java封装/继承/多态深度思考

封装

        概念:

        在程序中简单理解封装就是把代码整合到一起! 函数的封装:就是把一组操作整合到一起;类的封装:就是把属性和方法整合到一起;结构的封装:根据操作的性质(模型/控制操作/交互视图)进行结构设计封装。

 具体操作：

        属性设置为private

        提供getter和setter

        基本类型的封装：Java中要保证所有的成员都是完全面向对象的,所以java为基本数据类型也设计了一套对象类型(单词一致,首字母大写)

                        byte -- Byte

                        short-Short

                        int-Integer

                        long-Long

                        float-Float

                        double-Double

                        char-Character

                        boolean-Boolean

        实际项目开发中, javabean中的成员(属性)的类型要求用封装类型

封装的目的：

封装解决程序的安全性问题。

狭义：用private声明字段，用public方法来声明bean方法，形成了JavaBean（user）。

广义：要将保护的成员都声明为私有，用封装公共方法对外提供访问操作。

        

继承

        我们发现，一个B类中的操作都实用于另一个类A，但另外一个类还多出一些个性方法，我们希望既有类操作，又能拓展个性化重要的需要由此产生了继承。

具体操作

        class Father{}

        class Son ==extends== Father{}

        extend: 得到,拓展 , java使用了动词形式 extends

public class Father {
	//父类 姓名和年龄属性
	private String name;
	private Integer age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Father(String name, Integer age) {
		this.name = name;
		this.age = age;
	}
	public Father() {
	}
	
	//公共的方法
	public void f1() {
		System.out.println(name+"今年"+age+"岁了");
	}
	
}

//子类
public class Sun extends Father{
	//拥有自己的字段
	private String money;

	public String getMoney() {
		return money;
	}

	public void setMoney(String money) {
		this.money = money;
	}

	public Sun(String name, Integer age, String money) {
		//super  实际上就是对父类成员的调用
		super(name, age);
		this.money = money;
	}

	public Sun() {
		super.f1();
	}
}
public class Main {
	public static void main(String[] args) {
		//实例化父类,并调用其方法
		Father father=new Father("张三",40);
		father.f1();
		//实例化子类,并调用父类的方法
		Sun sun=new Sun("张小二",18,"500");
		sun.f1();
		
	}
}

结果：        张三今年40岁了
               张小二今年18岁了
        以上代码段我们用了在继承的基础上同时运用了封装的思想，子类无法直接访问父类中的name属性和age，但子类却可以通过继承父类的构造方法super(),来完成调用与赋值，同时也调用了父类的方法，当然子类也可以重写@Override父类的方法  来展现自生的一个独特性。

    @Override
	public void f1() {
		System.out.println(this.getName()+"今年"+this.getAge()+"岁了"+money);
	}

    //输出的结果：张小二今年18岁了,挣了500元

作用

        Son:子类,派生类(subClass)。

        Father: 父类,超类,基类(superClass)。

        子类通过继承父类,得到了父类中的非私有的成员的访问。 

        继承解决程序的重用性的问题，可以有效的降低重复性代码。

注意：

        单继承：父类可以派生多个子类，但子类只能有一个父类，不能双向继承。

        调用顺序：继承不能直接调用目标类中的私有成员。

        Object：所有类的根父类都被java指定为Object类。

多态

        简单理解就是多种形态（对象、方法、属性等），既有存在的多种形态也有调用的多种形态

 方法的多态。

重载：

        在一个类中,存在一组方法,它们的方法名一致,但参数各不相同(数量或类型),这一组方法就构成了重载,用单词Overload表示。

作用：同一个方法可以通过不同的参数来达到不同的效果，例如我们常见的println()。

注意：重载和返回值无关， 构造方法、实例方法都可以实现重载。

重写：

        在继承过程中,如果子类声明了一个方法,和父类的方法声明完全一致,只有操作不同,父类和子类的方法就构成了重写。

作用: 让子类和父类具有相同的行为,但,执行方式却不同,为对象的多态准备。

注意：用单词Override表示,也被叫做覆盖，重写时,方法的声明部分(访问权限/返回类型/参数/方法名)都必须完全一致，子类访问权限可以小于等于父类。

对象的多态

        声明为高级类型(父类),传递引用的时候赋值为低级类型(子类), 声明对象就是上转型对象；上转型对象在执行到有重写的方法时,会执行子类(重写)；上转型对象可以调用父类中声明的方法(继承)；上转型对象不可以调用子类独有的方法。

//动物父类
public class Animal {
	
	public void shout() {
		System.out.println("动物的吼叫");
	}
	
	@Override
	public String toString() {
		return "不知名的生物";
	}

}

//猫子类
public class Cat extends Animal{
	
	// 子类独有的方法
	public void eatFish() {
		System.out.println("吃鱼");
	}
	
	// 重写父类的方法
	public void shout(int i) {
		System.out.println("喵喵喵");
	}
	
	@Override
	public String toString() {
		return "大橘";
	}
}

//上转型具体操作
public static void main(String[] args) {
		
		// 养了一群小动物
		Animal[] animals = new Animal[3];
		
		// 添加小动物
		animals[0] = new Animal();//动物的实例
		animals[1] = new Cat();  //猫的实例实际上就是上转型

        下转型对象：声明低级子类，传递引用时赋值给高级父类，在这里设计到封箱拆箱思想，在转化时我们会用到强转；

        // 声明的类型是父类类型, 实例化使用的是子类的构造
		// a就叫做上转型对象
		Animal a = new Cat();
		Object o = new Cat();
		
		// 利用上转型对象,在集合List设置为可以添加任意类型
		List<Object> list = new ArrayList<Object>();
		list.add(1);
		list.add("abc");
		list.add(a);
		list.add(o);
		
		// 上转型对象调用子类独有的方法, 不能
		// 只能调用父类的或重写的方法
		// a.eatFish();
		
		// 本质上是一个父类对象,强转为子类对象(下转型)可以编译通过,
		//但执行就会抛出异常:ClassCastException
		/*
		 * Animal animal = new Animal(); ((Cat)animal).eatFish();
		 */
		
		// 安全的下转型操作: 判断实例化时的对象类型
		Animal animal2 = new Cat();
		((Cat)animal2).eatFish();

多态的使用思想
        先构建父子的类型的体系；在使用类型的时候用父类作为高级的类型声明(兼容性,拓展)；只要声明新的子类类型,它和原有操作就完全兼容。

        最后提及多态我们不得不谈到抽象abstract、接口interface，后续我会用专门的文章进行进行讲解！！！看过的铁子们，觉得博主讲的还可以留下一个珍贵的赞吧！小白博主做这些真的不容易，希望大家鼓励鼓励！