Java 多态

Java 多态

---

多态是同一个行为具有多个不同表现形式或形态的能力。（ Animal a = new Dog(); 动物表现的是狗的特性，进而去用狗具有的特点（方法），但其实这种特点还是属于动物的，只是和动物这个大范围有区别，故运用方法的重写，覆盖了父类的方法）

多态就是同一个接口，使用不同的实例而执行不同操作

多态的优点

• 1.消除类型之间的耦合关
• 2.可替换性
• 3.可扩充性
• 4.接口性
• 5.灵活性
• 6.简化性

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象; (向上转型 )在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

比如：

Parent p = new Child();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

---

多态（概念）：

所谓多态，就是指一个引用（类型）在不同的情况下的多种状态。也可以理解为，多态是指通过指向父类的指针，来调用在不同子类中实现的方法。。

场景假设：

一个主人养了猫和狗，猫和狗都有自己爱吃的东西，主人在喂它们的时候，如果既要判断是猫还是狗，再判断他们分别爱吃什么，就显得很麻烦。如果主人养了很多种动物，这样的重复判断，就会浪费很多时间。有什么办法，能让主人拿到一种食物就知道这是哪种动物的，就好了。

一个完整的 代码实例：

1.首先，创造动物类：

// 动物类
class Animal {
    private int age;
    private String name;

    // 动物类里面有叫和吃两个方法
    public void cry() {
        System.out.println("我不知道叫什么");
    }

    public void eat() {
        System.out.println("我不知道吃什么");
    }
}

2.其次，分别创造猫类和狗类（他们继承于动物类）：

// 狗类继承于动物类
class Dog extends Animal {
    // 覆盖（重写）方法
    public void cry() {
        System.out.println("旺旺");
    }

    public void eat() {
        System.out.println("我是狗，我爱吃骨头");
    }
}

// 猫类继承于动物类
class Cat extends Animal {
    // 覆盖（重写）方法
    public void cry() {
        System.out.println("喵喵");
    }

    public void eat() {
        System.out.println("我是猫，我爱吃鱼");
    }
}

3.再者，创建食物类：

// 食物类
class Food {

    private String name;

    // 食物类里面让它有一个方法
    public void showName() {

    }
}

4.再者，猫和狗都有自己不同的爱吃的食物（他们继承于食物类）：

// 鱼（食物的一种）继承于食物
class Fish extends Food {
    public void showName() {
        System.out.println("食物：鱼");
    }
}

// 骨头（食物的一种）继承于食物
class Bone extends Food {
    public void showName() {
        System.out.println("食物：骨头");
    }
}

5.主人类（就可以将动物和对应的食物统一起来）：

// 主人类 存在一種餵食方法
class Master {
    // 给动物喂食物，如果没有多态，他要写给猫喂食和给狗喂食两个方法
    // 有了多态，以后即使再来好多动物，用这一个函数就可以了
    public void feed(Animal an, Food f) {
        an.eat();
        f.showName();

    }
}

6.最后，方法的调用（测试）：

public class Polymorphic {

    public static void main(String args[]) {

        Master master = new Master();
        Animal4 dog = new Dog4();
        Animal4 cat = new Cat();

        Food bone =  new Bone();
        Food fish =  new Fish();

        master.feed(dog, bone);
        master.feed(cat, fish);

    }
}

//输出结果：
/*
我是狗，我爱吃骨头
食物：骨头
我是猫，我爱吃鱼
食物：鱼

Process finished with exit code 0

*/

静态多态和动态多态

多态分为编译时多态和运行时多态。其中编辑时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。

Java提供两种多态机制：重载与重写。

方法的重写Overriding和重载Overloading是Java多态性的不同表现

重写Overriding是父类与子类之间多态性的一种表现

重载Overloading是一个类中多态性的一种表现

idea中

反汇编时看到的是基类的实例调用基类的方法，而运行的是派生类的方法

动多态：发生在运行时—invokevirtual

静多态：发生在编译时—invokestatic

参考：

https://www.cnblogs.com/1693977889zz/p/8296595.html

http://www.runoob.com/java/java-polymorphism.html

                                         2018.11.03/周六
                                         by 922