当函数行为依赖于类型时，我如何避免instanceof？

在面向对象编程中，instanceof 操作符用于检查对象是否是指定类的实例。然而，过度依赖 instanceof 可能会导致代码难以维护和扩展，因为它违反了开闭原则（对扩展开放，对修改关闭）。以下是一些避免使用 instanceof 的方法：

1. 使用多态

多态是面向对象编程的核心概念之一，它允许不同的类以不同的方式实现相同的方法。通过定义一个接口或抽象类，并让不同的类实现该接口或继承该抽象类，可以避免使用 instanceof。

示例代码：

// 定义一个接口
interface Shape {
    double area();
}

// 实现接口的具体类
class Circle implements Shape {
    private double radius;

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

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

class Rectangle implements 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;
    }
}

// 使用多态
public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);

        System.out.println("Circle area: " + circle.area());
        System.out.println("Rectangle area: " + rectangle.area());
    }
}

2. 使用访问者模式

访问者模式是一种将算法与对象结构分离的设计模式。它允许你在不修改现有类层次结构的情况下定义新的操作。

示例代码：

// 定义一个元素接口
interface Element {
    void accept(Visitor visitor);
}

// 定义一个访问者接口
interface Visitor {
    void visit(Circle circle);
    void visit(Rectangle rectangle);
}

// 实现元素的具体类
class Circle implements Element {
    private double radius;

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

    public double getRadius() {
        return radius;
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

class Rectangle implements Element {
    private double width;
    private double height;

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

    public double getWidth() {
        return width;
    }

    public double getHeight() {
        return height;
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

// 实现访问者的具体类
class AreaCalculator implements Visitor {
    private double area;

    @Override
    public void visit(Circle circle) {
        area = Math.PI * circle.getRadius() * circle.getRadius();
    }

    @Override
    public void visit(Rectangle rectangle) {
        area = rectangle.getWidth() * rectangle.getHeight();
    }

    public double getArea() {
        return area;
    }
}

// 使用访问者模式
public class Main {
    public static void main(String[] args) {
        Element circle = new Circle(5);
        Element rectangle = new Rectangle(4, 6);

        AreaCalculator calculator = new AreaCalculator();

        circle.accept(calculator);
        System.out.println("Circle area: " + calculator.getArea());

        calculator = new AreaCalculator();
        rectangle.accept(calculator);
        System.out.println("Rectangle area: " + calculator.getArea());
    }
}

3. 使用类型安全的向下转型

在某些情况下，如果你确定某个对象的具体类型，可以使用类型安全的向下转型。

示例代码：

public class Main {
    public static void main(String[] args) {
        Object obj = new Circle(5);

        if (obj instanceof Circle) {
            Circle circle = (Circle) obj;
            System.out.println("Circle area: " + circle.area());
        }
    }
}

4. 使用反射

反射是一种在运行时检查对象类型和调用方法的能力。虽然反射可以避免使用 instanceof，但它通常会带来性能开销，并且会使代码更难理解和维护。

示例代码：

import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws Exception {
        Object obj = new Circle(5);

        Method method = obj.getClass().getMethod("area");
        double area = (double) method.invoke(obj);
        System.out.println("Area: " + area);
    }
}