初识java（十二）：多态

内容大纲：

摘要：本文详细介绍了Java中的多态特性及其实现方式。

1.多态指同一行为在不同对象上产生不同结果，实现条件包括继承体系、方法重写和父类引用调用。文章通过Animal、Cat、Dog等示例代码展示了多态的具体应用，并对比了重写与重载的区别。

2.同时讲解了向上转型（子类对象作为父类使用）和向下转型（还原为子类对象）的概念及注意事项，强调使用instanceof确保转型安全。

3.最后分析了多态的优点（降低代码复杂度、提高扩展性）和构造方法中调用重写方法的潜在问题。全文通过丰富示例帮助理解面向对象编程中的多态特性。

一：多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个⾏为，当不同的对象去完成时会产⽣出不同的状态

总的来说：同⼀件事情，发⽣在不同对象⾝上，就会产⽣不同的结果。

1.多态实现条件

在Java中要实现多态，必须要满⾜如下⼏个条件，缺⼀不可：

1. 必须在继承体系下

2. ⼦类必须要对⽗类中⽅法进⾏重写

3. 通过⽗类的引⽤调⽤重写的⽅法

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

Animal.java(父类)

java 复制代码

package demo1;

public 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+ " 吃饭 ");
    }

}

Cat.java(子类)

java 复制代码

package demo1;

public class Cat extends Animal{

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

    @Override
    public void eat() {
        super.eat();
        System.out.println("吃的是鱼");
    }
}

Dog.java(子类)

java 复制代码

package demo1;

public class Dog extends Animal{

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

    @Override
    public void eat() {
        super.eat();
        System.out.println("吃的是骨头");
    }
}

Test.java

java 复制代码

package demo1;

public class Test {
    //用类型是Animal，变量名字是a的来接收参数，而且这里的类型必须是父类的类型
    public static void eat(Animal a){
        a.eat();
    }
    public static void main(String[] args) {
        Cat cat = new Cat("小白",1);
        Dog dog =new Dog("大黄",10);

        //创建一个吃的方法,传了一个参数变量过去
        eat(cat);
        eat(dog);
    }

}

输出：

在上述代码中,Test上⽅的代码是类的实现者编写 的,Test的代码是类的调⽤者编写的.

当类的调⽤者在编写 eat 这个⽅法的时候,参数类型为Animal(⽗类),此时在该⽅法内部并不知道, 也不关注当前的a引⽤指向的是哪个类型(哪个⼦类)的实例.此时a这个引⽤调⽤eat⽅法可能会有多种不同的表现(和a引⽤的实例相关),这种⾏为就称为多态.

2.重写

重写(override)：也称为覆盖。重写是⼦类对⽗类⾮静态、⾮private修饰，⾮final修饰，⾮构造⽅法等的实现过程进⾏重新编写,返回值和形参都不能改变。即外壳不变，核⼼重写！重写的好处在于⼦类可以根据需要，定义特定于⾃⼰的⾏为。也就是说⼦类能够根据需要实现⽗类的⽅法**。**

【⽅法重写的规则】

1.⼦类在重写⽗类的⽅法时，⼀般必须与⽗类⽅法原型⼀致：返回值类型⽅法名 (参数列表) 要完全⼀致

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

3.访问权限不能⽐⽗类中被重写的⽅法的访问权限更低。例如：如果⽗类⽅法被public修饰，则⼦类中重写该⽅法就不能声明为protected

4.⽗类被static、private修饰的⽅法、构造⽅法都不能被重写。

5.重写的⽅法,可以使⽤ @Override注解来显式指定，有了这个注解能帮我们进⾏⼀些合法性校验. 例如不⼩⼼将⽅法名字拼写错了(⽐如写成aet),那么此时编译器就会发现⽗类中没有aet⽅法,就会编译报错,提⽰⽆法构成重写

【重写和重载的区别】

即：⽅法重载是⼀个类的多态性表现,⽽⽅法重写是⼦类与⽗类的⼀种多态性表现。

【重写的设计原则】

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

例如：若⼲年前的⼿机，只能打电话，发短信，来电显⽰只能显⽰号码，⽽今天的⼿机在来电显⽰的时候，不仅仅可以显⽰号码，还可以显⽰头像，地区等。在这个过程当中，我们不应该在原来⽼的类上进⾏修改，因为原来的类，可能还在有⽤⼾使⽤，正确做法是：新建⼀个新⼿机的类，对来电显⽰这个⽅法重写就好了，这样就达到了我们当今的需求了。

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

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

