java面向对象系列（四）——多态

多态

通俗来讲就是多种形态，完成某个行为，不同的对象会有不同的结果和状态！总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。

（1）多态的实现条件

1. 必须在继承体系下

2. 子类必须要对父类中方法进行重写

3. 通过父类的引用调用重写的方法（ 调用方法的形参类型必须时父类类型才可以 ）

class Animal {
    String name;
    int age;
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}
class Cat extends Animal{
    public Cat(String name, int age){
        super(name, age);
    }
    @Override
    public void eat(){
        System.out.println(name+"吃鱼~~~");
    }
}
class Dog extends Animal {
    public Dog(String name, int age){
        super(name, age);
    }
    @Override
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
}
public class TestAnimal {
    public static void eat(Animal a){   //此处形参类型必须是父类类型
        a.eat();
    }
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
        eat(cat);
        eat(dog);
    }
}

程序员在编写 eat 这个方法的时候 , 参数类型为 Animal ( 父类 ), 此时在该方法内部并 不知道 , 也不关注 当前的 a 引用指向的是 哪个子类 的实例 . 此时 a  这个引用调用 eat 方法可能会有多种不同的表现 ( 和 a 引用的实例相关), 这种行为就称为 多态。

静态绑定 ：也称为前期绑定 ( 早绑定 ) ，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。

动态绑定 ：也称为后期绑定 ( 晚绑定 ) ，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

（2）向上转型和向下转型

1.向上转型

实际就是创建一个子类对象，将其当成父类对象来使用。 语法格式：父类类型 对象名 = new 子类类型()；

Animal animal = new Cat("元宝",2);

 animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

使用场景：

1.直接赋值

Animal cat = new Cat("元宝",2);

2.方法传参

public static void eatFood ( Animal a ){

a . eat ();

}

3.方法返回

public static Animal buyAnimal ( String var ){

if ( " 狗 " . equals ( var ) ){

return new Dog ( " 狗狗 " , 1 );

}

 注意：

向上转型的优点：让代码实现更简单灵活。

Animal animal = cat;

animal.eat();

animal = dog;

animal.eat();

向上转型的缺陷：不能调用到子类特有的方法。

2.向下转型

子类对象经过向上转换之后再也不能使用子类独有的方法，但有时需要用到子类的独有的方法，此时将父类引用再还原为子类对象即可，即向下转型；

为了提高向下转型的安全性，java提供了 instanceof 关键字，如果表达式返回值为true，则安全转换；

if ( animal instanceof Cat ){

cat = ( Cat ) animal ;

cat . mew ();

}

 注意：

向下转型用得很少，因为一旦转换失败，编译器就会抛出异常

 （3）多态的优缺点

1.优点

(1)降低代码“圈复杂度”，避免使用大量的if-else语句，例如：

class Animal{
    public void fun(){
        System.out.println("动物");
    }
}
class Cat extends Animal{
    @Override
    public void fun() {
        System.out.println("猫");
    }
}
class Dog extends Animal{
    @Override
    public void fun() {
        System.out.println("狗");
    }
}
public class Text{
    public static void main(String[] args) {
        Animal[] animals = {new Cat(),new Dog()};
        for (Animal animal:animals){//此处就不用重复if（...equals....）语句
            animal.fun();
        }
    }
}

(2)可以提高可扩展能力

如果要在以上代码加入一种新的动物，多态改动的代码较少，只需加入一个类

class Bird extends Animal{
    @Override
    public void fun() {
        System.out.println("鸟");
    }
}

2.缺点

运行效率低下

1.子类与父类同名的情况下，通过父类访问只能引用父类成员。 

2.构造方法没有多态性，避免在构造方法中调用重写方法(会有动态绑定)。