【Java0基础学Java第八颗】 — 继承与多态

本文介绍: 重写是子类对父类非静态、非private 修饰，非final 修饰，非构造方法等的实现过程进行重新编写, **返回值和形参都不能改变。**重写的好处在于子类可以根据需要，定义特定于自己的行为。当在父类的构造方法当中，调用父类和子类同名的方法时候，此时也会发生动态绑定。同一个引用调用了同一个方法，当是因为引用的对象不一样，所表现的行为不一样，称为多态。就比如打印机，彩色打印机和黑白打印机，打印出的效果一个是彩色，一个是黑白。即：方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现。

8.继承与多态

8.2 多态

8.2 多态

8.2.1 多态的概念

通俗来说就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
就比如打印机，彩色打印机和黑白打印机，打印出的效果一个是彩色，一个是黑白。

即：同一件事情，发生在不同对象身上，就会产生不同的结果。

8.2.2 多态 实现 条件

在Jav a中要实现多态，必须要满足以下条件：

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

多态的体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。

8.2.3 重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, **返回值和形参都不能改变。即外壳不变，核心重写！**重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。
重写的规则：

方法名一样
参数列表相同（个数、数据类型、顺序）
返回值一样

注意: 不能被重写的4种情况

被final修饰的方法不可以被重写。这个方法叫做密封方法。

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

被static修饰的方法不能被重写

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

子类重写父类方法的时候，子类的方法访问修饰限定符要&g t;=父类

// 父类的方法  
//当父类的方法修饰限定符是 默认defau时，子类的方法访问修饰限定符可以是protected、public
public void eat() {
        System.out.println(this.name+" 正在吃。。。");
    }
    
//子类的方法 
public void eat() {
        System.out.println(this.name+" 正在吃狗粮...");
    }

1. 被private修饰的方法是不被重写的

重写和重载的区别：
重写的方法名和参数都一样，而重载的方法名相同，参数不同。
即：方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现。

通过反汇编代码：
在这里插入图片描述

动态绑定：子类和父类都有编译得时候认为还是确认调用了父类得eat方法
运行得时候绑定到子类当中

父类引用引用子类对象；
通过父类引用去调用父类和子类同名的方法。

静态绑定：编译的时候就已经确定调用哪个方法了，如下 dog.b ar ks(10)；
在这里插入图片描述

8.2.4 向上转型和向下转型

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

直接赋值

Animal animal = new Dog("旺财",10,"红色"); //直接赋值

方法传参

	// 方法传参 ：形参作为父类引用，可以接受任意子类的对象
    public static void fun(Animal animal) {
        animal.eat();// 发生了多态
    }

    public static void main(String[] args) {
        Dog dog = new Dog("旺财",3,"红色");
        fun(dog);

        Bird bird = new Bird("布谷",1);
        fun(bird);
    }

在这里插入图片描述

同一个引用调用了同一个方法，当是因为引用的对象不一样，所表现的行为不一样，称为多态。

方法返回

	//  通过返回值，进行向上转型
    public static Animal fun2() {
        return new Dog("旺财",3,"红色");
    }

向下转型能让代码变得更加简单灵活，缺点就是不能调用到子类特有的方法。

8.2.5 向下转型

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

    public static void main(String[] args) {
        Animal animal2 = new Bird("布谷",1);
        //animal2.eat();
        //animal2.fly();

        Bird bird = (Bird) animal2;
        bird.fly();

        Animal animal1 = new Dog("旺财",3,"红色");
        if (animal1 instanceof Bird) {
            Bird bird2 = (Bird) animal1;
            bird2.fly();
        }else {
            System.out.println("不一定所以的动物都是鸟");
        }
    }

8.2.6 多态的优缺点

使用多态的好处：

能够降低代码的圈复杂度，避免使用大量的if-else
用if-else：

class Shape {
    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("矩形");
    }
}

class Triangle 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();
        Triangle triangle = new Triangle();
        String[] shapes = {"cycle", "rect", "cycle", "rect", "triangle"};
        for (String shape : shapes) {
            if (shape.equals("cycle")) {
                cycle.draw();
            } else if (shape.equals("rect")) {
                rect.draw();
            } else if (shape.equals("triangle")) {
                triangle.draw();
            }
        }
    }
 }

用多态：

class Shape {
    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("矩形");
    }
}

class Triangle 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();
        Triangle triangle = new Triangle();

        // 向上转型
        Shape[] shapes = {cycle,rect,cycle,rect,triangle};
        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}

可扩展能力更强
如果需要新加一种形状，使用多态的方式代码改动成本也比较低
比如新加一个画❀

class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("❀");
    }
}
public class Test {
    public static void main(String[] args) {
        Rect rect = new Rect(); // 相当于Shape rect = new Rect();
        Cycle cycle = new Cycle();
        Triangle triangle = new Triangle();
        Flower flower = new Flower();

        // 向上转型
        Shape[] shapes = {cycle,rect,cycle,rect,triangle,flower};
        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}

缺点：代码的运行效率降低

属性没有多态性
当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
构造方法没有多态性

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

当在父类的构造方法当中，调用父类和子类同名的方法时候，此时也会发生动态绑定。也意味着构造方法内也会发生动态绑定。
注意：在构造方法当中不要调用重写的方法。

class B {
    public B() {

// 父类的实例 --> 父类的构造 -->  子类的实例  --> 子类的构造
        func();  // 调用子类的func方法  没有给num赋值 所以num的值为0
    }
    public void func() {
        System.out.println("B.func()");
    }
}
class D extends B {
    private int num = 1;
    public D() {
        super();
    }
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
}
public class Test2 {
    public static void main(String[] args) {
        //1. 分配内存空间  2. 调用合适的构造方法
        D d = new D();
    }
}