3.向上转型和向下转型

1.向上转型

向上转型：实际就是创建⼀个⼦类对象，将其当成⽗类对象来使⽤。

语法格式：⽗类类型对象名 = new ⼦类类型()

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

animal是⽗类类型，但可以引⽤⼀个⼦类对象，因为是从⼩范围向⼤范围的转换

【使⽤场景】

1.直接赋值

2.⽅法传参

3.⽅法返回

Dog Cat Animal 这三个代码文件和上面那是一样的，我就不重复写了，这里就只是变动了Test.java这个文件

Test.java

java 复制代码

package demo2;

public class Test {

    //2.⽅法传参：形参为⽗类型引⽤，可以接收任意⼦类的对象
    //创建了一个吃的方法
    public static void eatfood(Animal a) {
        a.eat();
    }

    // 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;
        }
    }


    public static void main(String[] args) {
        //向上转型
        Animal cat = new Cat(" 元宝 ",2);   // 1.直接赋值：⼦类对象赋值给⽗类对象

        Dog dog = new Dog("⼩七 ", 1);

        //调用吃的方法
        eatfood(cat);
        eatfood(dog);

        //调用比较返回值的方法
        //传了一个参数过去
        Animal animal = buyAnimal(" 狗 ");
        animal.eat();

        //调用比较返回值的方法
        //传了一个参数过去
        //这里的animal没有加类型是因为，前面已经定义过了，编译器就已经记住它了，不用你再些一遍了
        animal = buyAnimal(" 猫 ");
        animal.eat();


    }
}

输出：

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

向上转型的缺陷：不能调⽤到⼦类特有的⽅法。

总结向上转型

1.核心口诀：编译看左，运行看右
左边（父类） ：决定了"你能用什么"。编译器在检查代码时，只看左边的父类里有哪些方法。如果父类里没有这个方法，哪怕右边的子类写了，编译器也会直接报错。
右边（子类）： 决定了"实际执行什么"。当程序真正跑起来时，JVM（Java虚拟机）会看右边实际创建的是哪个子类对象，并执行该子类重写后的具体逻辑。
2.生活类比：贴标签

你可以把向上转型想象成"给具体的物品贴一个通用的标签"：
右边 new 子类() ：是你实实在在买回来的具体物品（比如一台具体的"苹果手机"）。
左边父类引用： 是你给这个物品贴的通用分类标签（比如贴上一个"电子产品"的标签）。

因为"苹果手机"一定是"电子产品"，所以把子类对象赋值给父类引用（向上转型）是绝对安全的，Java 会自动帮你完成，不需要任何强制转换。
3.绝对禁忌：左右不能反过来

如果反过来写，比如子类对象 = new 父类()，这在逻辑上是绝对不成立的。
为什么不行？ 继续用上面的例子，这就好比你说："我买了一个'电子产品'（父类），所以它一定是一台'苹果手机'（子类）。" ------ 这显然是不对的，因为"电子产品"还可能是电脑、电视或者平板。
后果： 这种把父类强转成子类的操作（向下转型），不仅不能自动完成，还必须手动强制转换，而且如果实际对象类型不匹配，程序运行时还会直接崩溃报错（抛出 ClassCastException 异常）。
总结一下：
向上转型的铁律就是"左边父类，右边子类"。只要你记住了"贴通用标签"这个逻辑，就再也不会搞混啦

2.向下转型

将⼀个⼦类对象经过向上转型之后当成⽗类⽅法使⽤，再⽆法调⽤⼦类的⽅法，但有时候可能需要调⽤⼦类特有的⽅法，此时：将⽗类引⽤再还原为⼦类对象即可，即向下转换。

代码还是和上面一样，只是变动了Test.java的文件

Test.java

java 复制代码

package demo2;

