创建型模式5之2-AbstractFactory抽象工厂模式例子理解
2016-01-14 15:26
323 查看
例子一
例子二
例子三
![](https://oscdn.geek-share.com/Uploads/Images/Content/201601/14/ee0e6aeffd11afff91f2c2e5ab90b191)
抽象工厂模式的优点
抽象工厂模式除了具有工厂方法模式的优点外,最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族,一般或多或少的都存在一定的关联,抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述,而不必专门引入一个新的类来进行管理。
抽象工厂模式的缺点
产品族的扩展将是一件十分费力的事情,假如产品族中需要增加一个新的产品,则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时,对产品等级结构的划分是非常重要的。
适用场景
当需要创建的对象是一系列相互关联或相互依赖的产品族时,便可以使用抽象工厂模式。说的更明白一点,就是一个继承体系中,如果存在着多个等级结构(即存在着多个抽象类),并且分属各个等级结构中的实现类之间存在着一定的关联或者约束,就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束,则使用多个独立的工厂来对产品进行创建,则更合适一点。
总结
无论是简单工厂模式,工厂方法模式,还是抽象工厂模式,他们都属于工厂模式,在形式和特点上也是极为相似的,他们的最终目的都是为了解耦。在使用时,我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式,因为他们之间的演变常常是令人琢磨不透的。经常你会发现,明明使用的工厂方法模式,当新需求来临,稍加修改,加入了一个新方法后,由于类中的产品构成了不同等级结构中的产品族,它就变成抽象工厂模式了;而对于抽象工厂模式,当减少一个方法使的提供的产品不再构成产品族之后,它就演变成了工厂方法模式。
所以,在使用工厂模式时,只需要关心降低耦合度的目的是否达到了。
========================
补充例子:
1。BoyInterface
2。GirlInterface
3。PersonFactory
4。ChineseBoy
5。ChineseGirl
6。AmericanBoy
7。AmericanGirl
8。AmericanFactory
9。ChineseFactory
10。Test
11。结果
package com.AbstractFactoryModel; /** * 抽象工厂:多个抽象产品类,派生出多个具体产品类;一个抽象工厂类,派生出多个具体工厂类;每个具体工厂类可创建多个具体产品类的实例。 即提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们的具体的类。“一对多”的关系。 抽象工厂: (1) 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有形态的工厂模式都是重要的。 (2) 这个系统有多于一个的产品族,而系统只消费其中某一产品族。 (3) 同属于同一个产品族的产品是在一起使用的,这一约束必须在系统的设计中体现出来。 (4) 系统提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于实现。 * @author Administrator * */ //定义不同的产品之间的一定具备的标准,用interface实现 //其中的method()方法可看作提取出不同产品的共性,如手机都有类似的功能 interface IProductA {//设想:苹果手机 public void method();//设想:手机生产方法 } interface IProductB {//设想:安卓手机 public void method();//假设:手机生产方法 } // 实现了产品标准实现的一系列具体产品 // 由于已经设计好A1由厂商1生产,故以下输出代码有“厂商x” class ProductA1 implements IProductA { public void method() { System.out.println("厂商1 生产ProductA1 ...");//设想:苹果公司设计了6s } } class ProductA2 implements IProductA { public void method() { System.out.println("厂商2 生产ProductA2 ...");//设想:苹果公司设计了6s plus } } class ProductB1 implements IProductB { public void method() { System.out.println("厂商1 生产ProductB1 ...");//设想:华为公司设计了荣耀6 } } class ProductB2 implements IProductB { public void method() { System.out.println("厂商2 生产ProductB2 ...");//设想:华为公司设计了荣耀6 plus } } // 每一种牌子的产品生产工厂,即不同的厂商负责自己牌子产品的生产 abstract class Factory1 { abstract IProductA getProductA1();//设想:富士康公司代工生产了苹果6s abstract IProductB getProductB1();//设想:富士康公司代工生产了荣耀6 } abstract class Factory2 { abstract IProductA getProductA2();//设想:台电公司代工生产了苹果6s plus abstract IProductB getProductB2();//设想:台电公司代工生产了荣耀6 plus } // 具体的工厂用来生产相关的产品 class ConcreteFactory1 extends Factory1 { public IProductA getProductA1() { return new ProductA1();//设想:富士康公司使用苹果的设计来生产了苹果6s } public IProductB getProductB1() { return new ProductB1();//设想:富士康公司使用华为的设计来生产了荣耀6 } } class ConcreteFactory2 extends Factory2 { public IProductA getProductA2() { return new ProductA2();//设想:台电公司使用华为的设计来生产了苹果6s plus } public IProductB getProductB2() { return new ProductB2();//设想:台电公司使用华为的设计来生产了华为6s plus } } // 测试类 public class AbstractFactoryModel { public static void test() { //设想:富士康公司使用苹果的设计来生产了苹果6s //设想:富士康公司使用华为的设计来生产了荣耀6 // 厂商1负责生产产品A1、B1 Factory1 factory1 = new ConcreteFactory1(); IProductA productA1 = factory1.getProductA1(); IProductB productB1 = factory1.getProductB1(); productA1.method(); productB1.method(); //设想:富士康公司使用苹果的设计来生产了苹果6s plus //设想:富士康公司使用华为的设计来生产了荣耀6 plus // 厂商2负责生产产品A2、B2 Factory2 factory2 = new ConcreteFactory2(); IProductA productA2 = factory2.getProductA2(); IProductB productB2 = factory2.getProductB2(); productA2.method(); productB2.method(); } }
例子二
package com.test.factorymodel; import com.test.factorymodel.AbstractFactory.BigFactory; import com.test.factorymodel.AbstractFactory.SmallFactory; public class AbstractFactory { public interface IScreen {//设想:屏幕技术 } public interface IBody {//设想:机身技术 } public static class BigScreen implements IScreen {//设想:大型屏幕生产 public BigScreen() { // TODO Auto-generated constructor stub System.out.println("BigScreen"); } } public static class SmallScreen implements IScreen {//设想:小型屏幕生产 public SmallScreen() { // TODO Auto-generated constructor stub System.out.println("SmallScreen"); } } public static class BigBody implements IBody {//设想:大型机身生产 public BigBody() { // TODO Auto-generated constructor stub System.out.println("BigBody"); } } public static class SmallBody implements IBody {//设想:小型机身生产 public SmallBody() { // TODO Auto-generated constructor stub System.out.println("SmallBody"); } } public interface IFactory {//设想:工厂机身和屏幕生产 public IScreen createScreen(); public IBody createBody(); } public static class BigFactory implements IFactory {//设想:大工厂的大机身和大屏幕生产 @Override public IScreen createScreen() { // TODO Auto-generated method stub return new BigScreen(); } @Override public IBody createBody() { // TODO Auto-generated method stub return new BigBody(); } } public static class SmallFactory implements IFactory {//设想:小工厂的小机身和小屏幕生产 @Override public IScreen createScreen() { // TODO Auto-generated method stub return new SmallScreen(); } @Override public IBody createBody() { // TODO Auto-generated method stub return new SmallBody(); } } public static class AbstractFactory_Customer { public static void main(String[] args) { BigFactory bigFactory = new BigFactory(); bigFactory.createBody(); bigFactory.createScreen(); SmallFactory smallFactory = new SmallFactory(); smallFactory.createBody(); smallFactory.createScreen(); } } }
例子三
interface CPU { void process(); } interface CPUFactory { CPU produceCPU(); } class AMDFactory implements CPUFactory { public CPU produceCPU() { return new AMDCPU(); } } class IntelFactory implements CPUFactory { public CPU produceCPU() { return new IntelCPU(); } } class AMDCPU implements CPU { public void process() { System.out.println("AMD is processing..."); } } class IntelCPU implements CPU { public void process() { System.out.println("Intel is processing..."); } } class Computer { CPU cpu; public Computer(CPUFactory factory) { cpu = factory.produceCPU(); cpu.process(); } } public class Client { public static void main(String[] args) { new Computer(createSpecificFactory()); } public static CPUFactory createSpecificFactory() { int sys = 0; // 基于特定要求 if (sys == 0) return new AMDFactory(); else return new IntelFactory(); } }
抽象工厂模式的优点
抽象工厂模式除了具有工厂方法模式的优点外,最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族,一般或多或少的都存在一定的关联,抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述,而不必专门引入一个新的类来进行管理。
抽象工厂模式的缺点
产品族的扩展将是一件十分费力的事情,假如产品族中需要增加一个新的产品,则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时,对产品等级结构的划分是非常重要的。
适用场景
当需要创建的对象是一系列相互关联或相互依赖的产品族时,便可以使用抽象工厂模式。说的更明白一点,就是一个继承体系中,如果存在着多个等级结构(即存在着多个抽象类),并且分属各个等级结构中的实现类之间存在着一定的关联或者约束,就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束,则使用多个独立的工厂来对产品进行创建,则更合适一点。
总结
无论是简单工厂模式,工厂方法模式,还是抽象工厂模式,他们都属于工厂模式,在形式和特点上也是极为相似的,他们的最终目的都是为了解耦。在使用时,我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式,因为他们之间的演变常常是令人琢磨不透的。经常你会发现,明明使用的工厂方法模式,当新需求来临,稍加修改,加入了一个新方法后,由于类中的产品构成了不同等级结构中的产品族,它就变成抽象工厂模式了;而对于抽象工厂模式,当减少一个方法使的提供的产品不再构成产品族之后,它就演变成了工厂方法模式。
所以,在使用工厂模式时,只需要关心降低耦合度的目的是否达到了。
========================
补充例子:
1。BoyInterface
package com.test.factorymodel.two4abstractfactory; public interface BoyInterface { public void beMan(); }
2。GirlInterface
package com.test.factorymodel.two4abstractfactory; public interface GirlInterface { public void beWoman(); }
3。PersonFactory
package com.test.factorymodel.two4abstractfactory; public interface PersonFactory { public BoyInterface getBoyInterface(); public GirlInterface getGirlInterface(); }
4。ChineseBoy
package com.test.factorymodel.two4abstractfactory; public class ChineseBoy implements BoyInterface { @Override public void beMan() { // TODO Auto-generated method stub System.out.println("中国男孩"); } }
5。ChineseGirl
package com.test.factorymodel.two4abstractfactory; public class ChineseGirl implements GirlInterface { @Override public void beWoman() { // TODO Auto-generated method stub System.out.println("中国女孩"); } }
6。AmericanBoy
package com.test.factorymodel.two4abstractfactory; public class AmericanBoy implements BoyInterface { @Override public void beMan() { // TODO Auto-generated method stub System.out.println("美国男孩"); } }
7。AmericanGirl
package com.test.factorymodel.two4abstractfactory; public class AmericanGirl implements GirlInterface { @Override public void beWoman() { // TODO Auto-generated method stub System.out.println("美国女孩"); } }
8。AmericanFactory
package com.test.factorymodel.two4abstractfactory; public class AmericanFactory implements PersonFactory { @Override public BoyInterface getBoyInterface() { // TODO Auto-generated method stub return new AmericanBoy(); } @Override public GirlInterface getGirlInterface() { // TODO Auto-generated method stub return new AmericanGirl(); } }
9。ChineseFactory
package com.test.factorymodel.two4abstractfactory; public class ChineseFactory implements PersonFactory { @Override public BoyInterface getBoyInterface() { // TODO Auto-generated method stub return new ChineseBoy(); } @Override public GirlInterface getGirlInterface() { // TODO Auto-generated method stub return new ChineseGirl(); } }
10。Test
package com.test.factorymodel.two4abstractfactory; public class Test { public static void main(String[] args) { PersonFactory c_facoty = new ChineseFactory(); BoyInterface c_boy = c_facoty.getBoyInterface(); c_boy.beMan(); GirlInterface c_girl = c_facoty.getGirlInterface(); c_girl.beWoman(); System.out.println("***************************"); PersonFactory a_facoty = new AmericanFactory(); BoyInterface a_boy = a_facoty.getBoyInterface(); a_boy.beMan(); GirlInterface a_girl = a_facoty.getGirlInterface(); a_girl.beWoman(); } }
11。结果
中国男孩 中国女孩 *************************** 美国男孩 美国女孩
相关文章推荐
- Git协作流程
- Android 模仿网易新闻简单标题栏 《零基础学安卓》
- HttpURLConnection的流式输出的缺陷和解决方法
- WebViewJavascriptBridge使用分析(二)
- Controller生命周期
- 在Unity中使用UGUI修改Mesh绘制几何图形
- mysql 存储过程,搞死人的语法
- 极光推送
- 2.3静态synchronized同步方法和synchronized(class)代码块
- 虚拟机上迁移Linux系统
- Can't connect to local MySQL server through socke
- Latex Skills
- Ubuntu解决make menuconfig错误
- Kotlin 基本语法
- 图片格式那么多,哪种更适合你?
- 线程池的要点分析
- Linux查看文件编码格式及文件编码转换
- Oracle死锁问题分析解决
- NumberUtils的简单学习
- Android之DatePickerDialog用法(日历的用法)