GoF23设计模式-创建型设计模式：工厂模式

最新推荐文章于 2021-08-14 20:58:54 发布

来临

最新推荐文章于 2021-08-14 20:58:54 发布

阅读量108

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/chai1143126501/article/details/111428929

版权

设计模式专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、工厂模式是如何形成的？

原始社会自给自足（没有工厂），农耕社会小作坊（简单工厂，民间酒坊），工业革命流水线（工厂方法，自产自销），现代产业链代工厂（抽象工厂，富士康）。我们的项目代码同样是由简到繁一步一步迭代而来的，但对于调用者来说，却越来越简单

工厂模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

工厂模式业务场景划分：有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

二、简单工厂模式

package com.project.factory.simpleFactory;

/**
 * 简单工厂
 * 	创建实例的方法通常是静态方法，因此又称静态工厂
 *  简单工厂模式有一个具体的工厂类，可以生成多个不同的产品
 */
public class CarFactory {
	//传参类型方式
	public static Car createCar(String type){
		if("Audi".equals(type)){
			return new Audi();
		}else if("Byd".equals(type)){
			return new Byd();
		}else{
			return null;
		}
	}
	
	//每种类型创建方式
	public static Car createAudi(){
		return new Audi();
	}
	
	public static Car createByd(){
		return new Byd();
	}
}

package com.project.factory.simpleFactory;

/**
 * 调用者
 */
public class Client {
	public static void main(String[] args) {
		//第一种
		Car c1 = CarFactory.createCar("Audi");
		c1.run();
		//第二种
		Car c2 = CarFactory.createAudi();
		c2.run();
		
	}
}

package com.project.factory.simpleFactory;

public interface Car {
	void run();
}

class Byd implements Car {
	@Override
	public void run() {
		System.out.println("比亚迪轿车！");
	}
}

class Audi implements Car {
	@Override
	public void run() {
		System.out.println("奥迪超跑！");
	}
}

优点：

工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
客户端无需知道所创建具体产品的类名，只需知道参数即可。
也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

缺点：

简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。
使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度
系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂，违背开闭原则
简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构

模式的结构与实现：

简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
具体产品（ConcreteProduct）：是简单工厂模式的创建目标。

三、工厂方法模式

是对简单工厂模式的进一步抽象化，工厂方法模式考虑的是一类产品的生产，如果同种类称为同等级，那么工厂方法模式只考虑生产同等级的产品。

package com.project.factory.factoryMethod;

/**
 * 工厂方法模式
 *  是对简单工厂模式的进一步抽象化
 *  可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。
 */
public interface FactoryMethod {
	Car createCar();
}

class AudiFactory implements FactoryMethod {
	@Override
	public Car createCar() {
		return new Audi();
	}
}

class BydFactory implements FactoryMethod {
	@Override
	public Car createCar() {
		return new Byd();
	}
}

//读取工厂配置
class ReadConfigure {
	public static Object getObject(Class<?> clazz){
		try {
			return clazz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
}

package com.project.factory.factoryMethod;

/**
 * 调用者
 */
public class Client {
	public static void main(String[] args) {
		FactoryMethod factory = (FactoryMethod)ReadConfigure.getObject(AudiFactory.class);
		Car audi = factory.createCar();
		audi.run();
	}
}

package com.project.factory.factoryMethod;

public interface Car {
	void run();
}

class Byd implements Car {
	@Override
	public void run() {
		System.out.println("比亚迪轿车！");
	}
}

class Audi implements Car {
	@Override
	public void run() {
		System.out.println("奥迪超跑！");
	}
}

优点：

用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点：

类的个数容易过多，增加复杂度
增加了系统的抽象性和理解难度
抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

模式的结构与实现

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 createProduct() 来创建产品。
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

四、抽象工厂模式

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品

package com.project.factory.abstractFactory;

/**
 * 发动机的同一个产品种类
 */
public interface Engine {
	void run();//运行状态
}

//高端发动机
class LuxuryEngine implements Engine{
	@Override
	public void run() {
		System.out.println("高端发动机，动力高爆发");
	}
}

//低端发动机
class LowEngine implements Engine {
	@Override
	public void run() {
		System.out.println("低端发动机，动力迟缓");
	}
}

package com.project.factory.abstractFactory;

/**
 * 轮胎的同一个产品种类
 */
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("低端轮胎，旋转微磨损");
	}
}

package com.project.factory.abstractFactory;

/**
 * 抽象工厂
 * 	是一种为访问类提供一个创建一组相关或相互依赖对象的接口
 * 	访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构
 */
public interface CarFactory {
	Engine createEngine();
	Tyre createTyre();
}

//高端汽车
class LuxuryCar implements CarFactory {

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

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

//低端汽车
class LowCar implements CarFactory {
	@Override
	public Engine createEngine() {
		return new LowEngine();
	}

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

//读取工厂配置
class ReadConfigure {
	public static Object getObject(Class<?> clazz){
		try {
			return clazz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
}

package com.project.factory.abstractFactory;

//调用者
public class Client {
	public static void main(String[] args) {
		//高端汽车配置
		CarFactory car = (CarFactory) ReadConfigure.getObject(LuxuryCar.class);
		Engine engine = car.createEngine();
		Tyre tyre = car.createTyre();
		engine.run();
		tyre.revolve();
	}
}

抽象工厂模式一般要满足以下条件