public class Test1 {
    public static void main(String[] args) {

        Cat cat = new Cat(" 元宝 ",2);
        Dog dog = new Dog("⼩七 ", 1);

        //向上转型
        Animal animal = cat; //向上转向的另一种写法和Animal cat = new Cat(" 元宝 ",2);一样
        animal.eat();

        animal = dog;
        animal.eat();

        //下面的代码就是向下转型
        //按照代码一行一行的执行
        //因为我们的animal最后指向的是狗，不是猫，强转会发生报错
        cat = (Cat)animal;
        cat.mew();


        //下面这个代码才能运行 animal本来指向的就是狗，因此将animal还原为狗也是安全的
        dog = (Dog)animal;
        dog.bark();

    }

}

输出：

向下转型⽤的⽐较少，⽽且不安全，万⼀转换失败，运⾏时就会抛异常。Java中为了提⾼向下转型的安全性，引⼊了instanceof，如果该表达式为true，则可以安全转换。

Test.java

java 复制代码

package demo2;

public class Test2 {
        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();

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

输出：

instanceof关键字的具体介绍：

https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2

4.多态的优缺点

假设有如下代码：
Shape.java(父类)

java 复制代码

package demo3;

public class Shape {

    public void draw(){
        System.out.println("画一个图形");
    }

}

Rect.java

java 复制代码

package demo3;

public class Rect extends Shape{
    @Override
    public void draw() {
        super.draw();
        System.out.println("矩形");
    }
}

Cycle.java

java 复制代码

package demo3;

public class Cycle extends Shape{
    @Override
    public void draw() {
        super.draw();
        System.out.println("圆");
    }
}

flower.java

java 复制代码

package demo3;

public class flower extends Shape{
    @Override
    public void draw() {
        super.draw();
        System.out.println("花");
    }
}

【使⽤多态的好处】

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

什么叫"圈复杂度"?

圈复杂度是⼀种描述⼀段代码复杂程度的⽅式.⼀段代码如果平铺直叙,那么就⽐较简单容易理解.⽽如果有很多的条件分⽀或者循环语句,就认为理解起来更复杂.

因此我们可以简单粗暴的计算⼀段代码中条件语句和循环语句出现的个数,这个个数就称为"圈复杂度".如果⼀个⽅法的圈复杂度太⾼,就需要考虑重构.

不同公司对于代码的圈复杂度的规范不⼀样.⼀般不会超过10.

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

Draw.java

java 复制代码

package demo3;

public class Draw {
    public static void main(String[] args) {
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        flower flower = new flower();
        String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};

        for(String s:shapes){
            if (s.equals("cycle")) {
                cycle.draw();
            } else if (s.equals("rect")) {
                rect.draw();
            } else if (s.equals("flower")) {
                flower.draw();
            }
        }
    }
}

输出：

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

java 复制代码

package demo3;

public class Draw1 {
    public static void main(String[] args) {
        Shape[] shapes={new Cycle(),new Rect(),new flower()};
        for (Shape s:shapes){
            s.draw();
        }
    }
}

输出：

2.可扩展能⼒更强

如果要新增⼀种新的形状,使⽤多态的⽅式代码改动成本也⽐较低.

Tri.java

java 复制代码

package demo3;

public class Tri extends Shape{
    @Override
    public void draw() {
        super.draw();
        System.out.println("三角形");
    }
}

对于类的调⽤者来说(drawShapes⽅法),只要创建⼀个新类的实例就可以了,改动成本很低.

⽽对于不⽤多态的情况,就要把drawShapes中的if-else进⾏⼀定的修改,改动成本更⾼

5.避免在构造⽅法中调⽤重写的⽅法

⼀段有坑的代码.我们创建两个类,B是⽗类,D是⼦类.D中重写func⽅法.并且在B的构造⽅法中调⽤func

B.java(父类)

java 复制代码

package demo4;

public class B {

    public B(){
        func();
    }

    public void func(){
        System.out.println("B.func");
    }

}

D.java

java 复制代码

package demo4;

public class D extends B {
    public int num = 1;

    @Override
    public void func() {
        super.func();
    }
}

输出：

• 构造D对象的同时,会调⽤B的构造⽅法.

• B的构造⽅法中调⽤了func⽅法,此时会触发动态绑定,会调⽤到D中的func

• 此时D对象⾃⾝还没有构造,此时num处在未初始化的状态,值为0.

• 所以在构造函数内，尽量避免使⽤实例⽅法，除了final和private⽅法。

结论:

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

以上就是我们的全部内容了！！！！！！！！