【软考】设计模式总览、简单工厂模式、工厂方法模式

# 设计模式
设计模式：是为了 复用 成功的设计和体系结构
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/16/sea3cb.webp)

三大类：创建型模式、结构型模式、行为型模式

![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/16/selr1y.webp)

---
# 创建型设计模式
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/16/sr2enu.webp)
一个类创建模式，使用 继承 改变被实例化的类
一个对象创建模式，将 实例化 委托给 另一个对象

---
# 简单工厂模式
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/16/ssroxo.webp)

定义一个工厂类，他可以根据参数的不同 返回不同类的实例，被创建的实例通常都具有共同的父类

在简单工厂模式中，用于被创建实例的方法：静态方法 static
因此 简单工厂模式 又被称为：静态工厂方法 Static Factory Method

需要什么产品就传入产品对应的参数（需要产品 A，就传入产品 A 的参数），就会把产品 A 返回给你
就可以获取所需要的产品对象，不需要知道其实现过程

角色：
工厂（核心）：负责实现创建所有产品的内部逻辑
工厂类可以直接被外界调用，创建所有对象：
类名.静态方法名

抽象产品：工厂类所创建的所有对象的父类
封装了产品对象的公共方法，所有的具体产品都是其子类对象

具体产品：简单工厂模式的 **创建目标**
所有被创建的对象都是某个具体类的实例，要实现抽象产品中声明的抽象方法

```java
public class SimpleFactory{
	//直接调用即可
	public static void main(String[] args){
		//是静态的方法，所以不需要去 new 一个新的东西
		Product productA = Factroy.createProduct(type "A");// 传一个参数 A,把产品实例化成一个 产品 A，可以用一个具体的产品来接收
		// 可以调用一个方法
		productA.info();
		
		Product productB = Factory.creatProduct(type "B");
		productB.info();
		
	}
}

class Factory{
	public static Product createProduct(String type){
	// 上面返回产品a或产品b都不对，所以要返回产品 Product
	// createProduct 方法名
		Product product = null;
		
		//根据产品参数类型来判断要返回什么类型的产品
		switch (type){
			case "A":
				product = new ProductA();
				break;
			case "B":
				product = new ProductB();
				break;
			default:
				System.out.println("没有 "+ type = " 类型的产品")
				break;
		}
		return product;
	}
}

// 考虑把抽象的产品写进去，还有抽象的方法
abstract class Product{
	public abstract void info(); 
}

class ProductA extends Product{
	@Override// 实现方法
	public void info(){
		System.out.println("产品的信息：A");
	}
}

class ProductB extends Product{
	@Override// 实现方法
	public void info(){
		System.out.println("产品的信息：B");
	}
}

```

运行结果：
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/17/go799e.webp)

---
# 工厂方法模式 Factory Method
意图：
**定义一个用于创建对象的接口，让子类决定实例化哪一个类**

Factroy Method 使一个类的实例化延迟到其子类

把简单工厂中的工厂抽象为接口，接口只负责定义
接口不去具体实现这个方法，要由实现这个方法的子类去实现这个接口
子类决定要实例化哪一个类。也就是说 工厂A 实例化产品 A，工厂 B 实例化产品 B
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/17/h1eopp.webp)
```java
public class FactoryMethod{
	public static void main(String[] args){
		// 由子类决定创建哪一个产品
		Factory factoryA = new FactoryA(); //创建一个工厂A
		// 有点类似多态，父 对象名 = new 子类();
		
		//用刚创建的对象 factorA 来调用他的方法
		Product productA = factoryA.creatProduct();
		productA.info();
		
		
		Factory factoryB = new FactoryB();
		
		Product productB = factoryB.creatProduct();
		productB.info();
	}
}

// 简单工厂：class Factory
// 把工厂改成接口
interface Factory{
	//之前简单工厂中的方法体都可以不要了
	public Product createProduct();
}

//需要两个具体的工厂子类来实现接口
class FactoryA implements Factory{
	//实现这个接口就要实现这个接口中的方法，创建一个产品，然后返回一个产品的这个方法，实现父类工厂中的方法：创建产品
	@Override
	public Product createProduct(){
		return new ProductA();
	}
}

class FactoryB implements Factory{
	@Override
	public Product createProduct(){
		return new ProductB();
	}
}

// 简单工厂：abstract class Product
// 把简单工厂模式中的抽象类改成接口
interface Product{
	//简单工厂：public abstract void info();
	//接口里的方法都是抽象方法
	public void info();
}
// 简单工厂：class ProductA extends Product
// 接口对应的是实现，把继承改成实现
class ProductA implements Product{//子类实现这个接口
	//实现这个接口中的所有方法
	@Override
	public void info(){
		System.out.println("产品的信息：A");
	}
}

class ProductB implements Product{
	@Override
	System.out.println("产品的信息：B");
}

```

---
# 工厂方法模式的适用性：
- 当一个类不知道它所必须创建的对象的类的时候
- 当一个类希望由它的子类来指定它所创建的对象的时候
- 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将那个一个帮助子类是代理者这一信息局部化的时候