java面向对象编程【高级篇】之多态

目录

• 🚀前言
• 🤔什么是多态？
• 🌟多态的优缺点
• • 💯优点
  • 💯缺点
• 🌟类型转换
• • 💯自动类型转换
  • 💯强制类型转换

🚀前言

大家好！我是 EnigmaCoder 。

本文介绍java面向对象编程三大特性之一的多态，包括定义、优缺点、类型转换等。

🤔什么是多态？

多态是继承情况下的一种现象，表现为：对象多态、行为多态。

前提：

• 有继承关系
• 存在父类引用子类对象
• 存在方法重写

注意：多态是对象、行为的多态，java中的成员变量没有多态。

代码示例：

public class Test {
    public static void main(String[] args) {
            //对象多态、行为多态
            Animal a1=new Wolf();
            a1.run();//方法：编译看左边，运行看右边
            System.out.println(a1.name); //成员变量：编译看左边，运行也看左边。

            Animal a2=new Tortoise();
            a2.run();//方法：编译看左边，运行看右边
            System.out.println(a2.name);//成员变量：编译看左边，运行也看左边。
    }
}
 class Animal {
    String name="Animal";
    public void run(){
        System.out.println("Animal is running");
    }
}

class Tortoise extends Animal{
    String name="乌龟";
    @Override
    public void run(){
        System.out.println("乌龟跑得慢");
    }
}

class Wolf extends Animal{
    String name="狼";
    @Override
    public void run(){
        System.out.println("狼跑的快");
    }
}

运行结果：

狼跑的快
Animal
乌龟跑得慢
Animal

🌟多态的优缺点

💯优点

• 在多态形式下，右边对象是解耦合的，更便于扩展和维护。

例如：

Animal a1=new Wolf();
a1.run();

上述代码中的Wolf()可以替换成其它继承了Animal父类的子类。

• 定义方法时，使用父类类型的形参，可以接收一切子类对象，扩展性更强、更便利。

例如：

public class Test {
    public static void main(String[] args) {
            Animal a1=new Wolf();
            a1.run();
            //父类类型的变量作为参数，可以接收一个子类对象
            Wolf w=new Wolf();
            go(w);

            Tortoise t=new Tortoise();
            go(t);
    }
    public static void go(Animal a){
        a.run();
    }
}

💯缺点

多态下不能使用子类的独有功能，换句话说，多态下只能使用被重写的方法。

🌟类型转换

• 自动类型转换：父类 变量名 = new 子类();
• 强制类型转换：子类 变量名 = (子类)父类变量;

💯自动类型转换

自动类型转换（也叫隐式类型转换）指的是小范围数据类型自动转换为大范围数据类型，或者子类对象自动转换为父类对象。这种转换无需额外操作，系统会自动完成。

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class AutomaticConversion {
    public static void main(String[] args) {
        Dog dog = new Dog();
        // 自动类型转换：子类对象转换为父类对象
        Animal animal = dog;
        animal.makeSound();
    }
}

💯强制类型转换

强制类型转换（也叫显式类型转换）指的是将大范围数据类型转换为小范围数据类型，或者父类对象转换为子类对象。进行强制类型转换时，需要使用强制转换运算符 (type)。不过要注意，在进行父类对象到子类对象的转换时，要确保该父类对象实际上引用的是子类对象，不然会引发 ClassCastException 异常。

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
    public void wagTail() {
        System.out.println("Dog wags its tail");
    }
}

public class ForcedConversion {
    public static void main(String[] args) {
        Animal animal = new Dog();
        // 强制类型转换：父类对象转换为子类对象
        Dog dog = (Dog) animal;
        dog.makeSound();
        dog.wagTail();
    }
}

小结：

• 自动类型转换：是安全的，系统会自动完成。
• 强制类型转换：存在风险，使用时要确保转换的安全性，可借助 instanceof 运算符进行检查。

示例代码如下：

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
    public void wagTail() {
        System.out.println("Dog wags its tail");
    }
}

public class TypeConversionExample {
    public static void main(String[] args) {
        Animal animal = new Dog();
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.makeSound();
            dog.wagTail();
        }
    }
}

在上述代码里，运用 instanceof 运算符来判断 animal 对象是否为 Dog 类的实例，若为真，再进行强制类型转换，以此确保转换的安全性。