Question

我正在学习简单的工厂模式，我想知道我工厂中的所有方法是否适用于这种模式：

public class Bmw implements Car {
private String color;
private boolean hasXDrive;

public Bmw() {
}

public Bmw(String color) {
    this.color = color;
}

public Bmw(String color, boolean hasXDrive) {
    this.color = color;
    this.hasXDrive = hasXDrive;
}

public String getColor() {
    return color;
}

public void setColor(String color) {
    this.color = color;
}

public boolean isHasXDrive() {
    return hasXDrive;
}

public void setHasXDrive(boolean hasXDrive) {
    this.hasXDrive = hasXDrive;
}
}


public class Audi implements Car {
private String color;
private int turnAssistLevel;

public Audi() {
}

public Audi(String color) {
    this.color = color;
}

public Audi(String color, int turnAssistLevel) {
    this.color = color;
    this.turnAssistLevel = turnAssistLevel;
}

public String getColor() {
    return color;
}

public void setColor(String color) {
    this.color = color;
}

public int getTurnAssistLevel() {
    return turnAssistLevel;
}

public void setTurnAssistLevel(int turnAssistLevel) {
    this.turnAssistLevel = turnAssistLevel;
}
}


public class SimpleCarFactory {

// 1. make empty cars
public Car makeCar(CarType carType) {
    switch (carType) {
        case AUDI:
            return new Audi();
        case BMW:
            return new Bmw();
        default:
            throw new RuntimeException("No such car type!");
    }
}

// 2. make cars with colors
public Car makeCarWithColor(CarType carType, String color) {
    switch (carType) {
        case AUDI:
            return new Audi(color);
        case BMW:
            return new Bmw(color);
        default:
            throw new RuntimeException("No such car type!");
    }
}

// 3. BMW has an option that differentiate it from any other car. We cannot use a general car factory anymore
public Car makeBmw(String color, boolean hasXDrive) {
    return new Bmw(color, hasXDrive);
}

// 4. Audi has a turnAssistLevel option
public Car makeAudi(String color, int turnAssistLevel) {
    return new Audi(color, turnAssistLevel);
}

// 5. The same as #1, only it is static now make empty cars
public static Car staticMakeCar(CarType carType) {
    switch (carType) {
        case AUDI:
            return new Audi();
        case BMW:
            return new Bmw();
        default:
            throw new RuntimeException("No such car type!");
    }
}
}

我在代码注释中添加了方法的变体。我问这些问题，因为通常情况下，你会根据一些鉴别器（CarType）创建一个子类。但是你也可以有构造函数参数。

另外，当相关对象具有不同的构造函数时，我不确定该怎么做。

请告诉我SimpleCarFactory中的哪些方法有资格遵循简单的工厂模式？

亲切的问候，

Answer 1

我创建一个CarOptions对象并使用它，而不是使用这么多不同的方法。

public class CarOptions {
    private String color;
    private CarType carType;

    public String getColor() {
        return this.color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public CarType getCarType() {
        return this.carType;
    }

    public void setCarType(CarType carType) {
        this.carType = carType;
    }
}

然后是一个简单的makeCar方法，它接受CarOptions对象。

public Car makeCar(CarOptions options) {
    switch (options.getCarType()) {
        case AUDI:
            return new Audi(options.getColor());
        case BMW:
            return new Bmw(options.getColor());
        default:
            throw new RuntimeException("No such car type!");
    }
}

这样做的好处是你可以创建一个BMWCarOptions类：

public class BMWCarOptions extends CarOptions {
    private boolean hasXDrive;

    public boolean getHasXDrive() {
        return this.hasXDrive;
    }

    public void setHasXDrive(boolean hasXDrive) {
        this.hasXDrive = hasXDrive;
    }
}

然后，您仍然可以将其传递到makeCar方法。

Answer 2

＆＃34;它们是否有效＆＃34;是

＆＃34;它们是否是最佳的＆＃34;号

您没有超载这些方法，我认为这有助于解决您的问题。

 public Car makeCar(CarType carType)
                throws NoCarExistsException 
 public Car makeCar(CarType carType, Color color)
                throws NoCarExistsException 
 public Car makeCar(CarType carType, Color color, Options options) 
                throws NoCarExistsException 
 // where Options is a container class with hashmap 
 // (or one of many other valid impl. possibilities)  with all the options.

只要拥有＆＃34;的所有逻辑，这个选项的组合是否存在＆＃34;在工厂逻辑。

也可能有＆＃39;颜色＆＃39;成为一个选项＆＃39;太。

注意：这样做的好处是工厂的用户可以只列出他们想要的选项，并获得汽车或例外。使用起来要简单得多，但意味着逻辑必须存在于工厂中（我认为它应该存在），而不是依赖于用户必须编写额外的逻辑才能出厂。

Answer 3

这完全取决于您的工厂将用于什么。

1）如果您要将此工厂传递给某个通用 instantiator ，那么您的工厂必须实现该实例化器使用的所有工厂共有的一些接口。此接口可能具有通用选项的单一方法：

public interface CarFactory {
    Car makeCar(CarOptions options);
}

2）如果您要从代码的不同部分“手动”调用工厂，那么我会说您的方法是正确的。 makeAudi("red", true)看起来比makeCar(new CarOptions(CarType.AUDI, "red", ...))更具可读性。

所有这些方法签名对简单工厂模式都有效吗？

3 个答案: