在实现工厂设计模式时如何避免“实例化”？

您可以实现访客模式。

详细答案

这个想法是使用多态性来执行类型检查。每个子类都重写方法，该方法应在超类中声明。当我们遇到这样的情况时：accept(Visitor)

void add(Vehicle vehicle) {
    //what type is vehicle??
}

我们可以将对象传递到 中声明的方法中。如果 是 类型，并且覆盖了我们将对象传递到的方法，则该对象现在将在类中声明的方法中处理。我们利用这一点来发挥我们的优势：创建一个对象并将其传递给一个重写的方法：VehiclevehicleCarclass CarCarVisitor

abstract class Vehicle {
    public abstract void accept(AddToListVisitor visitor);
}

class Car extends Vehicle {
    public void accept(AddToListVisitor visitor) {
        //gets handled in this class
    }
}

这应该准备访问类型。要避免用于查找 的实际类型，必须在 中指定。VisitorCarinstanceofVisitor

class AddToListVisitor {
    public void visit(Car car) {
        //now we know the type! do something...
    }

    public void visit(Plane plane) {
        //now we know the type! do something...
    }
}

这是类型检查发生的地方！

当收到访问者时，它应该使用关键字将自己传入。因为我们在类中，所以将调用该方法。在访问者内部，我们可以执行所需的操作，现在我们知道对象的类型。CarthisCarvisit(Car)

所以，从顶部开始：

创建一个 ，它执行所需的操作。访问者应包含要对其执行操作的每种对象类型的方法。在本例中，我们为车辆创建访客：Visitorvisit

interface VehicleVisitor {
    void visit(Car car);
    void visit(Plane plane);
    void visit(Boat boat);
}

我们想要执行的操作是将车辆添加到某些东西上。我们将创建一个 ;管理添加运输工具的访客：AddTransportVisitor

class AddTransportVisitor implements VehicleVisitor {
    public void visit(Car car) {
        //add to car list
    }

    public void visit(Plane plane) {
        //add to plane list
    }

    public void visit(Boat boat) {
        //add to boat list
    }
}

每辆车都应该能够接受车辆访客：

abstract class Vehicle {
    public abstract void accept(VehicleVisitor visitor);
}

当访客被传递到车辆时，车辆应该调用它的方法，将自身传递到参数中：visit

class Car extends Vehicle {
    public void accept(VehicleVisitor visitor) {
        visitor.visit(this);
    }
}

class Boat extends Vehicle {
    public void accept(VehicleVisitor visitor) {
        visitor.visit(this);
    }
}

class Plane extends Vehicle {
    public void accept(VehicleVisitor visitor) {
        visitor.visit(this);
    }
}

这就是类型检查发生的地方。调用正确的方法，其中包含要根据方法的参数执行的正确代码。visit

最后一个问题是与列表进行交互。这就是您的用武之地：它封装了列表，允许您通过方法添加车辆。VehicleVisitorVehicleManagerVehicleManager#add(Vehicle)

当我们创建访问者时，我们可以将管理器传递给它（可能通过它的构造函数），这样我们就可以执行我们想要的操作，现在我们知道了对象的类型。应包含访问者并拦截呼叫：VehicleManagerVehicleManager#add(Vehicle)

class VehicleManager {
    private List<Car> carList = new ArrayList<>();
    private List<Boat> boatList = new ArrayList<>();
    private List<Plane> planeList = new ArrayList<>();

    private AddTransportVisitor addVisitor = new AddTransportVisitor(this);

    public void add(Vehicle vehicle) {
        vehicle.accept(addVisitor);
    }

    public List<Car> getCarList() {
        return carList;
    }

    public List<Boat> getBoatList() {
        return boatList;
    }

    public List<Plane> getPlaneList() {
        return planeList;
    }
}

现在，我们可以为这些方法编写实现：AddTransportVisitor#visit

class AddTransportVisitor implements VehicleVisitor {
    private VehicleManager manager;

    public AddTransportVisitor(VehicleManager manager) {
        this.manager = manager;
    }

    public void visit(Car car) {
        manager.getCarList().add(car);
    }

    public void visit(Plane plane) {
        manager.getPlaneList().add(plane);
    }

    public void visit(Boat boat) {
       manager.getBoatList().add(boat);
    }
}

我强烈建议删除 getter 方法，并为每种类型的车辆声明重载方法。这将减少不需要“访问”的开销，例如：addmanager.add(new Car())

class VehicleManager {
    private List<Car> carList = new ArrayList<>();
    private List<Boat> boatList = new ArrayList<>();
    private List<Plane> planeList = new ArrayList<>();

    private AddTransportVisitor addVisitor = new AddTransportVisitor(this);

    public void add(Vehicle vehicle) {
        vehicle.accept(addVisitor);
    }

    public void add(Car car) {
        carList.add(car);
    }

    public void add(Boat boat) {
        boatList.add(boat);
    }

    public void add(Plane plane) {
        planeList.add(plane);
    }

    public void printAllVehicles() {
        //loop through vehicles, print
    }
}

class AddTransportVisitor implements VehicleVisitor {
    private VehicleManager manager;

    public AddTransportVisitor(VehicleManager manager) {
        this.manager = manager;
    }

    public void visit(Car car) {
        manager.add(car);
    }

    public void visit(Plane plane) {
        manager.add(plane);
    }

    public void visit(Boat boat) {
       manager.add(boat);
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle[] vehicles = {
            new Plane(),
            new Car(),
            new Car(),
            new Car(),
            new Boat(),
            new Boat()
        };

        VehicleManager manager = new VehicleManager();
            for(Vehicle vehicle : vehicles) {
                manager.add(vehicle);
            }

            manager.printAllVehicles();
    }
}

您可以向车辆类添加方法来打印文本。然后在每个专用 Car 类中重写该方法。然后只需将所有汽车添加到车辆列表中即可。并循环列表以打印文本。