一、什么是多态？

多态的词组字面意思是： 某种事物多种形态。
但是对于我们学习Java 的程序原来说，就不不能简单这样来理解了。
多态是 完成某个行为，不同的对象去实现会有不同的效果。现在还看不懂其实没关系，也就简单提一嘴。

举个栗子：

有一天，学校二食堂做了一大盘深海大闸蟹，你和小帅同时在排队。此时一位长得very beautiful 的女生——小美来了，到窗口看了一下菜，感觉不错，也想吃。但是排队的人太多了，就想插下队。你一看，我丢想插队，门都没有，表现出不肯的样子。而你后面的小帅眼睛一亮，就说，小美同学你好，我看你插队的话影响不好，不如我多打一份给你，倒时候加个微信发我就行了。此时这就是多态，不同的人对一件事表现出不同的状态。到头来‘你’还在为什么，自己还单身着。小帅到后面，小美微信也加了，说：就一顿饭钱也没多少，算了算了。此时小美就非常感动，说：小帅同学下次我会请你吃一顿。这样一来而去。。。

磨刀不误砍柴功，要想学真正学会多态，就要理解一下，向上转型是怎么转的？静态绑定是怎么绑定的，方法的覆盖是？最后，学完才可以说学会了Java 的多态，太哇塞了！！！

二、转型

向上转型

向上转型： 父类 引用 子类型对象
也好理解 儿子孝顺父亲，给父亲买点礼物，父亲乐意地接受了。

例子：创建一个父类 Animal 其子类有Dog， Cat
测试类 Test

public class Animal {
    public String name;
    //无参构造方法
    public Animal() {

    }
 	//有参构造方法
    public Animal(String name) {
        this.name = name;
    }

	//动物会说方法
    public void speak() {
        System.out.println("会说话-----------");
    }

}

public class Cat extends Animal{
	//无参构造方法
    public Cat() {
    }

	//有参构造方法
    public Cat(String name) {
        super(name);//子类继承父类，就要先对父类进行初始化
    }
    public void speak() {
        System.out.println(this.name+"会喵喵叫-----");
    }

}

public class Dog extends Animal{
	//无参构造方法
    public Dog() {
    }
	//有参构造方法
    public Dog(String name) {
        super(name); //子类继承父类，就要先对父类进行初始化
    }
    
    public void speak() {
        System.out.println(this.name+"会汪汪叫------");
    }
    
    //dog 特有的方法
    public void lookHouse() {
        System.out.println(this.name+"会看家-----------");
    }
    
}

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog("小黑");
        dog.speak();
        
       Animal cat = new Cat("小咪");
       cat.speak();


    }
}

有三种表示方式
1.直接赋值

2.方法传参

3.返回值

总结
优点 父类可以接受任何的子类

又创建了一个Cat 类 ，也是可以接受的。

缺点 不能调用子类特有方法，因为你还是Animal 类！

向下转型

父类强转子类

Animal 转为 Dog子类
a instanceof b ： 判断 a 是否为b类型 。是返回 true ,否返回false

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("小黑");

        if(animal instanceof Dog) { 
            Dog dog = (Dog)animal;
            
            //可以 调用子类特有的方法
            dog.lookHouse();
        }


    }
}

注意了 强转是要注意 子类一致
一开始是狗，怎么强转成猫呢？
就像养一只小狗，再怎么养，也不会变成小猫。因为一生下来就决定了的。

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("小黑");
        
        
        Cat cat = (Cat) animal; //error
        cat.speak(); //error
    }
}

总结：

三、方法覆盖与方法重载

方法重载： 我想大家都应该知道：就是在同一个类中，方法名相同，参数列表不同。就只要记住一个方法名，就可以调用不同的参数列表，提高了效率。

以add() 加法为例子：

public class Test {
    public static void main(String[] args) {

        System.out.println("方法重载");
        //相同 add方法名，不同参数列表。构成方法重载
        System.out.println(add(1,5));
        System.out.println(add(1,2,3));
        
    }

	
    public static int add(int a,int b) {
        return a+b;
    }
    
    public static int add(int a,int b,int c) {
        return a+b+c;
    }
}

方法覆盖: 也叫方法重写。发生在父子类之间的关系，方法名相同，参数列表相同，返回值也要相同。
也好理解，重写是重新再写一遍呗，不改变原来的。
父类的方法完成不了子类的需求，就要重写。

方法覆盖也存在一些细节：
1.static ，final ，private 修饰的方法，构造方法 不能被重写。
2.子类重写的方法，访问权限要 >= 父类 原来的方法。
3.重写方法的返回值类型也可不同，但是要构成父子类关系。

四、绑定

动态绑定

动态绑定是理解多态的基础。
那什么是动态绑定呢？
程序在编译的时候，确实是调用了父类的方法。但在运行的时候，通过父类的引用，调用的却是子类重写父类的那个方法。这就叫动态绑定。

还是以之前的Animal ，Dog 为例子：
不是输出： 会说话-------

静态绑定

“静态绑定"也称为"早期绑定”。
简单 就相当于平时调用方法 。就是调用这个方法时，编译器确定调用这个方法。

public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        
        test.func(); //确定调用func()

    }

    public  void func() {
        System.out.println("我就是一个普通的方法------");
    }
}

五、理解多态

现在，我们学习了
向上转型 就是父类型 引用 子类型对象 ，方法的重写是 父类的方法完成不了子类的需求，就要重写。 静态绑定：运行是调用子类重写父类的方法。

请看

public class Test {
    public static void main(String[] args) {

        Animal dog = new Dog("小黑");
        Animal cat = new Cat("小花");
        autoSpeak(dog);
        autoSpeak(cat);
    }
    public static void autoSpeak(Animal animal) {
        animal.speak();
    }
}

autoSpeak() 方法就会自动的调用 子类的speak（）方法。
不要判断 是否为 Dog 类 还是 Cat 类。
1.能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
2.可扩展能力强。