Question

我创建了一个以下示例。这是否遵循AbstractFactory设计模式？

ButtonType.java

public interface Button {
    ButtonType getButtonType();

    void actionListener();
}

Button.java

public class LinuxButton implements Button {

    @Override
    public ButtonType getButtonType() {
        return ButtonType.LINUX;
    }

    @Override
    public void actionListener() {
        System.out.println("Linux Button created");

    }

}

LinuxButton.java

public class WinButton implements Button {

    @Override
    public ButtonType getButtonType() {
        return ButtonType.WIN;
    }

    @Override
    public void actionListener() {
        System.out.println("Window Button Created");

    }

}

WinButton.java

public class MacButton implements Button {

    @Override
    public ButtonType getButtonType() {
        return ButtonType.MAC;
    }

    @Override
    public void actionListener() {
        System.out.println("Mac Button Created");

    }

}

MacButton.java

public interface ButtonFactory {

    Button createButton();
}

ButtonFactory.java

public class LinuxButtonFactory implements ButtonFactory {

    @Override
    public Button createButton() {
        System.out.println("creating Linux Button");
        return new LinuxButton();
    }

}

LinuxButtonFactory.java

public class WinButtonFactory implements ButtonFactory {

    @Override
    public Button createButton() {
        System.out.println("creating window Button");
        return new WinButton();
    }

}

WinButtonFactory.java

public class MacButtonFactory implements ButtonFactory {

    @Override
    public Button createButton() {
        System.out.println("Creating MAC Button");
        return new MacButton();
    }

}

MacButtonFactory.java

public abstract class AbstractButtonFactory {

    public static ButtonFactory getButtonFactory(ButtonType bt) {
        ButtonFactory btnFactory = null;
        switch (bt) {
        case WIN:
            btnFactory = new WinButtonFactory();
            break;
        case LINUX:
            btnFactory = new LinuxButtonFactory();
            break;
        default:
            btnFactory = new MacButtonFactory();
        }
        return btnFactory;
    }

}

AbstractButtonFactory.java

public class AbstractFactoryObjectDemo {

    public static void main(String[] args) {

        ButtonFactory factory = AbstractButtonFactory.getButtonFactory(ButtonType.LINUX);
        Button linuxButton = factory.createButton();
        System.out.println(linuxButton.getButtonType().toString());
    }

}

最后是主要的calss

{{1}}

我想确定这个模式是否遵循AbstractFactory设计模式，如果它没有应该做出哪些更改？

Answer 1

抽象工厂的目的是提供一个用于创建相关对象族的接口，而无需指定具体的类。 您现在不需要抽象工厂设计模式，因为到目前为止您只有一个按钮可以创建，但它可能会发生变化（显然）。

如果根据传递给getFactory方法的内容创建其他内容，此模式将非常有用。

要回答您的问题，根据source making，执行此操作的惯用方法如下：

首先，您不必每次都必须实现ButtonFactory的getFactory方法。

你可以简单地从ButtonFactory接口中删除getButtonFactory方法，但我认为这个接口是无用的。

我看到两种可能性有一个惯用的抽象工厂设计模式：

让你的抽象工厂成为界面（见下面的例子）。
使用这样的静态类：
https://sourcemaking.com/design_patterns/abstract_factory/java/2

MacButtonToolKit：

public class MacButtonToolkit extends AbstractButtonFactory {
    public Button createButton() {
        System.out.println("Creating MAC Button");
        return new MacButton();
    }

    public SomethingElse createSomethingElse() {
        return new SomethingElse();
    }
}

AbstractButtonFactory：

public abstract class AbstractButtonFactory {
    private static final MacButtonToolkit macButtonToolkit = new MacButtonToolkit();
    public static ButtonFactory getFactory(ButtonType bt) {
        switch (bt) {
        case MAC:
            return macButtonToolkit;
        default:
            return macButtonToolkit;
        }
    }

    public abstract Button createButton();
    public abstract SomethingElse createButton();
}

如果您没有要创建的对象系列，则只应使用工厂设计模式：

public class ButtonFactory {
    public Button createButton(ButtonType buttonType) {
        switch (buttonType) {
          case MAC: 
            return new MacButton();
          default: 
            return new MacButton();
        }
    }

}

Answer 2

您应该拆分界面

public interface ButtonFactory {
    ButtonFactory getButtonFactory(ButtonType bt);
    Button createButton();
}

分为两个不同的

public interface ButtonFactory {
    ButtonCreator getButtonFactory(ButtonType bt);
}

和

public Button ButtonCreator {
    Button createButton();
}

首先创建ButtonCreator（取决于类型），ButtonCreator将类型保留在内部并创建类型的按钮

：更新

Answer 3

实施没问题。您已经抽象了按钮和工厂，这是该模式的主要目标。

在实施方面注意：工厂上的getButtonFactory方法非常无用，您只需将其从实际工厂中删除即可。

当用户在抽象工厂上调用静态方法时，他已经获得了一个工厂的实例，并且不必在这个工厂上调用一个方法，这个方法只会再次返回。所以放弃这个方法：）

Answer 4

也许您可以考虑Bridge和Abstract Factory之间的组合。

想象一下，除了按钮之外，你需要添加新的图形项目，比如ComboBox，或者除了Win / Linux / Mac之外你还有其他平台。
那么纯抽象工厂将不灵活，因此可以使用Bridge模式来分离抽象（Button，ComboBox，...）和平台特定实现（Win / Linux / Mac）。

AbstractFactory设计模式

4 个答案: