文章目录

概述
工厂模式的优点包括
工厂模式有几种主要的变体
- 看一个具体需求
- 使用传统的方式来完成
- - 传统的方式的优缺点
- 简单工厂模式基本介绍
- 使用简单工厂模式
- - 简单工厂模式的优缺点
  - - 优点：
    - 缺点：
- 工厂方法模式
- - 看一个新的需求
  - 思路 1
  - 思路 2
  - 工厂方法模式介绍
  - 工厂方法模式应用案例
- 抽象工厂模式
- - 基本介绍
  - 抽象工厂模式应用实例
工厂模式小结

概述

工厂模式是一种创建型设计模式，它提供了一种创建对象的接口，但将对象的实例化过程推迟到子类或具体的实现类中。工厂模式的主要目的是将对象的创建与使用分离，从而降低代码的耦合性，增强代码的可维护性和可扩展性。

工厂模式的优点包括

对象的封装：将对象的创建细节封装在具体的工厂类中，使客户端不需要了解具体的创建过程，只需通过工厂来获取所需的对象。
代码重用：由于对象的创建过程在工厂类中集中管理，可以避免在多个地方重复创建相同类型的对象。
易于扩展：当需要添加新的产品或变体时，只需创建新的具体工厂类和产品类，而不需要修改现有代码。
降低耦合：客户端只与抽象工厂类进行交互，不直接依赖于具体产品类，从而降低了代码的耦合性。

工厂模式有几种主要的变体

简单工厂模式：不是正式的设计模式，更像是一种编程习惯，将对象的创建封装在一个静态方法中。
工厂方法模式：定义了一个用于创建对象的抽象方法，由具体的子类工厂来实现创建逻辑。
抽象工厂模式：提供一个创建一组相关或相互依赖对象的接口，每个具体工厂类负责创建一组具体产品。

看一个具体需求

看一个披萨的项目：要便于披萨种类的扩展，要便于维护

披萨的种类很多(比如 GreekPizz、CheesePizz 等)
披萨的制作有 prepare，bake, cut, box
完成披萨店订购功能。

使用传统的方式来完成

思路分析(类图)

在这里插入图片描述

新建一个tradition.pizzastore包

编写 OrderPizza.java 去订购需要的各种 Pizza

代码展示：

package com.lh.factory.tradition.pizzastore.order;import java.io.BufferedReader;import java.io.IOException;
import java.io.InputStreamReader;import com.lh.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.lh.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.PepperPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.Pizza;public class OrderPizza {// 构造器public OrderPizza() {//比萨的Pizza pizza = null;String orderType; // 订购披萨的类型do {orderType = getType();if (orderType.equals("greek")) {pizza = new GreekPizza();pizza.setName("胡椒披萨");} else if (orderType.equals("cheese")) {pizza = new CheesePizza();pizza.setName("奶酪披萨");// 新写的代码} else if (orderType.equals("pepper")) {pizza = new PepperPizza();pizza.setName("希腊披萨");} else {System.out.println("不存在！");break;}// 输出 Pizza 制作过程pizza.prepare();pizza.bake();pizza.cut();pizza.box();} while (true);}// 写一个方法，可以获取客户希望订购的披萨种类private String getType() {try {BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));System.out.println("input pizza 种类:");String str = strin.readLine();return str;} catch (IOException e) {e.printStackTrace();return "";}}
}

Pizza类，作为抽象类，功能参考类图

package com.lh.factory.tradition.pizzastore.pizza;//将Pizza 类做成抽象类
public abstract class Pizza {//名字protected String name;public void setName(String name) {this.name = name;}//原材料（不同的披萨，不一样的原材料）,做成抽象方法，自定义实现public abstract void prepare();//烘烤public void bake() {System.out.println(name + "baking");}//切割public void cut() {System.out.println(name + "cuting");}//打包public void box() {System.out.println(name + "boxing");}
}

三个子类继承Pizza类

package com.lh.factory.tradition.pizzastore.pizza;public class CheesePizza extends Pizza{@Overridepublic void prepare() {System.out.println("给胡椒披萨，制作原材料");}
}package com.lh.factory.tradition.pizzastore.pizza;public class GreekPizza extends Pizza{@Overridepublic void prepare() {System.out.println("奶酪准备原材料");}
}package com.lh.factory.tradition.pizzastore.pizza;public class PepperPizza extends Pizza {@Overridepublic void prepare() {System.out.println(" 给希腊披萨 准备原材料 ");}
}

客户端：

