Stay Hungry,Stay Foolish!

Groovy 设计模式 -- 抽象工厂 模式

 

抽象工厂

https://blog.csdn.net/wyxhd2008/article/details/5597975

首先来看看这两者的定义区别：

工厂模式：定义一个用于创建对象的借口，让子类决定实例化哪一个类

抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类

       个人觉得这个区别在于产品，如果产品单一，最合适用工厂模式，但是如果有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。再通俗深化理解下：工厂模式针对的是一个产品等级结构 ，抽象工厂模式针对的是面向多个产品等级结构的。

再来看看工厂方法模式与抽象工厂模式对比：

 

工厂方法模式

抽象工厂模式
针对的是一个产品等级结构 针对的是面向多个产品等级结构
一个抽象产品类 多个抽象产品类
可以派生出多个具体产品类 每个抽象产品类可以派生出多个具体产品类
一个抽象工厂类，可以派生出多个具体工厂类 一个抽象工厂类，可以派生出多个具体工厂类
每个具体工厂类只能创建一个具体产品类的实例 每个具体工厂类可以创建多个具体产品类的实例

       

 

 

简单工厂

https://www.cnblogs.com/zhangchenliang/p/3700820.html

这个模式本身很简单而且使用在业务较简单的情况下。一般用于小项目或者具体产品很少扩展的情况（这样工厂类才不用经常更改）。
它由三种角色组成：
工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，根据逻辑不同，产生具体的工厂产品。如例子中的Driver类。
抽象产品角色：它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类来实现。如例中的Car接口。
具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现，如例子中的Benz、Bmw类。

 

 

    1. abstract class Car{  
    2.     private String name;  
    3.       
    4.     public abstract void drive();  
    5.       
    6.     public String getName() {  
    7.         return name;  
    8.     }  
    9.     public void setName(String name) {  
    10.         this.name = name;  
    11.     }  
    12. }  
    13. //具体产品  
    14. class Benz extends Car{  
    15.     public void drive(){  
    16.         System.out.println(this.getName()+"----go-----------------------");  
    17.     }  
    18. }  
    19.   
    20. class Bmw extends Car{  
    21.     public void drive(){  
    22.         System.out.println(this.getName()+"----go-----------------------");  
    23.     }  
    24. }  
    25.   
    26. //简单工厂  
    27. class Driver{  
    28.     public static Car createCar(String car){  
    29.         Car c = null;  
    30.         if("Benz".equalsIgnoreCase(car))  
    31.             c = new Benz();  
    32.         else if("Bmw".equalsIgnoreCase(car))  
    33.             c = new Bmw();  
    34.         return c;  
    35.     }  
    36. }  
    37.   
    38. //老板  
    39. public class BossSimplyFactory {  
    40.   
    41.     public static void main(String[] args) throws IOException {  
    42.         //老板告诉司机我今天坐奔驰  
    43.         Car car = Driver.createCar("benz");  
    44.         car.setName("benz");  
    45.          //司机开着奔驰出发  
    46.         car.drive();  
    47.     }  
    48. <span style="font-family: courier new,courier;">}</span> 

抽象工厂 和 工厂模式 区别：

https://www.zhihu.com/question/20367734

作者：名姓
链接：https://www.zhihu.com/question/20367734/answer/115807228
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

工厂模式也就是鼠标工厂是个父类，有生产鼠标这个接口。
戴尔鼠标工厂，惠普鼠标工厂继承它，可以分别生产戴尔鼠标，惠普鼠标。
生产哪种鼠标不再由参数决定，而是创建鼠标工厂时，由戴尔鼠标工厂创建。
后续直接调用鼠标工厂.生产鼠标()即可


抽象工厂模式

抽象工厂模式也就是不仅生产鼠标，同时生产键盘。
也就是PC厂商是个父类，有生产鼠标，生产键盘两个接口。
戴尔工厂，惠普工厂继承它，可以分别生产戴尔鼠标+戴尔键盘，和惠普鼠标+惠普键盘。
创建工厂时，由戴尔工厂创建。
后续工厂.生产鼠标()则生产戴尔鼠标，工厂.生产键盘()则生产戴尔键盘。

 

DEMO

http://groovy-lang.org/design-patterns.html#_example

def guessFactory = [messages: GuessGameMessages, control: GuessGameControl, converter: GuessGameInputConverter]
def twoupFactory = [messages: TwoupMessages, control: TwoupControl, converter: TwoupInputConverter]

class GameFactory {
    def static factory
    def static getMessages() { return factory.messages.newInstance() }
    def static getControl() { return factory.control.newInstance() }
    def static getConverter() { return factory.converter.newInstance() }
}

 

GameFactory.factory = twoupFactory
def messages = GameFactory.messages
def control = GameFactory.control
def converter = GameFactory.converter
println messages.welcome
def reader = new BufferedReader(new InputStreamReader(System.in))
while (control.moreTurns()) {
    def input = reader.readLine().trim()
    control.play(converter.convert(input))
}
println messages.done
posted @ 2018-03-27 01:57  lightsong  阅读(282)  评论(0)  编辑  收藏  举报
Life Is Short, We Need Ship To Travel