Java 多态基础

多态的定义

　　程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在运行期间才确定。

　　或者是同一个行为具有多个不同表现形式或形态的能力。

多态的体现

　　在玩LOL时，W键是技能；而且不同英雄的W的效果是不一样的。

　　在吃鸡中，W是前进。

　　在Word中，W就在字母按键。

实现多条的条件

①    ：必须是存在继承关系父类/子类

②    ：子类对父类的方法进行重写

③    ：父类对象指向子类引用/向上转型

多态的简单示例

 /**
  * @author qiuling
  */
 public class AnimalTest {

     class Animal {
         public void eat (){
             System.out.println("动物进食.");
         }
     }

     /**
      * 多态条件1 发生继承关系
      */
     class Bird extends Animal {
         /**
          * 多态条件2 进行父类方法的重写
          */
         @Override
         public void eat() {
             System.out.println("小鸟吃虫子");
         }

         /**
          * 发生向上转型后 只能调用父类存在的属性或方法
          * Animal bird = new Bird(); bird.fly()无法进行调用
          */
         public void fly (){
             System.out.println("一只小鸟飞飞飞");
         }
     }

     class Dog extends Animal {
         @Override
         public void eat() {
             System.out.println("小狗吃肉");
         }
     }

     public static void main (String[] args){
         //多态条件3 父类对象指向子类的引用/向上转型
         Animal bird = new AnimalTest().new Bird();
         Animal dog = new AnimalTest().new Dog();
         bird.eat();
         dog.eat();
         //要调用子类特有的方法 只能向下转型
         ((Bird) bird).fly();
     }

写博客发现一个蛮有意思的例子

/**
 * @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);
    }
}

参考博文:https://my.oschina.net/langxSpirit/blog/1541074

　　　　https://www.cnblogs.com/chenssy/p/3372798.html