【设计模式】工厂模式

文章目录

- - 1. 简介
  - 2. 无工厂模式
  - 3. 简单工厂模式
  - 4. 工厂模式
  - 5. 抽象工厂模式

1. 简介

工厂模式：
- 实现了创建者和调用者的分离
- 详细分类：
  - 简单工厂模式
  - 工厂方法模式
  - 抽象工厂模式
面向对象设计的基本原则：
- OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭
- DIP（依赖倒转原则，Dependence Inversion Principle）：要针对接口编程，不要针对实现编程
- LoD（迪米特法则。Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信
核心本质：
- 实例化对象，用工厂方法代替new操作
- 将选择实现类、创建对象统一管理和控制，从而将调用者跟我们的实现类解耦
工厂模式：
- 简单工厂模式
  - 用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
- 工厂方法模式
  - 用来生产同一等级结构中的固定产品（支持增加任意产品）
- 抽象工厂模式
  - 用来生产不同产品类的全部产品（对于增加新的产品，无能为力，支持增加产品族）

2. 无工厂模式

创建car接口

public interface Car {
	void run();
}

创建Audi类

public class Audi implements Car {

	@Override
	public void run() {
		System.out.println("Audi.run()");
	}

}

创建Byd类

public class Byd implements Car {

	@Override
	public void run() {
		System.out.println("Byd.run()");
	}

}

测试

/**
 * 测试在没有工厂模式的情况
 */
public class Client {// 调用者
	public static void main(String[] args) {
		Car c1 = new Audi();
		Car c2 = new Byd();
		c1.run();
		c2.run();
	}
}

控制台打印

Audi.run()
Byd.run()

Client依赖Car、Audi、Byd

3. 简单工厂模式

创建工厂类

/**
 * Car工厂
 */
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;
		}
	}
}

不符合开闭原则，增加新的Car实现，需要修改原代码

测试

/**
 * 测试在简单工厂模式的情况
 */
public class Client {// 调用者
	public static void main(String[] args) {
		Car c1 = CarFactory.createCar("奥迪");
		Car c2 = CarFactory.createCar("比亚迪");
		c1.run();
		c2.run();
	}
}

控制台打印

Audi.run()
Byd.run()

CarFactory依赖Car、Audi、Byd，但Client只依赖CarFactory和Car
调用者不需要知道内部调用关系

补充：
简单工厂的另一种实现

/**
 * Car工厂
 */
public class CarFactory {
	public static Car createAudi() {
		return new Audi();
	}

	public static Car createByd() {
		return new Byd();
	}
}

测试

/**
 * 测试在简单工厂模式的情况
 */
public class Client {// 调用者
	public static void main(String[] args) {
		Car c1 = CarFactory.createAudi();
		Car c2 = CarFactory.createByd();
		c1.run();
		c2.run();
	}
}

控制台打印

Audi.run()
Byd.run()

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

简单工厂模式比较常用

4. 工厂模式

工厂方法模式要点：
- 为了避免简单工厂模式的缺点，不完全满足OCP（开闭原则）
- 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的实现类

创建工厂接口

/**
 * 工厂接口
 */
public interface CarFactory {
	Car createCar();
}

创建Audi工厂类

/**
 * Audi工厂类
 */
public class AudiFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Audi();
	}

}

创建Byd工厂类

/**
 * 比亚迪工厂类
 */
public class BydFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Byd();
	}

}

测试

/**
 * 测试工厂模式
 */
public class Client {
	public static void main(String[] args) {
		Car c1 = new AudiFactory().createCar();
		Car c2 = new BydFactory().createCar();
		c1.run();
		c2.run();
	}
}

控制台打印

Audi.run()
Byd.run()

now，我们要扩展一个新的Car实现类Benz

创建Benz类

public class Benz implements Car {

	@Override
	public void run() {
		System.out.println("Benz.run()");
	}

}

创建Benz工厂

/**
 * 奔驰工厂类
 */
public class BenzFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Benz();
	}

}

测试

/**
 * 测试工厂模式
 */
public class Client {
	public static void main(String[] args) {
		Car c1 = new AudiFactory().createCar();
		Car c2 = new BydFactory().createCar();
		c1.run();
		c2.run();
		// --------
		Car c3 = new BenzFactory().createCar();
		c3.run();
	}
}

控制台打印

Audi.run()
Byd.run()
Benz.run()

虽然符合开闭原则但是需要新增工厂类来实现
根据设计理论建议：工厂方法模式。但实际上，我们一般都用简单工厂模式。

5. 抽象工厂模式

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

创建引擎接口及实现

/**
 * 引擎接口
 */
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("低端引擎启动");
	}

}

创建座椅接口及实现

/**
 * 座椅接口
 */
public interface Seat {
	void message();
}

/**
 * 豪华座椅
 */
class LuxurySeat implements Seat {

	@Override
	public void message() {
		System.out.println("豪华座椅自动按摩");
	}

}

/**
 * 低端座椅
 */
class LowSeat implements Seat {

	@Override
	public void message() {
		System.out.println("低端座椅无自动按摩");
	}

}

创建轮胎接口及实现

/**
 * 轮胎接口
 */
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("低端轮胎转速慢");
	}

}

创建工厂接口及实现

/**
 * 汽车工厂接口
 */
public interface CarFactory {
	Engine createEngine();

	Seat createSeat();

	Tyre createTyre();
}

/**
 * 豪华汽车工厂
 */
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();
	}

}

/**
 * 低端汽车工厂
 */
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();
	}

}

测试

public class Client {// 调用者
	public static void main(String[] args) {
		CarFactory c1 = new LuxuryCarFactory();
		Engine engine1 = c1.createEngine();
		engine1.start();
		engine1.run();
		Seat seat1 = c1.createSeat();
		seat1.message();
		Tyre tyre1 = c1.createTyre();
		tyre1.revolve();
		System.out.println("----------");
		CarFactory c2 = new LowCarFactory();
		Engine engine2 = c2.createEngine();
		engine2.start();
		engine2.run();
		Seat seat2 = c2.createSeat();
		seat2.message();
		Tyre tyre2 = c2.createTyre();
		tyre2.revolve();
	}
}

控制台打印

豪华引擎启动
豪华引擎运行
豪华座椅自动按摩
豪华轮胎转速快
----------
低端引擎启动
低端引擎运行
低端座椅无自动按摩
低端轮胎转速慢

工厂模式要点：
- 简单工厂模式（静态工厂模式）
  - 虽然某种程度不符合设计原则，但实际使用最多
- 工厂方法模式
  - 不修改已有类的前提下，通过增加新的工厂类实现扩展
- 抽象工厂模式
  - 不可以增加产品，可以增加产品族

更多推荐

【设计模式】工厂模式

【设计模式】工厂模式

文章目录

1. 简介

2. 无工厂模式

3. 简单工厂模式

4. 工厂模式

5. 抽象工厂模式

发布评论取消回复

最近发表

热门文章

标签列表

【设计模式】工厂模式

文章目录

1. 简介

2. 无工厂模式

3. 简单工厂模式

4. 工厂模式

5. 抽象工厂模式

相关文章

发布评论取消回复

最近发表

热门文章

标签列表