Java多态

声明：该博客参考1：Java中的多态 <2>：什么是多态？如何实现？只看这一篇就够了

多态概念

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作。
多态是继封装、继承之后，面向对象的第三大特性。

两种多态：重写式多态和重载式多态。

1. 重写式多态（运行时多态）
   通过动态绑定（dynamic binding）技术来实现，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
2. 重载式多态（编译时多态）
   调用这种重载的方法时，通过传入不同的参数最后得到不同的结果。

多态的实现方式

方式一：重写：
方式二：接口
方式三：抽象类和抽象方法

向上转型

//实例：
public class Animal {
    public void eat(){
        System.out.println("animal eatting...");
    }
}
 
public class Cat extends Animal{
 
    public void eat(){
 
        System.out.println("我吃鱼");
    }
}
 
public class Dog extends Animal{
 
    public void eat(){
 
        System.out.println("我吃骨头");
    }
 
    public void run(){
        System.out.println("我会跑");
    }
}
 
public class Main {
 
    public static void main(String[] args) {
 
        Animal animal = new Cat(); //向上转型
        animal.eat();
 
        animal = new Dog();
        animal.eat();
    }
 
}
 
//结果:
//我吃鱼
//我吃骨头
//这就是向上转型，Animal animal = new Cat(); 将子类对象 Cat 转化为父类对象 Animal。

注意点：

1. 向上转型时，子类单独定义的方法会丢失
2. 子类引用不能指向父类对象。

好处：

1. 减少重复代码，使代码变得简洁。
2. 提高系统扩展性。

向下转型

class A {
    public String show(D obj) {
        return ("A and D");
    }
 
    public String show(A obj) {
        return ("A and A");
    }
 
}
 
class B extends A{
    public String show(B obj){
        return ("B and B");
    }
 
    public String show(A obj){
        return ("B and A");
    }
}
 
class C extends B{
 
}
 
class D extends B{
 
}
 
public class Demo {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
 
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));
    }
}
//结果：
//1--A and A
//2--A and A
//3--A and D
//4--B and A
//5--B and A
//6--A and D
//7--B and B
//8--B and B
//9--A and D

注意点：

1. 向下转型的前提是父类对象指向的是子类对象（也就是说，在向下转型之前，它得先向上转型）。
2. 向下转型只能转型为本类对象（猫是不能变成狗的）。
3. 当父类对象引用变量引用子类对象时，被引用对象的类型决定了调用谁的成员方法，引用变量类型决定可调用的方法。如果子类中没有覆盖该方法，那么会去父类中寻找。

重载、覆盖(重写)、隐藏(重定义)的对比