多态

定义

同一消息根据发送对象的不同，采取不同的行为方式

多态存在的三个条件

1. 有继承
2. 有重写
3. 父类引用指向子类对象
   1. 指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性
   2. 而对于子类中存在而父类中不存在的方法，该引用是不能使用的
   3. 若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法

调用优先级

this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

当前类方法->父类方法->当前类方法(父类参数)->父类方法(父类参数)

即先查this对象的父类(有没有该方法)，没有就重头再查参数的父类。

    public class A {  
       static int a=1;
       int b=2;
        public String show(D obj) {  
            return ("A and D");  
        }  
      
        public String show(A obj) {  
            return ("A and A");  
        }   
    }  
    
    public class B extends A{  
      static int a=3;
      int b=4;
        public String show(B obj){  
            return ("B and B");  
        }  

        public String show(A obj){  
            return ("B and A");  
        }   
    }  
    public class C extends B{}  
    public class D extends B{}  
      
    public class Test {  
        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));   // A and A 
            System.out.println("2--" + a1.show(c));   // A and A 
            System.out.println("3--" + a1.show(d));   // A and D
            
            System.out.println("4--" + a2.show(b));   // B and A  
            System.out.println("5--" + a2.show(c));   // B and A 
            System.out.println("6--" + a2.show(d));   // A and D 
            
            System.out.println("7--" + b.show(b));    // B and B  
            System.out.println("8--" + b.show(c));    // B and B .
            System.out.println("9--" + b.show(d));    // A and D  
            
            System.out.println(a2.a);  //1
            System.out.println(a2.b);  //2 还是A的属性 子类的变量不能覆盖父类的变量
        }  
    } 
    
    
1. A中没有show(B)方法，B extends A 所以查找show(A) 即A.show(A)
2. 同上 c extends B,B extends A
3. A中有show(D) 

4. a2执行B的实例，所以遵循上面的规则，1 先查找A，没有show(B) 2 B extends A ，所以查找show(A) 3 因为A B中都有show(A),执行子类 即B.show(A)
5. 同上
6. 1 先找B 没有show(D) 再查找A 有show(D) 执行

7. B里有show(B) 执行
8. B里没有show(C) A里也没有 然后 B里找show(B) 有 执行
9. DCB里都没有show(D),A有 执行