【JavaSE】面对对象程序三大特性之多态

一、何为多态

什么是多态呢？

通常来说，是多种形态；

具体来说，在完成某个行为时，不同的对象去完成时会产生不同的状态

就像动物都会吃饭，但是不同的动物吃的食物并不同，狗吃狗粮、猫吃猫粮等等

多态实现的条件

多态实现要满足三个条件，缺一不可：

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法 

我们现在先用动物的例子来简单实现一下多态 

public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(name + "正在吃饭");
    }

    public void show(){
        System.out.println(name + "正在跑");
    }
}

public class Cat extends Animal{

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "正在吃小鱼干");
    }

    @Override
    public void show() {
        System.out.println(name + "正在喵喵叫");
    }
}

public class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "正在吃骨头");
    }

    @Override
    public void show() {
        System.out.println(name + "正在汪汪叫");
    }
}

public class Test {
    public static void eat(Animal a){
        a.eat();
}
    public static void show(Animal a){
        a.show();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("旺财",1);
        Cat cat = new Cat("花花",2);
        eat(dog);
        show(dog);
        System.out.println("------------------");
        eat(cat);
        show(cat);
    }
}

多态的优缺点 

多态的优点 

1.能够降低代码的 "圈复杂度", 避免使用大量的 if - else

（圈复杂度是一种描述一段代码复杂程度的方式。一段代码如果平铺直叙，那么就比较简单容易理解； 而如果有很多的条件分支或者循环语句，就认为理解起来更复杂）

2.可扩展能力更强

多态的缺点 

代码的运行效率低 

1.属性没有多态性

（当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性） 

2.构造方法没有多态性 

二、何为重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变 

方法重写的规则：

• 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
• 被重写的方法返回值类型可以不同，但是必须是具有父子关系的
• 访问权限不能比父类中被重写的方法的访问权限更低
• 父类被static、private修饰的方法、构造方法都不能被重写。
• 重写的方法, 可以使用 @Override 注解来显式指定

区分重写与重载

区别点	重写	重载
参数列表	一定不能修改	必须修改
返回类型	一定不能修改	可以修改
访问限定符	一定不能做更严格的限制	可以修改

三、向上转型与向下转型

（一）向上转型

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用 

语法格式：

        父类类型 对象名 = new 子类类型()

public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(name + "正在吃饭");
    }

    public void show(){
        System.out.println(name + "正在跑");
    }
}

public class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "正在吃小鱼干");
    }

    @Override
    public void show() {
        System.out.println(name + "正在喵喵叫");
    }
}

public class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "正在吃骨头");
    }

    @Override
    public void show() {
        System.out.println(name + "正在汪汪叫");
    }

    public void run(){
        System.out.println(name + "正在奔跑");
    }
}

public class Test {
    public static void eat(Animal a){
        a.eat();
    }
    public static void show(Animal a){
        a.show();
    }
    public static void main(String[] args) {
        Animal dog = new Dog("旺财",1);
        Animal cat = new Cat("花花",2);
        eat(dog);
        show(dog);
        //dog.run();
        System.out.println("------------------");
        eat(cat);
        show(cat);
    }
}

向上转型

        优点：让代码实现更简单灵活。
        缺陷：不能调用到子类特有的方法。 

（二）向下转型

public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(name + "正在吃饭");
    }

    public void show(){
        System.out.println(name + "正在跑");
    }
}

public class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "正在吃小鱼干");
    }

    @Override
    public void show() {
        System.out.println(name + "正在喵喵叫");
    }
}

public class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "正在吃骨头");
    }

    @Override
    public void show() {
        System.out.println(name + "正在汪汪叫");
    }

    public void run(){
        System.out.println(name + "正在奔跑");
    }
}

public class Test2 {
    public static void main(String[] args) {
        Cat cat = new Cat("咪咪",1);
        Dog dog = new Dog("小黄",1);

        //向上转型
        Animal animal = cat;
        animal.eat();
        animal = dog;
        animal.eat();


        //向下转型
        //直接强转
        dog = (Dog) animal;
        dog.run();

        cat = (Cat) animal;
        cat.show();
    }
}

我们也可以利用instanceof进行转换

public class Test2 {
    public static void main(String[] args) {
        Cat cat = new Cat("咪咪",1);
        Dog dog = new Dog("小黄",1);

        //向上转型
        Animal animal = cat;
        animal.eat();
        animal = dog;
        animal.eat();


        //向下转型

        if (animal instanceof Dog){
            dog = (Dog) animal;
            dog.run();
        }
        if (animal instanceof Cat){
            cat = (Cat) animal;
            cat.show();
        }
    }
}

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。

Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换 

四、静态绑定与动态绑定

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表方法重载。
动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。 

注：

        "用尽量简单的方式使对象进入可工作状态", 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题