【JavaSE】面向对象三大特性之一，多态

一、多态是什么

多态在我的理解就是当执行同一件事时，对象不同会导致实现结果不同。
在Java中就是由于向上转型和向下转型让对象调用同一个方法，执行的代码却不同。

二、多态实行条件

多态实行条件如下：

1. 必须在继承体系之下。
2. 子类必须对父类中的成员方法（重写方法数量>=1）进行重写。
3. 通过父类的引用调用重写的方法。

三、重写

3.1 重写的格式：

重写的格式有如下四种：

1. 返回类型相同，或者构成父子类关系。

2. 方法名相同。

3. 参数列表（个数，类型，顺序）相同。

4. 在重写的方法前一般要加上@Override注解。
   例如：

class Base{
	public void fun(int a){
		System.out.println(a);
	}
}
class A extends Base{
	@Override
	public void fun(int b){
		System.out.println(--b);
	}
}

3.2 重写的条件

重写的条件主要有如下3个：

• 重写的方法不能被private，static，final修饰 。

• 重写必须发生在继承体系下。

• 子类重写的方法的访问修饰权限必须大于父类的访问修饰权限。

3.3 重写与重载的对比

对比图如下：

四、向上转型

向上转型就是父类引用子类对象，将子类给到父类。

4.1 向上转型的方式

向上转型的方式有如下3种：

1. 直接引用`父类 变量名 = new 子类()。

2. 方法传参。

3. 方法返回值。

还是先将上面的两个类拿来，举例如下。

class Base{
	public void fun(int a){
		System.out.println(a);
	}
}
class A extends Base{
	@Override
	public void fun(int b){
		System.out.println(--b);
	}
}

下面直接用上面两个类举例理解：

4.2 直接引用父类 变量名 = new 子类();

Base base1 = new A();

4.3 方法传参

public void func(Base base2){

}
A a = new A();
func(a);

4.4 方法返回值

public Base func1(){
	Base base = new Base();
	return Base;
}
A a = new A();
a = func1();

4.5 向上转型结果

向上转型之后该对象就只能调用父类的成员了。

但是如果父类的成员在改子类被重写了，那调用该方法就调用的是子类重写方法，
这种现象就称为动态绑定。

public static void main(String[] args) {
	Base base1 = new A();
	base1.fun(2);
}

五、向下转型

向下转型也主要有如下3种方式（第一种最普遍）：

• 向下转型就是强制类型转换，只不过这个是将父类对象强制类型转换为子类对象。 格式就是子类对象 = (子类)父类对象;

• 方法传参。

• 方法返回值。

Base base2 = new Base();//当base有多个子类这种方式就会报错
A a = (A)base2;

Base base1 = new A();
A a1 = (A)base1;

5.1 向下转型的风险

当我们的父类是另一个子类向上转型过来的，那此时向下转型就会失败。

5.1.1 instanceof关键字

为避免上述情况我们就是要instanceof关键字。

public static void main(String[] args) {
	Base base1 = new A();
	base1.fun(2);
	Base base2 = base1;
	A a = (A)base2;
	Base base3 = new B();
	if(base3 instanceof A) {
		A a1 = (A)base3;
	}
}

六、多态优缺点

6.1 优点：

优点如下：

• 可以避免使用大量if-else。 如我们要求图形面积，我们要是有if-else判断是什么图形，在调用求该图形面积的方法。但是我们使用多态就不用。
• 代码更灵活。

public class Shape {
    public void are(int a) {
    }

    public static void main(String[] args) {
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        Shape[] shapes = {rect,cycle};
        for(Shape shape : shapes){
            shape.are(2);
        }
    }
}
class Rect extends Shape{
    @Override
    public void are(int a) {
    System.out.println(a*a);
    }
}
class Cycle extends Shape{
    @Override
    public void are(int a) {
    System.out.println(a*a*3.14);
    }
}

6.2 缺点

运行效率低。