程序博客网 > 偏偏喜欢你淘宝续

工厂设计模式 factory

来源：互联网 发布：偏偏喜欢你淘宝续 编辑：程序博客网 时间：2024/04/20 00:13

设计模式（一）--静态工厂模式

静态工厂模式（static factory）也叫简单工厂模式。
涉及到3个角色：工厂类角色，抽象产品类角色和具体产品类角色。
抽象产品类可以使用接口或者父类来描述产品对象的行为特征。
具体产品类就是某一具体的对象。
静态工厂类有一个静态的方法，含有判断逻辑，决定要创建哪一种具体的产品对象。


其设计模式如下：


抽象产品类  IProduct

[java] view plaincopy
  1. package org.test.design.sf;  
  2.   
  3. public interface IProduct {  
  4.     void work();  
  5. }  
具体产品类   ProductA   ProductB 


[java] view plaincopy
  1. package org.test.design.sf;  
  2.   
  3. public class ProductA implements IProduct {  
  4.   
  5.     public void work() {  
  6.         System.out.println("Here is ProductA, for your dedicated service.");  
  7.     }  
  8.   
  9. }  

[java] view plaincopy
  1. package org.test.design.sf;  
  2.   
  3. public class ProductB implements IProduct {  
  4.   
  5.     public void work() {  
  6.         System.out.println("Here is ProductB, for your dedicated service.");  
  7.     }  
  8.   
  9. }  

工厂类  ProductFactory  

[java] view plaincopy
  1. package org.test.design.sf;  
  2.   
  3. /** 
  4.  * 静态工厂模式 
  5.  * @author lushuaiyin 
  6.  * 
  7.  */  
  8. public class ProductFactory {  
  9.     public static IProduct product=null;//静态  
  10.     //静态方法  
  11.     public static IProduct getProduct(String productType) throws InstantiationException, IllegalAccessException, ClassNotFoundException{  
  12. //      if(productType==null||productType.trim().equals("")){//默认创建ProductA  
  13. //          product=new ProductA();  
  14. //      }else if(productType.trim().equals("ProductA")){  
  15. //          product=new ProductA();  
  16. //      }else if(productType.trim().equals("ProductB")){  
  17. //          product=new ProductB();  
  18. //      }  
  19.           
  20.         //静态工厂一般使用类的反射来构建对象，像上面的构建也可以。  
  21.         if(productType.trim().equals("ProductA")){  
  22.             product=(IProduct)Class.forName("org.test.design.sf.ProductA").newInstance();  
  23.         }else if(productType.trim().equals("ProductB")){  
  24.             product=(IProduct)Class.forName("org.test.design.sf.ProductB").newInstance();  
  25.         }  
  26.         return product;  
  27.     }  
  28.   
  29. }  

测试：

[java] view plaincopy
  1. package org.test.design.sf;  
  2.   
  3. public class TestMain {  
  4.   
  5.     /** 
  6.      * @param args 
  7.      * @throws ClassNotFoundException  
  8.      * @throws IllegalAccessException  
  9.      * @throws InstantiationException  
  10.      */  
  11.     public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {  
  12.         IProduct product_a=ProductFactory.getProduct("ProductA");  
  13.         product_a.work();  
  14.         IProduct product_b=ProductFactory.getProduct("ProductB");  
  15.         product_b.work();  
  16.           
  17.     }  
  18.   
  19. }  
  20.   
  21. /*打印 
  22. Here is ProductA, for your dedicated service. 
  23. Here is ProductB, for your dedicated service. 
  24.  
  25. */  



这种模式的优点就是，工厂类负责所有产品对象的创建，客户端在
需要创建对象时，告诉工厂需要哪种类型，工厂就负责创建。


缺点：把所有类型的对象集中在一种工厂创建。当产品对象在以后出现
新的类型以及类型结构变得复杂，这个工厂就会显得简单混乱。
比如，一个生产自行车的工厂，它会生产各种自行车，男士女士的等等。
随着工厂发展壮大，它收购了电视工厂。这时候，工厂还是叫自行车制造厂。
但是生产电视。也就是在工厂类中加入了新的产品类型：电视。
这样的工厂也能正常运转，但是结构显得简单，功能混乱。
同时使用静态方法，也无法实现子类继承。
解决这样的问题就涉及到另一种稍显复杂的模式：工厂模式。


设计模式（二）---工厂模式


工厂模式（factory）
涉及到4个角色：抽象工厂类角色，具体工厂类角色,抽象产品类角色和具体产品类角色。
抽象工厂类角色使用接口或者父类来描述工厂的行为，
具体工厂类角色负责创建某一类型的产品对象。
抽象产品类可以使用接口或者父类来描述产品对象的行为特征。
具体产品类就是某一具体的对象。


