简单工厂模式：
简单工厂模式又叫做静态工厂（Static Factory）模式，但不属于23种GOF设计模式之一。简单工厂模式是根据传入的参数决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单但最实用的模式。
下面以生产车的工厂案例来展示简单工厂模式：
//抽象产品类
public interface Car {
void run();
}
//具体产品类
public class Audi implements Car {
@Override
public void run() {
System.out.println("奥迪runing");
}
}
//具体产品类
public class Byd implements Car {
@Override
public void run() {
System.out.println("比亚迪runing");
}
}
//生产车的工厂类
public class CarFactory {
public static Car createCar(String type) {
if("奥迪".equals(type)) {
return new Audi();
}else if ("比亚迪".equals(type)) {
return new Byd();
}else {
return null;
}
}
}
//调用者类
public class FactoryDemo01 {
public static void main(String[] args) {
Car c1 = CarFactory.createCar("奥迪");
Car c2 = CarFactory.createCar("比亚迪");
c1.run();
c2.run();
}
}
工厂方法模式：
由于简单工厂模式对于增加新产品无能为力，不修改代码的话，无法扩展，也就是不完全符合开闭原则。工厂方法模式可以避免这个缺点，工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。
1 //抽象工厂类
2 public interface CarFactorys {
3 Car createCar();
4 }
5
6 //抽象产品类
7 public interface Car {
8 void run();
9 }
10
11 //具体工厂类
12 public class AudiFactory implements CarFactorys {
13 @Override
14 public Car createCar() {
15 return new Audi();
16 }
17 }
18
19 //具体工厂类
20 public class BydFactory implements CarFactorys {
21 @Override
22 public Car createCar() {
23 return new Byd();
24 }
25 }
26
27 //调用者类
28 public class FactoryDemo2 {
29
30 public static void main(String[] args) {
31 Car c1 = new AudiFactory().createCar();
32 Car c2 = new BydFactory().createCar();
33 c1.run();
34 c2.run();
35 }
36 }
简单工厂模式和工厂方法模式比较：
- 结构复杂度：
从这个角度看，简单工厂模式显然更占优势，因为它只需一个工厂类，而工厂方法需要为每个产品类设置工厂类，这无疑使类的个数越来越多，从而导致结构更复杂。
- 代码复杂度：
代码复杂度和结构复杂度是一对矛盾，简单工厂模式的工厂类随着产品类的增加需要增加很多方法，而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。
- 客户端编程难度：
工厂方法模式虽然在工厂类结构中引入了接口从而满足了开闭原则，但是在客户端编码中需要对工厂类进行实例化，而简单工厂模式的工厂类是个静态类，在客户端无需实例 化，这无疑是个吸引人的优点。
- 管理上的难度：
首先从扩展性上来说，工厂方法模式完全满足开闭原则，即拥有非常良好的扩展性，那是否说明简单工厂模式就没有扩展性呢？答案是否定的，简单工厂模式同样具备良好的扩展性--扩展的时候仅需修改少了代码（工厂类的代码）就可以达到扩展的要求然后从维护性上来说，假如某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。当同时需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦，反而简单工厂没有这些麻烦，当多个产品类需要修改时，简单工厂模式仍然仅需修改唯一的工厂类。
选择：根据设计理论建议是选择工厂方法模式，但实际上，一般是用简单工厂模式。
抽象工厂模式：
- 用来生产不同产品族的全部产品（对于增加新的产品无能为力，支持增加产品族）
- 抽象工厂模式是工厂方法的升级版，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
1 //抽象产品类
2 public interface Engine {
3
4 void run();
5 void start();
6 }
7
8 //具体产品类
9 class LuxuryEngine implements Engine{
10 @Override
11 public void run() {
12
13 System.out.println("转的飞快");
14 }
15 @Override
16 public void start() {
17
18 System.out.println("启动快！");
19 }
20 }
21
22 //具体产品类
23 class LowEngine implements Engine{
24
25 @Override
26 public void run() {
27 System.out.println("转的慢");
28 }
29
30 @Override
31 public void start() {
32 System.out.println("启动慢！");
33 }
34
35 }
36
37 //抽象产品类
38 public interface Seat {
39
40 void massage();
41 }
42
43 //具体产品类
44 class LuxurySeat implements Seat{
45 @Override
46 public void massage() {
47 System.out.println("可以自动按摩");
48 }
49 }
50
51 //具体产品类
52 class LowSeat implements Seat{
53 @Override
54 public void massage() {
55 System.out.println("不能按摩！");
56 }
57 }
58
59 //抽象产品类
60 public interface Tyre {
61 void revolve();
62 }
63
64 //具体产品类
65 class LuxuryTyre implements Tyre{
66 @Override
67 public void revolve() {
68 System.out.println("橡胶耐磨！");
69 }
70 }
71
72 //具体产品类
73 class LowTyre implements Tyre{
74 @Override
75 public void revolve() {
76 System.out.println("橡胶磨损快！");
77 }
78 }
79
80 //抽象工厂类
81 public interface CarFactory {
82
83 Engine createEngine();
84 Seat createSeat();
85 Tyre createTyre();
86 }
87
88 //具体工厂类（生产的是一个产品族）
89 public class LowCarFactory implements CarFactory{
90 @Override
91 public Engine createEngine() {
92 return new LowEngine();
93 }
94
95 @Override
96 public Seat createSeat() {
97 return new LowSeat();
98 }
99
100 @Override
101 public Tyre createTyre() {
102 return new LowTyre();
103 }
104 }
105
106 //具体工厂类（生产的是一个产品族）
107 public class LuxuryCarFactory implements CarFactory{
108
109 @Override
110 public Engine createEngine() {
111 return new LuxuryEngine();
112 }
113
114 @Override
115 public Seat createSeat() {
116 return new LuxurySeat();
117 }
118
119 @Override
120 public Tyre createTyre() {
121 return new LowTyre();
122 }
123 }
124
125 //调用者类
126 public class Client {
127
128 public static void main(String[] args) {
129 CarFactory factory = new LuxuryCarFactory();
130 Engine e = factory.createEngine();
131 e.run();
132 e.start();
133 }
134 }
总结：
--简单工厂模式（静态工厂模式）
虽然某种程度不符合设计原则，但实际使用最多。
--工厂方法模式
不修改已有类的前提下，通过增加新的工厂类实现扩展
--抽象工厂模式
不可以增加产品，可以增加产品族
应用场景：
- JDK中Calendar的getInstance方法
- JDBC中Connection对象的获取
- 反射中Class对象的newInstance()
- XML解析时的DocumentBuilderFactory创建解析器对象
- Spring中IOC容器创建管理bean对象
来源：https://www.cnblogs.com/jie-y/p/10758759.html