package com.lh.factory.tradition.pizzastore.order;//相当于一个客户端，发出订购
public class PizzaStore {public static void main(String[] args) {//传统方法new OrderPizza();}
}

传统的方式的优缺点

优点是比较好理解，简单易操作。
缺点是违反了设计模式的 ocp 原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
比如我们这时要新增加一个 Pizza 的种类(Pepper 披萨)，我们需要做如下修改.如果我们增加一个 Pizza 类，只要是订购 Pizza 的代码都需要修改.

在orderType中新增的代码如下图：参考上方的orderType代码，代码块中有如下功能：

在这里插入图片描述

改进的思路分析
分析：修改代码可以接受，但是如果我们在其它的地方也有创建 Pizza 的代码，就意味着，也需要修改，而创建 Pizza的代码，往往有多处。
思路：把创建 Pizza 对象封装到一个类中，这样我们有新的 Pizza 种类时，只需要修改该类就可，其它有创建到 Pizza对象的代码就不需要修改了.-> 简单工厂模式

简单工厂模式基本介绍

简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式

使用简单工厂模式

简单工厂模式的设计方案: 定义一个可以实例化 Pizaa 对象的类，封装创建对象的代码。

uml类图如下：

在这里插入图片描述

看代码示例

简单工厂模式的pizza包下的类，均不做改动，参考如上代码即可（需要细心观看哦）

这里只展示修改后的OrderPizza和客户端了，以及新的简单工厂模式

package com.lh.factory.simplefactory.pizzastore.order;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;import com.lh.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.lh.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.PepperPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.Pizza;public class OrderPizza {SimlpleFactory simlpleFactory;Pizza pizza = null;//构造器public OrderPizza(SimlpleFactory simlpleFactory) {//接受简单工厂setFactory(simlpleFactory);}public void setFactory(SimlpleFactory simlpleFactory) {String orderType = ""; // 用户输入的this.simlpleFactory = simlpleFactory; // 设置简单工厂对象do {orderType = getType();pizza = this.simlpleFactory.createPizza(orderType);//输出pizzaif (pizza != null) { //订购成功pizza.prepare();pizza.bake();pizza.cut();pizza.box();}else {System.out.println("订购披萨失败！");break;}} while (true);}// 写一个方法，可以获取客户希望订购的披萨种类private String getType() {try {BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));System.out.println("input pizza 种类:");String str = strin.readLine();return str;} catch (IOException e) {e.printStackTrace();return "";}}
}

好处：只需要修改工厂类的代码即可，不需要在业务场景下进行修改

下面的工厂类写了两个相同的方法，没别的意思，就是告诉大家，简单工厂模式，也叫静态工厂模式

package com.lh.factory.simplefactory.pizzastore.order;import com.lh.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.lh.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.PepperPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.Pizza;//简单工厂类
public class SimlpleFactory {//返回对应的Pizza public Pizza createPizza(String orderType) {Pizza pizza = null;if (orderType.equals("greek")) {pizza = new GreekPizza();pizza.setName("希腊披萨");} else if (orderType.equals("cheese")) {pizza = new CheesePizza();pizza.setName("奶酪披萨");// 新写的代码} else if (orderType.equals("pepper")) {pizza = new PepperPizza();pizza.setName("胡椒披萨");}return pizza;}//简单工厂模式也叫静态工厂模式public static Pizza createPizza2(String orderType) {Pizza pizza = null;System.out.println("使用简单工厂模式2");if (orderType.equals("greek")) {pizza = new GreekPizza();pizza.setName("希腊披萨");} else if (orderType.equals("cheese")) {pizza = new CheesePizza();pizza.setName("奶酪披萨");// 新写的代码} else if (orderType.equals("pepper")) {pizza = new PepperPizza();pizza.setName("胡椒披萨");}return pizza;}
}

静态工厂模式的OrderPizza类（静态工厂模式看起来更加方便，减少了一部分代码）

package com.lh.factory.simplefactory.pizzastore.order;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;import com.lh.factory.simplefactory.pizzastore.pizza.Pizza;public class OrderPizza2 {Pizza pizza = null;String orderType = "";// 构造器public OrderPizza2() {// 接受简单工厂do {orderType = getType();pizza = SimlpleFactory.createPizza2(orderType);// 输出pizzaif (pizza != null) { // 订购成功pizza.prepare();pizza.bake();pizza.cut();pizza.box();} else {System.out.println("订购披萨失败！");break;}} while (true);}// 写一个方法，可以获取客户希望订购的披萨种类private String getType() {try {BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));System.out.println("input pizza 种类:");String str = strin.readLine();return str;} catch (IOException e) {e.printStackTrace();return "";}}}

简单工厂模式的优缺点

优点：

封装对象的创建逻辑：通过将对象的创建逻辑封装在静态工厂方法中，客户端代码无需了解对象的具体创建过程，降低了对象创建的复杂度。

代码组织：简单工厂模式可以集中管理对象的创建逻辑，使代码更加清晰、简洁，并且易于维护。

灵活性：如果需要更改或替换产品，只需修改工厂方法的实现，不会影响客户端代码，从而实现了产品变化对客户端的透明性。

缺点：

不符合开闭原则：当需要添加新的产品类型时，可能需要修改工厂方法的代码，这违背了开闭原则（对扩展开放，对修改关闭）。

工厂类职责过重：工厂类通常负责创建多种不同类型的对象，导致工厂类职责变得较重，随着产品种类的增加，工厂类会变得越来越复杂。

不支持多个工厂类：在简单工厂模式中，只有一个工厂类负责所有对象的创建，这可能会导致工厂类变得庞大，难以管理。

不够灵活：由于所有对象的创建逻辑集中在一个工厂类中，如果不同的产品有复杂的创建过程，可能无法很好地适应。

工厂方法模式

看一个新的需求

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪 pizza、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza。

思路 1

使用简单工厂模式，创建不同的简单工厂类，比如 BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等。从当前这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是特别好（考验大家抽象能力）

思路 2

使用工厂方法模式

工厂方法模式介绍

工厂方法模式设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。
工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

工厂方法模式应用案例

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪 pizza、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza
思路分析图解

在这里插入图片描述

Pizza类与它的子类

package com.lh.factory.factorymethod.pizzastore.pizza;//将Pizza 类做成抽象类
public abstract class Pizza {//名字protected String name;//原材料（不同的披萨，不一样的原材料）,做成抽象方法，自定义实现public abstract void prepare();//烘烤public void bake() {System.out.println(name + "baking");}//切割public void cut() {System.out.println(name + "cuting");}//打包public void box() {System.out.println(name + "boxing");}public void setName(String name) {this.name = name;}
}public class LDPepperPizza extends Pizza{@Overridepublic void prepare() {setName("伦敦胡椒披萨...");System.out.println("伦敦胡椒pizza,准备原材料");}
}public class LDCheesePizza extends Pizza{@Overridepublic void prepare() {setName("伦敦奶酪披萨...");System.out.println("伦敦奶酪pizza,准备原材料");}}public class BJPepperPizza extends Pizza{@Overridepublic void prepare() {setName("北京胡椒披萨...");System.out.println("北京pizza,准备原材料");}
}public class BJCheesePizza extends Pizza{@Overridepublic void prepare() {setName("北京奶酪披萨...");System.out.println("北京pizza,准备原材料");}
}

工厂抽象类，定义一个工厂的抽象方法，让其子类自己实现，这样可以不需要动工厂自身的代码，如果想添加新的品种，可以新创建一个，继承工厂抽象类重写其方法就可以

package com.lh.factory.factorymethod.pizzastore.order;import java.io.BufferedReader;import java.io.IOException;
import java.io.InputStreamReader;import com.lh.factory.factorymethod.pizzastore.pizza.Pizza;public abstract class OrderPizza {// 构造器public OrderPizza() {Pizza pizza = null;String orderType; // 订购披萨的类型do {orderType = getType();//抽象方法，由工厂子类完成pizza = createPizza(orderType);// 输出 Pizza 制作过程pizza.prepare();pizza.bake();pizza.cut();pizza.box();} while (true);}// 定义一个抽象方法，createPizza,让各个工厂子类自己实现abstract Pizza createPizza(String orderType);// 写一个方法，可以获取客户希望订购的披萨种类private String getType() {try {BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));System.out.println("input pizza 种类:");String str = strin.readLine();return str;} catch (IOException e) {e.printStackTrace();return "";}}
}

两个分工厂分别继承OrderPizza 类，分别实现各自的功能

package com.lh.factory.factorymethod.pizzastore.order;import com.lh.factory.factorymethod.pizzastore.pizza.LDCheesePizza;
import com.lh.factory.factorymethod.pizzastore.pizza.LDPepperPizza;
import com.lh.factory.factorymethod.pizzastore.pizza.Pizza;public class LDOrderPizza extends OrderPizza{@OverridePizza createPizza(String orderType) {Pizza pizza = null;if (orderType.equals("cheese")) {pizza = new LDCheesePizza();}else if (orderType.equals("pepper")) {pizza = new LDPepperPizza();}	return pizza;}
}package com.lh.factory.factorymethod.pizzastore.order;import com.lh.factory.factorymethod.pizzastore.pizza.BJCheesePizza;
import com.lh.factory.factorymethod.pizzastore.pizza.BJPepperPizza;
import com.lh.factory.factorymethod.pizzastore.pizza.Pizza;public class BJOrderPizza extends OrderPizza{@OverridePizza createPizza(String orderType) {Pizza pizza = null;if (orderType.equals("cheese")) {pizza = new BJCheesePizza();}else if (orderType.equals("pepper")) {pizza = new BJPepperPizza();}return pizza;}
}

客户端：

package com.lh.factory.factorymethod.pizzastore.order;public class PizzaStore {public static void main(String[] args) {//创建北京口味的各种Pizzanew BJOrderPizza();//创建伦敦口味的各种Pizzanew LDOrderPizza();}
}

抽象工厂模式

基本介绍

抽象工厂模式：定义了一个 interface 用于创建相关或有依赖关系的对象簇，而无需指明具体的类
抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
将工厂抽象成两层，AbsFactory(抽象工厂) 和具体实现的工厂子类。程序员可以根据创建对象类型使用对应
的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。
类图

在这里插入图片描述

抽象工厂模式应用实例

Pizza类与它的子类，与抽象工厂方法模式中的Pizza类和它的子类代码一样，这里不做复制粘贴，耐心可观看

工厂接口：

package com.lh.factory.absfactory.pizzastore.order;import com.lh.factory.absfactory.pizzastore.pizza.Pizza;//一个抽象工厂模式的抽象层（接口）
public interface AbsFactory {//让下面的工厂子类具体实现Pizza createFactory(String orderType);}

OrderType工厂类，将业务需求写好之后，不动此代码。直接调用即可

package com.lh.factory.absfactory.pizzastore.order;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;import com.lh.factory.absfactory.pizzastore.pizza.Pizza;public class OrderPizza {// 是聚合AbsFactory factory;//构造器public OrderPizza(AbsFactory factory) {setFactory(factory);}//指向子类实例化private void setFactory(AbsFactory factory) {Pizza pizza = null;String orderType; // 用户输入披萨this.factory = factory;do {orderType = getType();//可能是北京，或者是伦敦pizza = factory.createFactory(orderType);if (pizza != null) { //订购 okpizza.prepare();pizza.bake();pizza.cut();pizza.box();}else {System.out.println("订购失败！");break;}} while (true);}// 写一个方法，可以获取客户希望订购的披萨种类private String getType() {try {BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));System.out.println("input pizza 种类:");String str = strin.readLine();return str;} catch (IOException e) {e.printStackTrace();return "";}}
}

两个工厂各自实现AbsFactory，各自实现自己的功能

package com.lh.factory.absfactory.pizzastore.order;import com.lh.factory.absfactory.pizzastore.pizza.BJCheesePizza;
import com.lh.factory.absfactory.pizzastore.pizza.BJPepperPizza;
import com.lh.factory.absfactory.pizzastore.pizza.Pizza;//北京工厂子类
public class BJFactory implements AbsFactory{	@Overridepublic Pizza createFactory(String orderType) {// TODO Auto-generated method stubSystem.out.println("使用的是抽象工厂模式");Pizza pizza = null;if (orderType.equals("cheese")) {pizza = new BJCheesePizza();}else if (orderType.equals("pepper")) {pizza = new BJPepperPizza();}return pizza;}
}package com.lh.factory.absfactory.pizzastore.order;import com.lh.factory.absfactory.pizzastore.pizza.LDCheesePizza;
import com.lh.factory.absfactory.pizzastore.pizza.LDPepperPizza;
import com.lh.factory.absfactory.pizzastore.pizza.Pizza;//伦敦工厂子类
public class LDFactory implements AbsFactory{@Overridepublic Pizza createFactory(String orderType) {// TODO Auto-generated method stubSystem.out.println("使用的是抽象工厂模式");Pizza pizza = null;if (orderType.equals("cheese")) {pizza = new LDCheesePizza();}else if (orderType.equals("pepper")) {pizza = new LDPepperPizza();}return pizza;}
}

工厂模式小结

工厂模式的意义
将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)
设计模式的依赖抽象原则
- 创建对象实例时，不要直接 new 类, 而是把这个 new 类的动作放在一个工厂的方法中，并返回。有的书上说，
  变量不要直接持有具体类的引用。
- 不要让类继承具体类，而是继承抽象类或者是实现 interface(接口)
- 不要覆盖基类中已经实现的方法。