AbstractFactory设计模式

问题描述：

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

ButtonType.java

public enum ButtonType { 
    WIN, LINUX, MAC 
}

Button.java

public interface Button { 
    ButtonType getButtonType(); 

    void actionListener(); 
}

LinuxButton.java

public class LinuxButton implements Button { 

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

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

    } 

}

WinButton.java

public class WinButton implements Button { 

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

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

    } 

}

MacButton.java

public class MacButton implements Button { 

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

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

    } 

}

ButtonFactory.java

public interface ButtonFactory { 

    Button createButton(); 
}

LinuxButtonFactory.java

public class LinuxButtonFactory implements ButtonFactory { 

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

}

WinButtonFactory.java

public class WinButtonFactory implements ButtonFactory { 

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

}

MacButtonFactory.java

public class MacButtonFactory implements ButtonFactory { 

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

}

AbstractButtonFactory.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; 
    } 

}

终于主要CALSS

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

}

我想确认是这种模式遵循AbstractFactory设计模式，如果它不应该怎样进行的更改？

你已经提取了按钮和工厂 - 对我来说很好看。你的特别关注点在哪里？ –

@Andreas_D：AbstractButtonFactory.java，它是正确的吗？ – optional

答

执行就可以了。你已经抽象出了按钮和工厂，这是该模式的主要目标。

在实现方面注意：工厂上的getButtonFactory方法非常没用，您可以简单地将它从实际工厂中移除所有实现。

当用户调用抽象工厂的静态方法时，他已经获得了工厂的一个实例，并且不必调用该工厂的一个方法，该方法只会返回自己。所以放下这个方法:)

看起来不错，我会以同样的方式实现它。对我来说，它满足了由模式本身设定的要求。 –

@Andreas_D在这种情况下使用* Abstract Factory *模式是一种矫枉过正的IMO。 – CKing

是的，但我认为，这更像是一个学术问题/任务。 –

答

你应该拆分接口

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

进入2周不同的人

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

和

public Button ButtonCreator { 
    Button createButton(); 
}

第一个创建ButtonCreator（取决于型）和ButtonCreator保持里面的类型并创建类型为

的按钮

：更新

我没有得到你最后的编码片段 – optional

更新了片段 – StanislavL

ButtonFactory是一个无用的方法的无用接口， –

答

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

如果您根据传递给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(); 
     } 
    } 

}

答

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

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

AbstractFactory设计模式

相关推荐