java的多态性

面向对象(多态性)

2.1、子类对象的创建过程

实例化子类对象的过程：

• 1、先调用父类的构造方法
  • 默认调用父类的无参构造方法。
• 2、再调用子类的构造方法

我们通过代码演示，发现当创建子类对象的时候，默认会先调用父类的构造方法。

调用子类的构造方法中，先调用了父类的构造方法，默认调用的父类的无参构造方法。
1、子类的构造方法中，第一行一定是调用了父类的构造方法。
2、如果没有显示的调用父类的构造方法，那么编译器会自动添加一个：super()，父类的无参构造方法。
3、子类的构造方法中，既可以调用父类的无参构造方法，也可以调用父类的有参构造方法。
4、父类的构造方法：
    		无参构造：super();
			有参构造：super(参数);

2.2、super关键字

用法一：super()，指代父类的构造方法。

​ 如果有多个父类的构造方法，那么要靠参数区分。

​ super()，无参构造

​ super(参数)，父类的有参构造方法。。

​ 注意点：super()，指代父类的构造方法，一定是位于第一行。同this()指代本类构造方法。

方法二：直接访问父类的属性和方法

​ super.属性—>父类的属性。

​ super.方法—>父类的方法

this.属性

this.方法

2.3、方法的重写

重载(overload)：一个功能方法的多种写法。

​ 同一个类中，方法名必须一致，参数列表必须不同。

重写(override)：继承结构。

概念：在继承结构中，子类将父类已有的方法，重新实现，这叫方法的重写。

如果在子类中，存在方法的重写，那么默认调用的是重写之后的方法。

方法重写的规则：

1、继承结构中。
2、方法的声明，必须和父类的一致。
	方法名必须和父类一致
	参数列表必须和父类一致
	返回值必须和父类一致
3、访问权限，不能比父类更加严格。
4、子类重写的方法，不能抛出比父类更大更多的异常。

/*
		 * 1.父类的方法，访问权限：public
		 *   子类重写，只能public
		 * 2.父类的方法，访问权限：protected
		 * 	 子类重写，protected，public
		 * 3.父类的方法，访问权限：default
		 * 	  子类重写，default，protected，public
		 * 4.父类的方法，访问权限：private
		 	 对于子类来讲，该方法根本不可见。
		 */

2.4、访问权限修饰符

访问权限：就是在哪能访问。通过访问权限修饰符来实现。

​ 作用：限制可见度。

private：私有的。本类中。

默认的：(default)：注意，啥修饰符都不写，就是默认的。本类。同包下可以访问。

protected：受保护的。本类，同包下，不同包(子类使用)

public，没有限制的。

private—> default—>protected—>public

使用原则：

• 修饰类：只能是public和default
• 修饰成员：变量和方法：以上4个修饰符都可以。
• 局部变量，不能使用这些修饰符。

2.6、向上转型和向下转型

向上转型：一个子类对象看成了父类类型。那么就失去了子类新增。

Animal a2 = new Cat();//
a2,本身是子类对象，但是看成父类类型。
那么能够访问父类的属性，不能访问子类的新增属性。
能够访问方法，以及子类重写的方法。

2.1、对象的多态性

指的是子类对象的多种形态：

​ 子类对象—>看成父类的类型。

​ 子类对象—>看成子类的类型。

1、如果声明了一个父类类型的引用(=左边)，创建的是父类的对象(=右边)。
	可以访问父类的属性和方法。（不能访问子类的）
2、如果声明了一个子类类型的引用(=左边)，创建的也是子类的对象(=右边)。
	可以访问父类的属性和方法。
	还可以访问子类的新增。
	以及子类的重写。
	
3、如果声明了一个父类类型的引用(=左边),但是实际上指向了一个子类对象。(=右边)
	可以访问父类的属性和方法。
	以及子类重写的方法。但是不能访问子类的新增。
	

2.2、向上转型和向下转型

向上转型：一个子类对象，看成了父类的类型。（自动转换）

​ 那么只能访问父类的属性和方法，以及子类重写的方法。失去了子类的新增。

向下转型：向上转型后，子类对象看成了父类类型，然后再看成子类类型。（强制转换）

​ 可以重新访问子类的新增属性和方法。

向下转型的注意点：不是所有的父类引用都能转成子类类型。向下转型的前提：是一个子类对象先向上转型了，再转回来，那是可以的。但是如果没有向上转型，直接父类对象转为子类类型，报错：ClassCastException。

看一个引用，能够访问哪些成员：

​ 看=左边是什么类型的声明：

​ 父类类型：那么能够访问父类中声明属性和方法。

看一个引用，具体执行的方法，是否重写了：

​ 看=右边是什么类型的对象：

​ 如果是父类的对象，执行没有重写的方法，父类的方法。

​ 如果是子类的对象，执行的是重写的方法，子类重写后的方法。

2.3.2 instanceof

子类对象向上转型，为父类的类型。自动完成。
但是把一个父类的引用，再转回子类类型。就可能会存在问题。

语法：引用 instanceof 类名
	得到的结果：boolean类型
	
对于对象的多态性，如果想向下转型，那么应该先加个逻辑判断。判断该引用指向对象是否是要转换的类型。否则的话，会产生错误：ClassCastException，打断程序的执行。
所以：所有的向下转型之前，都应该使用instanceof进行判断。
    
    向上转型不需要：子类 is a 父类
    

2.3.3 对象的多态性的应用

如果一个方法，接收了父类类型作为参数，那么实际上传入父类对象和其他的任意子类对象都可以。

​ 如果传入子类对象的话，会发生对象的向上转型。

2.3、多态性

多态性：事物的多种形态。

​ 方法：方法的多种形态，指的就是方法的重载。一个功能方法，但是根据参数不同，执行的具体方法也不同。叫做静态多态。程序编译时发生的多态。

​ 对象：对象的多态性，结合方法的重写。一个子类对象，如果看成父类的类型，那么执行的方法就只能父类的以及子类重写的。如果再把该对象向下转型转为子类类型，才可以执行子类的新增方法。

1、方法的重载：
	public void getSum(int i,int j){
	
	}
	public void getSum(double d1,double d2){
	
	}
2、对象的多态性：子类对象。看成父类类型(向上转型)，或者看成子类类型(向下转型)。
   方法的重写：
   Animal a = new Animal();//父类类型引用，只能执行父类的方法。
		父类的方法。不是重写的
   Animal a1 = new Cat();//父类类型引用，执行重写后的方法。父类的方法。
		子类重写后的方法。
            
   Cat c1 = (Cat)a1;//子类类型的引用，执行的值重写后的方法，以及子类的新增方法