工厂模式不同于静态工厂模式的地方：
工厂模式在工厂类也实现了多态，而不仅仅是在产品对象上实现多态。
它可以应对不同类型的产品对应一种具体的工厂。


其设计模式如下：


抽象工厂类  IFactory 

[java] view plaincopy
  1. package org.test.design.f;  
  2.   
  3. /** 
  4.  *  
  5.  * @author lushuaiyin 
  6.  * 
  7.  */  
  8. public interface IFactory {  
  9.     IProduct createProduct();  
  10. }  

具体工厂类  CarFactory   ComputerFactory   

[java] view plaincopy
  1. package org.test.design.f;  
  2.   
  3. public class CarFactory implements IFactory {  
  4.   
  5.     public IProduct createProduct() {  
  6.         return new Car();  
  7.     }  
  8.   
  9. }  



[java] view plaincopy
  1. package org.test.design.f;  
  2.   
  3. public class ComputerFactory implements IFactory {  
  4.   
  5.     public IProduct createProduct() {  
  6.         return new Computer();  
  7.     }  
  8.   
  9. }  

抽象产品类  IProduct

[java] view plaincopy
  1. package org.test.design.f;  
  2.   
  3. public interface IProduct {  
  4.     void work();  
  5. }  

具体产品类  Car  Computer  

[java] view plaincopy
  1. package org.test.design.f;  
  2.   
  3. public class Car implements IProduct{  
  4.   
  5.     public void work() {  
  6.         System.out.println("I am car.");  
  7.     }  
  8.   
  9. }  

[java] view plaincopy
  1. package org.test.design.f;  
  2.   
  3. public class Computer implements IProduct{  
  4.     public void work() {  
  5.         System.out.println("I am Computer.");  
  6.     }  
  7. }  


测试：

[java] view plaincopy
  1. package org.test.design.f;  
  2.   
  3. public class TestMain {  
  4.   
  5.     /** 
  6.      * @param args 
  7.      */  
  8.     public static void main(String[] args) {  
  9.         IFactory carFactory=new CarFactory();  
  10.         IProduct car=(IProduct)carFactory.createProduct();  
  11.         car.work();  
  12.           
  13.         IFactory pcFactory=new ComputerFactory();  
  14.         IProduct pc=(IProduct)pcFactory.createProduct();  
  15.         pc.work();  
  16.     }  
  17.   
  18. }  
  19. /*打印 
  20. I am car. 
  21. I am Computer. 
  22.  */  
设计模式（三）---抽象工厂模式

具体工厂类：生产创建某一类具体产品对象。
抽象产品类可以使用接口或者父类来描述产品对象的行为特征。
具体产品类就是某一具体的对象。


那么抽象工厂模式和工厂模式的不同之处呢？
其实最大的不同就在于，在产品类的结构更加复杂时，抽象工厂模式针对不同
的产品族(就是一类产品对象)定义了不同的行为，也就是在父类或接口中，定义了不同
的产生方法。不同的产品族调用各自的创建方法。同时不同的产品族横向比较，也有可
归类的相同特征，这些特征就具体到某一个工厂中体现了。


例如苹果公司生产手机和平板电脑。
这明显是2个不同的产品族。手机和平板电脑就不是同一类产品。
所以在工厂中定义工厂的行为时，就需要为这两种产品族各自设计一个创建方法。
而具体到某一个工厂，它都会生产这两种产品，这两种产品横向比较其实还有共同点，
那就是某一时间段的苹果工厂生产的型号是有规律的，所以2011年的工厂就不会产生iphone5
这个产品对象（因为那时候还没有iphone5）


和工厂模式比，抽象工厂模式其实更加复杂化了，当产品族只有一个时，自然而然
就退化到使用工厂模式了。


设计模式：



抽象工厂类   IAppleFactroy 

[java] view plaincopy
  1. package org.test.design.abf;  
  2.   
  3. /** 
  4.  *  
  5.  * @author lushuaiyin 
  6.  * 
  7.  */  
  8. public interface IAppleFactroy {  
  9.     IComputer createComputer();  
  10.     IMobile createMobile();  
  11. }  

具体工厂类  AppleFactoryIn2011    AppleFactoryIn2012   

[java] view plaincopy
  1. package org.test.design.abf;  
  2.   
  3. /** 
  4.  *  
  5.  * @author lushuaiyin 
  6.  * 
  7.  */  
  8. public class AppleFactoryIn2011 implements IAppleFactroy{  
  9.   
  10.     public IComputer createComputer() {  
  11.         return new Pad3();  
  12.     }  
  13.   
  14.     public IMobile createMobile() {  
  15.         return new Phone4s();  
  16.     }  
  17.   
  18. }  

