工厂设计模式

什么是工厂设计模式？
看了好多文章，写的五花八门，以下是我对工厂模式的理解，重点是文末我通过大量的文章总结出的抽象工厂模式和工厂模式以及之间的区别，可以让你更好的认识工厂模式。

工厂设计模式，顾名思义，就是用来生产对象的，在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则，如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦

本篇主要介绍三种工厂设计模式的使用：
1、简单工厂
2、工厂方法
3、抽象工厂

简单工厂设计模式

定义：一个工厂方法，依据传入的参数，生成对应的产品对象；
角色：
1、抽象产品
2、具体产品
3、具体工厂
4、产品使用者
使用说明：先将产品类抽象出来，比如，苹果和梨都属于水果，抽象出来一个水果类fruit，苹果和梨就是具体的产品类，然后创建一个水果工厂，分别用来创建苹果和梨；代码如下：

 1 水果接口
 2 
 3 public interface fruit {
 4     void whatim();
 5 }
 6 
 7 具体类 苹果
 8 
 9 public class apple implements fruit {
10     @override
11     public void whatim() {
12         //苹果
13     }
14 }
15 
16 具体类 梨
17 
18 public class pear implements fruit {
19     @override
20     public void whatim() {
21         //梨
22     }
23 }
24 
25 具体工厂 水果工厂
26 
27 public class fruitfactory {
28 
29     public fruit createfruit(string type) {
30 
31         if (type.equals("apple")) {//生产苹果
32             return new apple();
33         } else if (type.equals("pear")) {//生产梨
34             return new pear();
35         }
36 
37         return null;
38     }
39 }
40 
41 产品使用
42 
43  fruitfactory mfactory = new fruitfactory();
44  apple apple = (apple) mfactory.createfruit("apple");//获得苹果
45  pear pear = (pear) mfactory.createfruit("pear");//获得梨

 

就这样，一个非常简单的工厂设计模式就完成了，但是有没有发现什么问题呢？
对，那就是如果我想吃香蕉，想吃橘子呢，我万一什么都想吃呢？？所以，以上的这种方式，每当我想添加一种水果，就必然要修改工厂类，这显然违反了开闭原则，亦不可取；所以简单工厂只适合于产品对象较少，且产品固定的需求，对于产品变化无常的需求来说显然不合适；所以我们来看下一种方式；

工厂方法设计模式

定义：将工厂提取成一个接口或抽象类，具体生产什么产品由子类决定；
角色：
抽象产品类
具体产品类
抽象工厂类
具体工厂类
使用说明：和上例中一样，产品类抽象出来，这次我们把工厂类也抽象出来，生产什么样的产品由子类来决定；
代码如下：
水果接口 苹果类和梨类 代码和上例一样

 1 工厂接口
 2 
 3 public interface fruitfactory {
 4     fruit createfruit();//生产水果
 5 }
 6 
 7 苹果工厂
 8 
 9 public class applefactory implements fruitfactory {
10     @override
11     public fruit createfruit() {
12         return new apple();
13     }
14 }
15 
16 梨工厂
17 
18 public class pearfactory implements fruitfactory {
19     @override
20     public fruit createfruit() {
21         return new pear();
22     }
23 }
24 
25 使用
26 
27 applefactory applefactory = new applefactory();
28 pearfactory pearfactory = new pearfactory();
29 apple apple = (apple) applefactory.createfruit();//获得苹果
30 pear pear = (pear) pearfactory.createfruit();//获得梨

 

以上这种方式，虽然解耦了，也遵循了开闭原则，但是问题根本还是没有解决啊，换汤没换药，如果我需要的产品很多的话，需要创建非常多的工厂，所以这种方式的缺点也很明显；

抽象工厂设计模式

定义：为创建一组相关或者是相互依赖的对象提供的一个接口，而不需要指定它们的具体类。
角色：和工厂方法一样
抽象工厂和工厂方法的模式基本一样，区别在于，工厂方法是生产一个具体的产品，而抽象工厂可以用来生产一组相同，有相对关系的产品；重点在于一组，一批，一系列；举个例子，假如生产小米手机，小米手机有很多系列，小米note、红米note等；假如小米note生产需要的配件有825的处理器，6英寸屏幕，而红米只需要650的处理器和5寸的屏幕就可以了；用抽象工厂来实现：

 1 cpu接口和实现类
 2 
 3 public interface cpu {
 4     void run();
 5 
 6     class cpu650 implements cpu {
 7         @override
 8         public void run() {
 9             //625 也厉害
10         }
11     }
12 
13     class cpu825 implements cpu {
14         @override
15         public void run() {
16             //825 处理更强劲
17         }
18     }
19 }
20 
21 屏幕接口和实现类
22 
23 public interface screen {
24 
25     void size();
26 
27     class screen5 implements screen {
28 
29         @override
30         public void size() {
31             //5寸
32         }
33     }
34 
35     class screen6 implements screen {
36 
37         @override
38         public void size() {
39             //6寸
40         }
41     }
42 }
43 
44 工厂接口
45 
46 public interface phonefactory {
47 
48     cpu getcpu();//使用的cpu
49 
50     screen getscreen();//使用的屏幕
51 }
52 
53 具体工厂实现类：小米手机工厂
54 
55 public class xiaomifactory implements phonefactory {
56     @override
57     public cpu getcpu() {
58         return new cpu.cpu825();//高性能处理器
59     }
60 
61     @override
62     public screen getscreen() {
63         return new screen.screen6();//6寸大屏
64     }
65 }
66 
67 具体工厂实现类：红米手机工厂
68 
69 public class hongmifactory implements phonefactory {
70 
71     @override
72     public cpu getcpu() {
73         return new cpu.cpu650();//高效处理器
74     }
75 
76     @override
77     public screen getscreen() {
78         return new screen.screen5();//小屏手机
79     }
80 }

 

以上例子可以看出，抽象工厂可以解决一系列的产品生产的需求，对于大批量，多系列的产品，用抽象工厂可以更好的管理和扩展；

抽象工厂模式与工厂模式的区别（重点理解）

    工厂方法模式： 一个抽象产品类，可以派生出多个具体产品类。 一个抽象工厂类，可以派生出多个具体工厂类。 每个具体工厂类只能创建一个具体产品类的实例。
    
    抽象工厂模式： 多个抽象产品类（），每个抽象产品类可以派生出多个具体产品类。 一个抽象工厂类，可以派生出多个具体工厂类。 每个具体工厂类可以创建多个具体产品类的实例。
    
　　区别： 工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个，并且多个产品类之间是有一定的依赖关系。 工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。