多态 使用场景

多态允许不同类的对象对同一消息做出不同的响应。在 Java 中，多态主要通过继承和接口实现。

场景一：方法参数多态

// 定义一个动物抽象类
abstract class Animal {
    public abstract void makeSound();
}

// 定义猫类，继承自动物类
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}

// 定义狗类，继承自动物类
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}

// 定义一个动物操作类
class AnimalOperator {
    public void operate(Animal animal) {
        animal.makeSound();
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        AnimalOperator operator = new AnimalOperator();
        Cat cat = new Cat();
        Dog dog = new Dog();

        operator.operate(cat); // 传入猫对象
        operator.operate(dog); // 传入狗对象
    }
}

场景二：返回值多态

// 定义一个形状抽象类
abstract class Shape {
    public abstract double area();
}

// 定义圆形类，继承自形状类
class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

// 定义矩形类，继承自形状类
class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double area() {
        return width * height;
    }
}

// 定义一个形状工厂类
class ShapeFactory {
    public Shape createShape(int type) {
        if (type == 1) {
            return new Circle(5);
        } else {
            return new Rectangle(4, 6);
        }
    }
}

public class ReturnPolymorphismExample {
    public static void main(String[] args) {
        ShapeFactory factory = new ShapeFactory();
        Shape shape1 = factory.createShape(1);
        Shape shape2 = factory.createShape(2);

        System.out.println("Shape 1 area: " + shape1.area());
        System.out.println("Shape 2 area: " + shape2.area());
    }
}

向上转型和向下转型示例

// 定义一个父类
class Parent {
    public void print() {
        System.out.println("This is Parent class");
    }
}

// 定义一个子类
class Child extends Parent {
    @Override
    public void print() {
        System.out.println("This is Child class");
    }

    public void childMethod() {
        System.out.println("This is a child-specific method");
    }
}

public class TypeCastingExample {
    public static void main(String[] args) {
        // 向上转型
        Parent parent = new Child(); // 子类对象赋值给父类引用
        parent.print(); // 调用子类重写的方法

        // 向下转型
        if (parent instanceof Child) {
            Child child = (Child) parent; // 父类引用转换为子类引用
            child.print();
            child.childMethod(); // 调用子类特有的方法
        }
    }
}

parent 引用指向 Child 类的对象，但它只能访问 Parent 类中定义的方法和属性。

只能使用父类中的方法，但是用的方法如果被重写，就使用被重写的方法。 

instanceof 关键字使用示例

instanceof 关键字用于检查一个对象是否是某个类或接口的实例。

// 定义一个接口
interface Flyable {
    void fly();
}

// 定义一个鸟类，实现 Flyable 接口
class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("Bird is flying");
    }
}

// 定义一个飞机类，实现 Flyable 接口
class Plane implements Flyable {
    @Override
    public void fly() {
        System.out.println("Plane is flying");
    }
}

public class InstanceOfExample {
    public static void main(String[] args) {
        Flyable bird = new Bird();
        Flyable plane = new Plane();

        System.out.println(bird instanceof Bird); // 输出 true
        System.out.println(bird instanceof Flyable); // 输出 true
        System.out.println(plane instanceof Bird); // 输出 false
    }
}