Java 多态基础

 1 /**
 2  * @author qiuling
 3  */
 4 public class AnimalTest {
 5 
 6     class Animal {
 7         public void eat (){
 8             System.out.println("动物进食.");
 9         }
10     }
11 
12     /**
13      * 多态条件1 发生继承关系
14      */
15     class Bird extends Animal {
16         /**
17          * 多态条件2 进行父类方法的重写
18          */
19         @Override
20         public void eat() {
21             System.out.println("小鸟吃虫子");
22         }
23 
24         /**
25          * 发生向上转型后 只能调用父类存在的属性或方法
26          * Animal bird = new Bird(); bird.fly()无法进行调用
27          */
28         public void fly (){
29             System.out.println("一只小鸟飞飞飞");
30         }
31     }
32 
33     class Dog extends Animal {
34         @Override
35         public void eat() {
36             System.out.println("小狗吃肉");
37         }
38     }
39 
40     public static void main (String[] args){
41         //多态条件3 父类对象指向子类的引用/向上转型
42         Animal bird = new AnimalTest().new Bird();
43         Animal dog = new AnimalTest().new Dog();
44         bird.eat();
45         dog.eat();
46         //要调用子类特有的方法 只能向下转型
47         ((Bird) bird).fly();
48     }

/**
 * @author qiuling
 */
public class Test {
    class A {
        public void show(D obj) {
            System.out.println("A and D");
        }
        public void show(A obj) {
            System.out.println("A and A");
        }
    }
    class B extends A{
        /**
         * 此方法其实是对 本类覆写父类方法的重载
         * A a2 = new Test().new B();向上转型后不会调用此方法
         * @param obj
         */
        public  void show(B obj) {
            System.out.println("B and B");
        }
        @Override
        public void show(A obj) {
            System.out.println("B and A");
        }
    }
    class C extends B{
    }
    class D extends B{
    }

    public static void main(String[] args){
        A a1 =  new Test().new A();
        A a2 = new Test().new B();
        B b =new Test().new B();
        C c = new Test().new C();
        D d = new Test().new D();
        //A and A
        a1.show(b);
        //A and A
        a1.show(c);
        //A and D 前三个应该没问题
        a1.show(d);
        //B and A 向上转型后不会调用show(B obj)
        //a2的声明类型为A，方法从A类开始搜索，A类没有show(B obj)的方法
        //兼容找到show(A obj),因为a2的实际类型为B类,B类覆写了show(A obj),故是 B and A
        a2.show(b);
        //B and A
        a2.show(c);
        //A and D
        a2.show(d);
        //B and B 继承关系调用方法顺序，从本类到父类
        b.show(b);
        //B and B
        b.show(c);
        //A and D
        b.show(d);
    }
}