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

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

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的哪些方法符合SimpleFactory模式

亲切问候，

“有效吗”是的

“它们是最优的吗”不

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

 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. 

只要把“这个选项组合是否存在”的所有逻辑都放在工厂逻辑中就行了

也可以将“颜色”作为“选项”

---

---

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

我将创建一个

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

方法。

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

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

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

---

2） 如果您打算从代码的不同部分“手动”调用工厂，那么我认为您的方法是正确的

makeAudi（“红色”，真）

看起来比

makeCar（新的CarOptions（CarType.AUDI，“red“，…））可读性好得多。

你可能会在@Pace上得到更好的答案，我认为那可能会更好。@Pace在引用其他网站时，指出Ok，如果我这样做，我必须修改makeCar，首先检查righ是什么样的选项？或者我应该创建一个专门的BmwCarFactory，直接与BmwCarOptions一起使用吗？您可以在知道它是

BMW

类型后使用

instanceof

，查看我们是否使用

BmwCarOptions

，或者您可以创建另一个工厂。恐怕您必须创建

CarOptionsFactory

然后才能创建所有类型的选项：）