【Java中23种面试常考的设计模式之工厂模式＜＜＜简单工厂VS工厂方法VS抽象工厂＞＞＞(Factory)-----创建型模式】

【Java中23种面试常考的设计模式之工厂模式<<<简单工厂VS工厂方法VS抽象工厂>>>(Factory)-----创建型模式】

知识回顾:

之前我们讲过的设计模式在这里呦:
【面试最常见的设计模式之单例模式】
【面试最常见的设计模式之工厂模式】
【Java中23种面试常考的设计模式之备忘录模式(Memento)—行为型模式】
【Java中23种面试常考的设计模式之观察者模式(Observer)—行为型模式】
【Java中23种面试常考的设计模式之模板模式(Template)—行为型模式】
【Java中23种面试常考的设计模式之状态模式(State)—行为型模式】
【Java中23种面试常考的设计模式之策略模式(Strategy)—行为型模式】
【Java中23种面试常考的设计模式之迭代器模式(Iterator)—行为型模式】
【Java中23种面试常考的设计模式之访问者模式(Visitor)—行为型模式】
【Java中23种面试常考的设计模式之中介者模式(Mediator)—行为型模式】
【Java中23种面试常考的设计模式之解释器模式(Interpreter)—行为型模式】
【Java中23种面试常考的设计模式之命令模式(Command)—行为型模式】
【Java中23种面试常考的设计模式之责任链模式(Chain of Responsibility)—行为型模式】
【Java中23种面试常考的设计模式之适配器模式(Adapter)—结构型模式】
【Java中23种面试常考的设计模式之桥接模式(Bridge)—结构型模式】
【Java中23种面试常考的设计模式之组合模式(Composite)—结构型模式】
【Java中23种面试常考的设计模式之装饰器模式(Decorator)—结构型模式】
【Java中23种面试常考的设计模式之外观模式(Facade)—结构型模式】
【Java中23种面试常考的设计模式之享元模式(Flyweight)—结构型模式】
【Java中23种面试常考的设计模式之代理模式(Proxy)—结构型模式】
【Java中23种面试常考的设计模式之单例模式(Singleton)—创建型模式】
【Java中23种面试常考的设计模式之原型模式(prototype)—创建型模式】
【Java中23种面试常考的设计模式之建造者模式(Builder)—创建型模式】
接下来我们要进行学习的是:【Java中23种面试常考的设计模式之工厂模式<<<简单工厂VS工厂方法VS抽象工厂>>>(Factory)-----创建型模式】。

参考博客来自恩师–>dpb–>波波烤鸭

工厂模式

1. 工厂模式为我们提供了一种最常用的创建对象的方式。
2. 工厂模式是最常用的实例化对象的模式，主要是通过工厂方法代替new关键字创建对象的一种模式。

简单工厂VS工厂方法VS抽象工厂

可以结合的看一下我之前写过的工厂模式的案例

三种工厂模式的注意事项:
简单工厂模式
• 虽然某种程度不符合设计原则，但实际使用最多。
工厂方法模式
• 不修改已有类的前提下，通过增加新的工厂类实现扩展。
抽象工厂模式
• 不可以增加产品，可以增加产品族！

生产开发中常用的使用场景

1. JDK中Calendar的getInstance方法
2. JDBC中Connection对象的获取
3. Hibernate中SessionFactory创建Session
4. Spring中IOC容器创建管理bean对象
5. XML解析时的DocumentBuilderFactory创建解析器对象
6. 反射中Class对象的newInstance()

简单工厂

类图

实现代码

接口定义Car

public interface Car {
	void run();
}
1
2
3

Car的具体实现类

