将abstractClass更改为abstractFactory模式。 有什么区别？

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类创建新机器，该Controller类处理与机器有关的所有操作。 所有创建的机器都存储在ArrayList中，以便以后在控制器类中访问它们。 这是该类中有关创建新计算机的一小部分摘录：

 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 );

    }
}

最好的问候daZza

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();
    }
}