java - 将抽象类更改为抽象工厂模式。区别在哪里？

Question

在编写训练练习时，我以为我正在使用抽象工厂模式，但事实证明我似乎已经实现了抽象类模式(根据审查我代码的人的说法)。

我通过使用我在网上找到的解释和 UML 图表来实现我所谓的“工厂”。我刚刚再次研究了它们并将其与我的代码进行了比较，但仍然看不到错误以及它应该只是抽象类模式的原因。

如我发现的 UML 图表所示，我实现了一个抽象类“AbstractMachineFactory”，它定义了我的具体机器所需的所有属性和方法。它们仅在生产的产品上有所不同。

然后我实现了三个不同的 ConcreteMachineType 类，它们扩展了 AbstractMachineFactory，也完全如 UML 图表中所示。

这是我的代码:

工厂:

public abstract class abstractMachineFactory {

public final int     machineID;
public int           producedGoods;
public boolean       status;

private final Logger abstractMachineFactoryLogger = LoggerFactory.getLogger( abstractMachineFactory.class );

public abstractMachineFactory( final int ID, final boolean state ) {
    this.machineID = ID;
    this.status = state;
}

public Integer getMachineID() {
    return this.machineID;
}

public Integer getNumberOfProducedGoods() {
    return this.producedGoods;
}

public Boolean getStatus() {
    return this.status;
}

public void startUp() {
    this.status = true;
}

public void shutDown() {
    this.status = false;
}

public abstract void produceGoods();

}

其中一台混凝土机器:

public class concreteMachineType1 extends abstractMachineFactory {

private final Logger concreteMachineType1Logger = LoggerFactory.getLogger( concreteMachineType1.class );

public concreteMachineType1( final int ID, final boolean state ) {
    super( ID, state );
}

@Override
public void produceGoods() {

    machineController machineController = exercise.java.basics.machine.machineController.getInstance();

    int timeToProduce = (int) ( ( Math.random() * ( 6 - 1 ) ) + 1 ) * 1000;


    try {
        Thread.sleep( timeToProduce );
    } catch ( InterruptedException ex ) {
        Thread.currentThread().interrupt();
    }

    machineController.moveNailToStorage();

    this.producedGoods++;

}

}

我通过一个 Controller 类创建新机器，该类处理与机器有关的所有操作。所有创建的机器都存储在 ArrayList 中，以便稍后在 Controller 类中访问它们。以下是该类(class)中有关创建新机器的一小段摘录:

 public void createMachine( final MachineType type ) {

    int machineID;
    if ( MachineType.TYPE1.equals( type ) ) {

        machineID = this.arrType1.size() + 1;
        abstractMachineFactory newMachine = new concreteMachineType1( machineID, false );
        this.numberOfType1++;
        this.arrType1.add( newMachine );

    } else if ( MachineType.TYPE2.equals( type ) ) {

        machineID = this.arrType2.size() + 1;
        abstractMachineFactory newMachine = new concreteMachineType2( machineID, false );
        this.numberOfType2++;
        this.arrType2.add( newMachine );

    }

    else if ( MachineType.TYPE3.equals( type ) ) {

        machineID = this.arrType3.size() + 1;
        abstractMachineFactory newMachine = new concreteMachineType3( machineID, false );
        this.numberOfType3++;
        this.arrType3.add( newMachine );

    }
}

最诚挚的问候达扎

Answer 1

工厂模式使用工厂返回基本类型的对象。

我想他所期待的是这样的:

public abstract class AbstractBase() {}

public class Concrete1 extends AbstractBase() {}

public class Concrete2 extends AbstractBase() {}

public class Factory() {
    enum BaseType {
        Type1,
        Type2
    };

    public static AbstractBase getObject(BaseType baseType) {
        if (baseType == Type1) {
            return new Concrete1();
        } else if (baseType == Type2) {
            return new Concrete2();
        }
        throw new IllegalArgumentException();
    }
}