Java多态 - 技术栈

1，多态的概念

多态字面意思就是多种形态，例如：同样是吃，狗吃狗粮，猫吃猫粮。在Java里的表现就是同样使用一个方法但是输出不同的结果。

1.1 多态的条件

在继承的基础上
向上转型
重写

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

java 复制代码

package demo1;

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

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

java 复制代码

package demo1;

public class Dog extends Animal{

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

    @Override
    public void eat() {
        System.out.println(getName() + " 在吃狗粮");
    }

    public void bark() {
        System.out.println("狗叫");
    }
}

java 复制代码

package demo1;

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

    @Override
    public void eat() {
        System.out.println(getName() + " 在吃猫粮");
    }
    
    public void mew() {
        System.out.println("猫叫");
    }
}

java 复制代码

package demo1;

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("旺财",5);
        animal.eat();
        Animal animal1 = new Cat("小黑",2);
        animal1.eat();
    }
}

2，向上转型和向下转型

2.1 向上转型

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

语法格式：父类类型对象名 = new 子类类型()

java 复制代码

Animal animal = new Dog("旺财",5);

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

向上转型的三种形式

直接赋值
方法传参
方法返回

java 复制代码

public class Test {
    // 2. ⽅法传参：形参为⽗类型引⽤，可以接收任意⼦类的对象
    public static void eatFood(Animal a) {
        a.eat();
    }

    public static void main(String[] args) {
        Dog dog = new Dog("旺财",5);
        Cat cat = new Cat("小黑",2);
        eatFood(dog);
        eatFood(cat);

    }
}

java 复制代码

    // 3.作返回值：返回任意⼦类对象
    public static Animal buyAnimal(String var){
        if("狗".equals(var) ){
            return new Dog("狗狗",1);
        }else if("猫" .equals(var)){
            return new Cat("猫猫", 1);
        }else{
            return null;
        }
    }

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

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

2.2 向下转型

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

java 复制代码

public class TestAnimal {
public static void main(String[] args) {
    Cat cat = new Cat("元宝",2);
    Dog dog = new Dog("⼩七", 1);
    // 向上转型
 
    Animal animal = cat;
    animal.eat();
    animal = dog;
    animal.eat();

    // 编译失败，编译时编译器将animal当成Animal对象处理
    // ⽽Animal类中没有bark⽅法，因此编译失败
    // animal.bark();

    // 向上转型
    // 程序可以通过编译，但运⾏时抛出异常--因为：animal实际指向的是狗
    // 现在要强制还原为猫，⽆法正常还原，运⾏时抛出：ClassCastException 
    cat = (Cat)animal;
    cat.mew();

    // animal本来指向的就是狗，因此将animal还原为狗也是安全的
    dog = (Dog)animal;
    dog.bark();
    }
}

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

java 复制代码

if(animal instanceof Cat){
    cat = (Cat)animal;
    cat.mew();
}
if(animal instanceof Dog){
    dog = (Dog)animal;
    dog.bark();
}

instanceof介绍

3，重写

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

重写的规则

子类在重写父类方法时，一般必须与父类方法原型一致：返回类型方法名参数列表要完全一致
被重写的方法返回类型可以不同，但是必须是具有父子关系的（协变)
子类重写方法的访问权限要大于等于父类，例如父类方法被public修饰，子类中重写该方法就不能声明为protected
父类被static,private，final修饰的方法，构造方法都不能被重写
重写的方法，可以使用@Override 注解来显示指定，有了这个注解能帮我们进行一些合法性校验，如果写的方法名在父类中找不到，就会报错

重写和重载的区别

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

重写的设计原则

对于一个已经使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，并且添加或者改动新的内容

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

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

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

java 复制代码

class B {
    public B() {
    // do nothing
    func();
}
    public void func() {
        System.out.println("B.func()");
    }
}
class D extends B {
    private int num = 1;
    @Override
    public void func() {
    System.out.println("D.func() " + num);
    }
}
public class Test {
    public static void main(String[] args) {
        D d = new D();
    }
}
// 执⾏结果
D.func() 0

构造D对象的同时，会调用B的构造方法
B的构造方法中调用了func方法，此时会触发动态绑定，会调用到D中的func
此时D对象自身还没有构造，此时num处在为初始化的状态，值为0
所以在构造函数内，尽量避免使用实例方法，除了final和private方法

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

4，多态的优缺点

java 复制代码

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

使用多态的好处：

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

圈复杂度是一种描述一段代码复杂程度的方式，一段代码如果平铺直叙，就很容易理解，如果有很多条件判断很循环语句就很难观察，因此我们可以简单粗暴的计算⼀段代码中条件语句和循环语句出现的个数,这个个数就称为"圈复杂度"

例如我们现在需要打印的不是⼀个形状了,⽽是多个形状.如果不基于多态,实现代码如下

java 复制代码

public static void drawShapes() {
    Rect rect = new Rect();
    Cycle cycle = new Cycle();
    Flower flower = new Flower();
    String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};
    for (String shape : shapes) {
        if (shape.equals("cycle")) {
            cycle.draw();
        } else if (shape.equals("rect")) {
            rect.draw();
        } else if (shape.equals("flower")) {
            flower.draw();
        }
    }
}

如果使⽤使⽤多态,则不必写这么多的if-else分⽀语句,代码更简单

java 复制代码

public static void drawShapes() {
// 我们创建了⼀个 Shape 对象的数组
 
Shape[] shapes = {new Cycle(), new Rect(), new Cycle(), 
                    new Rect(), new Flower()};//实际创建了5个对象
    for (Shape shape : shapes) {
        shape.draw();
    }
}

java 复制代码

Cycle cycle = new Cycle();
Rect rect = new Rect();
Flower flower = new Flower();
Shape[] shapes = {cycle, rect, cycle, rect, flower};//创建三个对象