public class Audi implements Car {
	@Override
	public void run() {
		System.out.println("奥迪,Go！");
	}
}
public class Byd implements Car {
	@Override
	public void run() {
		System.out.println("比亚迪,GO!");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

简单工厂

public class CarFactory {
	
	public static  Car createAudi(){
		return new Audi();
	}
	public static  Car createByd(){
		return new Byd();
	}
}
1
2
3
4
5
6
7
8
9

主函数测试类

public class Main{  
	public static void main(String[] args) {
		Car c1 =CarFactory.createAudi();
		Car c2 = CarFactory.createByd();
		
		c1.run();
		c2.run();
	}
}

1
2
3
4
5
6
7
8
9
10

运行结果

总结

1. 简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。
2. 对于增加新产品无能为力！不修改代码的话，是无法扩展的。

工厂方法

类图

实现代码

接口定义Car

public interface Car {
	void run();
}
1
2
3

Car的具体实现类

public class Audi implements Car {
	@Override
	public void run() {
		System.out.println("奥迪，Audi，go！！！ ");
	}
}
public class Byd implements Car {
	@Override
	public void run() {
		System.out.println("比亚迪，Byd ，go！");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

工厂接口

public interface CarFactory {
	Car createCar();
}
1
2
3

工厂接口的具体实现类

public class AudiFactory implements CarFactory {
	@Override
	public Car createCar() {
		return new Audi();
	}
}
public class BydFactory implements CarFactory {
	@Override
	public Car createCar() {
		return new Byd();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

主函数测试类

public class Main{
	public static void main(String[] args) {
		Car c1 = new AudiFactory().createCar();
		Car c2 = new BydFactory().createCar();
		
		c1.run();
		c2.run();
	}
}
1
2
3
4
5
6
7
8
9

运行结果

总结

1. 为了避免简单工厂模式的缺点，工厂方法完全满足开闭原则。
2. 简单工厂模式只有一个工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

简单工厂 VS 工厂方法

1. 结构复杂度
   从这个角度比较，显然简单工厂模式要占优。简单工厂模式只需一个工厂类，而工厂方法模式的工厂类随着产品类个数增加而增加，这无疑会使类的个数越来越多，从而增加了结构的复杂程度。

2. 代码复杂度
   代码复杂度和结构复杂度是一对矛盾，既然简单工厂模式在结构方面相对简洁，那么它在代码方面肯定是比工厂方法模式复杂的了。简单工厂模式的工厂类随着产品类的增加需要增加很多方法（或代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。

3. 客户端编程难度
   工厂方法模式虽然在工厂类结构中引入了接口从而满足了OCP，但是在客户端编码中需要对工厂类进行实例化。而简单工厂模式的工厂类是个静态类，在客户端无需实例化，这无疑是个吸引人的优点。

4. 管理拓展上的难度
   工厂方法模式完全满足OCP，即它有非常良好的扩展性。那是否就说明了简单工厂模式就没有扩展性呢？答案是否定的。简单工厂模式同样具备良好的扩展性——扩展的时候仅需要修改少量的代码（修改工厂类的代码）就可以满足扩展性的要求了。

根据设计理论建议：工厂方法模式。但实际上，我们一般都用简单工厂模式。

抽象工厂

类图

实现代码

引擎接口及其实现类

public interface Engine {
	void run();
	void start();
}


class LuxuryEngine implements Engine{

	@Override
	public void run() {
		System.out.println("转的快！");
	}

	@Override
	public void start() {
		System.out.println("启动快!可以自动启停！");
	}
	
}

class LowEngine implements Engine{
	
	@Override
	public void run() {
		System.out.println("转的慢！");
	}
	
	@Override
	public void start() {
		System.out.println("启动慢!");
	}
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

座位接口及其实现类

public interface Seat {
	void massage();
}

class LuxurySeat implements Seat {

	@Override
	public void massage() {
		System.out.println("可以自动按摩！");
	}
	
}
class LowSeat implements Seat {

	@Override
	public void massage() {
		System.out.println("不能按摩！");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

轮胎接口类及其实现类

public interface Tyre {
	void revolve();
}

class LuxuryTyre implements Tyre {

	@Override
	public void revolve() {
		System.out.println("旋转不磨损！");
	}
}

class LowTyre implements Tyre {

	@Override
	public void revolve() {
		System.out.println("旋转磨损快！");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

抽象工厂接口类

public interface CarFactory {
	Engine createEngine();
	Seat createSeat();
	Tyre createTyre();
}
1
2
3
4
5

LowCarFactory工厂实现类—实现对应的一个产品族1

public class LowCarFactory implements CarFactory {

	@Override
	public Engine createEngine() {
		return new LowEngine();
	}

	@Override
	public Seat createSeat() {
		return new LowSeat();
	}

	@Override
	public Tyre createTyre() {
		return new LowTyre();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

LuxuryCarFactory 工厂实现类—实现对应的一个产品族1

public class LuxuryCarFactory implements CarFactory {

	@Override
	public Engine createEngine() {
		return new LuxuryEngine();
	}

	@Override
	public Seat createSeat() {
		return new LuxurySeat();
	}

	@Override
	public Tyre createTyre() {
		return new LuxuryTyre();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

主函数测试类

public class Main{
	public static void main(String[] args) {
		CarFactory  factory = new LuxuryCarFactory();
		Engine e = factory.createEngine();
		e.run();
		e.start();
	}
}

1
2
3
4
5
6
7
8
9

运行结果

总结

1. 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
2. 抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

好了，到这里【Java中23种面试常考的设计模式之工厂模式<<<简单工厂VS工厂方法VS抽象工厂>>>(Factory)-----创建型模式】，23种设计模式持续更新汇总中。