[java] view plaincopy
  1. package org.test.design.abf;  
  2.   
  3. /** 
  4.  *  
  5.  * @author lushuaiyin 
  6.  * 
  7.  */  
  8. public class AppleFactoryIn2012 implements IAppleFactroy{  
  9.   
  10.     public IComputer createComputer() {  
  11.         return new PadMini();  
  12.     }  
  13.   
  14.     public IMobile createMobile() {  
  15.         return new Phone5();  
  16.     }  
  17.   
  18. }  

抽象产品类  IMobile   IComputer  

[java] view plaincopy
  1. package org.test.design.abf;  
  2.   
  3. public interface IMobile {  
  4.     void call();  
  5. }  

[java] view plaincopy
  1. package org.test.design.abf;  
  2.   
  3. public interface IComputer {  
  4.     void play();  
  5. }  

具体产品类   Pad3    PadMini    Phone4s   Phone5  

[java] view plaincopy
  1. package org.test.design.abf;  
  2.   
  3. public class Pad3 implements IComputer{  
  4.     public void play() {  
  5.         System.out.println("I am iPad3.");  
  6.     }  
  7. }  

[java] view plaincopy
  1. package org.test.design.abf;  
  2.   
  3. public class PadMini  implements IComputer{  
  4.     public void play() {  
  5.         System.out.println("I am iPad Mini.");  
  6.     }  
  7. }  
[java] view plaincopy
  1. package org.test.design.abf;  
  2.   
  3. public class Phone4s implements IMobile {  
  4.   
  5.     public void call() {  
  6.         System.out.println("I am IPhone 4s.");  
  7.     }  
  8.   
  9. }  
[java] view plaincopy
  1. package org.test.design.abf;  
  2.   
  3. public class Phone5 implements IMobile {  
  4.     public void call() {  
  5.         System.out.println("I am IPhone 5.");  
  6.     }  
  7. }  


测试：

[java] view plaincopy
  1. package org.test.design.abf;  
  2.   
  3. public class TestMain {  
  4.   
  5.     /** 
  6.      * @param args 
  7.      */  
  8.     public static void main(String[] args) {  
  9.         IAppleFactroy factory2011=new AppleFactoryIn2011();  
  10.         IComputer ipad3=factory2011.createComputer();  
  11.         ipad3.play();  
  12.         IMobile iphone4s=factory2011.createMobile();  
  13.         iphone4s.call();  
  14.           
  15.         IAppleFactroy factory2012=new AppleFactoryIn2012();  
  16.         IComputer ipad_mini=factory2012.createComputer();  
  17.         ipad_mini.play();  
  18.         IMobile iphone5=factory2012.createMobile();  
  19.         iphone5.call();  
  20.     }  
  21.   
  22. }  
  23. /*打印 
  24. I am iPad3. 
  25. I am IPhone 4s. 
  26. I am iPad Mini. 
  27. I am IPhone 5. 
  28.  **/  
转自： http://blog.csdn.net/lushuaiyin/article/details/8917334
0 0
偏偏喜欢你淘宝续 偏偏喜欢你淘宝续
原创粉丝点击
热门IT博客
js控制input选中状态js控制input选中状态
金太阳炒股软件下载金太阳炒股软件下载
广东软件企业认定
网络隔离
rewear it
走迷宫java代码
foobar2000网络歌曲
alan g mac diarmid
抢占式算法视频教程
怎么用vps建站
狗语翻译机软件
赌nba的软件
java编码转换utf8
linux home目录扩容
电脑字体软件
js对象数组添加元素
liunx启动mysql
淘宝客主题模板
淘宝一族的货在哪进货
java jdbc连接池实例
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 海博伦三件套怎么获得 海博伦三件套获得途径 青岛海博 海博出租 北京金泰海博酒店 北京建工博海建设有限公司 海博论坛 海杆线组安装图解 海钓线组组装图解 海卡组 观海卫宾馆 广州海印桥 海印桥南 海印桥 海印苑小区 海参崴 旅游 海参崴时间 海参歪 海参葳 海参崴在哪 海参崴特产 海参崴图片 去海参崴需要签证吗 海参崴的景点 海参崴旅游攻略 海参崴自助游 海参崴怎么去 俄罗斯海参崴旅游攻略 海参崴旅游注意事项 海参崴在哪里 海参崴是中国的吗 去海参崴旅游 去海参崴旅游多少钱 海参崴买什么便宜 海参崴购物非常便宜 海参威 闯荡漫威之毒液 海参猫 海参威在哪里 烟台明威海参价格 海参威的30万中国人 海参威旅游

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里