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中，以便稍后在控制器类中访问它们。以下是该类关于创建新机器的一个小摘录：

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

将抽象类更改为抽象工厂模式。差异在哪里？

1 个答案: