继承和多态（二）

一、继承

继承和多态（一）-CSDN博客

二、组合

继承和多态（一）-CSDN博客

三、多态

3.1 多态的概念

多态就是去完成某个行为时，不同的对象去完成时会产生不同的状态，通俗来讲就是有多种形态

3.2 多态的实现条件

1. 必须在继承体系下

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

3. 通过父类引用调用重写的方法

三者缺一不可

当传递不同类对象时，会调用对应类中的方法，体现出多态。

public class Animal {
    protected String name;
    protected int age;
    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public void eat() {
        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 + "吃狗粮");
    }
}
public class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "吃猫粮");
    }
}
public class Test {
    public static void eat(Animal animal) {
        animal.eat();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("jerry",2);
        Cat cat = new Cat("tom",4);
        eat(dog);
        eat(cat);
    }
}

3.3 重写

重写是子类对父类非静态，非priv修饰，非final修饰，非构造方法等的实现进行重写，返回值和形参都不改变，其优点是子类可以根据需要，定义自己的行为

方法重写的规则

1. 子类在重写父类方法时，一般必须与父类方法原型一致：返回值类型 方法名 （参数列表）要完全一致

2. 被重写的方法返回值类型可以不同，但必须是具有父子关系

3. 访问权限不能比父类中被重写的方法的访问权限低

4. 父类被static、final、private修饰的方法、构造方法都不能被重写

5. 重写的方法可以使用@Override注释来显示指定，有了这个注释能帮助我们进行一些合法性校验

重写和重载的区别

区别点	重写（override）	重载（overload）
参数列表	一定不能修改	必须修改
返回值类型	一定不能修改（除非可以构成父子类关系）	可以修改
访问限定符	一定不能做更严格的限制	可以修改

方法重载是一个类的多态性表现，方法重写是子类与父类的一种多态性表现

重写的设计规则

对于已经投入使用的类，尽量不要进行修改，而是重新定义一个新的类，来重复利用其中共性的内容并添加后改动新的内容

例如：以前的手机，只能打电话，发短信，来电显示只能显示号码，而今天不仅可以显示电话号码还可以显示头像，地区等。在这个过程中，我们不应该在原来老的类上进行修改，因为可能还有用户在使用，而是新建一个手机的类对来电显示这个方法进行重写就可以达到如今的需求

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

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

3.4 向上转型和向下转型

3.4.1 向上转型

向上转型就是创建一个子类对象，作为父类对象来使用

语法格式：父类类型 对象名 = new 子类类型（）

Animal animal = new Dog("jerry",3);

animal是父类类型，但是可以引用子类对象，因为是从小范围到大范围的转变。狗一定是动物，但动物不一定是狗。大范围囊括小范围是安全的。

使用场景

1. 直接赋值

2. 方法传递

3. 方法返回

public class Test {
    //2.方法传参：形参为父类的引用，可以直接接受任何子类的对象
    public static void eat(Animal animal) {
        animal.eat();
    }
    //3.做返回值：返回任意子类的对象
    public static Animal byEat(String str) {
        if("狗".equals(str)) {
            return new Dog("Jerry",1);
        }
        if ("猫".equals(str)) {
            return new Cat("Tom",2);
        } else {
            return null;
        }
    }
    public static void main(String[] args) {
        //1.直接赋值
        Dog dog = new Dog("jerry",2);
        Cat cat = new Cat("tom",4);
        //2.方法传参
        eat(dog);
        eat(cat);
        //3.做返回值
        Animal animal = byEat("狗");
        animal.eat();
        animal = byEat("猫");
        animal.eat();
    }
}

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

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

3.4.2 向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时可能需要调用子类特有的方法，此时：将父类引用在还原为子类对象即可，即向下转换。

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("jerry",2);
        Cat cat = new Cat("tom",4);
        Animal animal1 = dog;
        Animal animal2 = cat;
        dog = (Dog) animal1;
        dog.eat();
        cat = (Cat) animal2;
        cat.eat();
    }
}

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入 了 instanceof ，如果该表达式为true，则可以安全转换。

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("jerry",2);
        Cat cat = new Cat("tom",4);
        Animal animal = dog;
        animal.eat();
        animal = cat;
        animal.eat();
        if(animal instanceof Dog) {
            dog= (Dog) animal;
            dog.eat();
        }
        if(animal instanceof Cat) {
            cat = (Cat) animal;
            cat.eat();
        }
    }
}

3.5 多态的优缺点

1. 能降低代码的“圈复杂度”，避免使用大量的if-else语句

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

一段代码中条件语句和循环语句出现的个数n，n就是“圈复杂度”，一般不会超过10

public class Shape {
    public void draw() {
        System.out.println("画图形");
    }
}
class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("❀");
    }
}
class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("○");
    }
}
class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("♦");
    }
}

public class Test {
    public static void main(String[] args) {
        /*不基于多态
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        String[] shapes = {"rect","cycle","rect","flower"};
        for (int i = 0; i < shapes.length; i++) {
            if (shapes[i].equals("rect")) {
                rect.draw();
            }else if (shapes[i].equals("cycle")) {
                cycle.draw();
            }else if (shapes[i].equals("flower")) {
                flower.draw();
            } else {
                System.out.println("null");
            }
        }*/
        //基于多态
        Shape[] shapes = {new Rect(),new Cycle(),
                new Rect(),new Flower()};
        for (Shape shape :shapes) {
            shape.draw();
        }
    }
}

2. 可扩展能力更强

如果要增加一种新的形状，使用多态的方法代码改动成本也比较低

class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("△");
    }
}

对于调动者来说，只要创建一个新类的实例就可以了，改动成本很低，而对于不用多态的情况，就要把draw()中的if-else进行一定的修改，改动成本更高

多态缺陷：代码的运行效率降低

1. 属性没有多态性

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

2.构造方法没有多态性

3.6 避免在构造方法中调用重写方法

public class Base {
    public Base() {
        fuc();
    }
    public void fuc() {
        System.out.println("Base.fuc()");
    }
}
public class Derived extends Base{
    private int num = 1;
    /*public Derived() {
        super();
    }*/
    @Override
    public void fuc() {
        System.out.println("Derived.fuc()" + num);
    }
}
public class Test {
    public static void main(String[] args) {
       Derived derived = new Derived();
    }
}

在上面这段代码中，Base类中构造函数中调用了fuc()方法，并且此方法被子类Derived重写，此时的运行结果是什么？

构造Derived对象的同时，会调用Base的构造方法

Base的构造方法中还调用了fuc方法，此时会触发动态绑定，会调用到Derived中的fuc
此时Derived对象自身还没有构造，此时num处在未初始化的状态，值为零。如果具备多态性，num的值应该是1，所以在构造函数内，尽量避免使用实例方法，除了final和private方法

结论：“用尽量简单的方式是对象进入可工作状态”，尽量不要在构造器中调用方法（如果这个方法被子类重写，就会触发动态绑定，但此时子类对象还没构造完成），可能会出现一些隐藏但又不易发现的问题。