java面向对象特性之一多态

我觉得在学习一个新知识时，第一概念和认知非常重要，这种概念会把你引向正确的道路，反之，你可能会在十字路口左右徘徊…

抽象概念：

按照多态这两个字的字面意思，首先形态、形式，修饰词：多种…

运行时多态：

举个栗子：

动物，它的表现形式就有猪、狗、猫等等，它们都有共同的特性：要吃饭，不过狗吃的是骨头，猪吃的是糠。

*他们都是动物的一种(继承)；

public class Animal(){
    public String eat(){
        return "eat";
    }
}

public class Pig extends Animal(){}

*都有动物的技能：吃,不过吃的东西不一样(重写)；

public class pig extends Animal(){
    @Override
    public String eat(){
        return "Eat bran";
    }
}

*它是猪，但他的种类、对象类型是动物(父类引用指向子类对象…)；

Animal pig=new Pig();

编译时多态，被static、final修饰的等：

是靠重载实现的，即和父类同名方法但参数列表不同，返回值可以相同可以不相同，构造器就是重载的

public class S {
    public String number(){
        return "parent";
    }
}

public class D extends S {
    public String number(String s){
        return "child";
    }
}

关于多态的方法调用，看优先级：

this.show(O) --> super.show(O) --> this.show((super)O) --> super.show((super)O)

Animal animal=new Dog();

这个this指的就是Animal，animal方法的调用先看Animal类有没有，如果没有被子类重写的，直接调用的是Animal这个类的方法，如果被子类重写了，那就调用子类的重写后的方法

说到多态，拿经典的一题来举例说明，做完这道题，对多态的特性会更有帮助：

A类

public class A {
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    }
}

B类

public class B extends A {
    public String show(B obj){
        return ("B and B");
    }

    public String show(A obj){
        return ("B and A");
    }
}

C类

public class C extends B {}

D类

public class D extends B {}

题目

public class demo3 {
    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));
    }
}

答案在下面，先看思路：

先看一段经典却又拗口的概念:当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的。

栗子：

Aniaml animal=new Dog();

Dog类是被引用对象，当基类Animal类有一个eat()方法，并且被子类Dog类重写，就会调用Dog类的eat()方法。换句话说，当父类引用变量引用子类对象时，调用的是一定是子类的同名方法。子类特有的方法不能被调用，父类特有的方法可以。

因多态的机制，调用顺序优先级为：

this.show(O) --> super.show(O) --> this.show((super)O) --> super.show((super)O)

再开始说具体的解题思路：

第1、2、3个都是一个思路，所以只拿第一个举例说明。

a1.show(b);

直接找本类方法中有没有show(B)方法，结果是没有，那按照优先级找父类，父类Object肯定是没有这个方法的，那到第三优先级，看A类的show()方法中有没有参数是B类的基类的，那么就找到了show(A obj)这个方法。

a2.show(b);

由于a2是A类型，this指的就是A类，在A类中没有找到—>按优先级到A类的父类，Object排除后没有父类—>又回到到A类，b是B类型，它符合A类的show(A)方法，但是同时a2是B类的引用而且重写了这个方法，所以调用B类的这个方法

a2.show(c);

上面已经讲过了a2是A类型，第一步在A类中找没有这个方法—>没有父类—>再到A类中找，c的超类是A，符合A类的show(A)方法，且B类重写了这个方法，所以调用B类的show(A)

a2.show(d);

在A类中直接找到了…

b.show(b);

在B类中直接找到了…

b.show(c);

在B类中没有找到—>A类中也没有找到—>B是c的父类，所以B类的show(B)方法就是了

b.show(d);

在B类中没有找到—>在A类中找到了，B b=new B()不涉及多态，重写什么的就不必再看了

答案：

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

这道题想当初我初次学到多态的时候看是完全是懵的，就放在那里没有管它，直到一次面试，我俩又相遇了…

这道题关键点，摸清多态调用优先级，理解this到底是哪个类，就很容易了，最重要的是活学活用，换个衣服你认不出来就太无情了…