1.简介

工厂模式是一种创建型设计模式，通过提供一个接口或抽象类来创建对象，而不是直接实例化对象。工厂模式的主要思想是将对象的创建与使用分离，使得创建对象的过程更加灵活和可扩展。

工厂模式主要包括以下角色：

• 抽象工厂（Abstract Factory）：定义了一个创建产品对象的接口，可以包含多个方法来创建不同类型的产品。
• 具体工厂（Concrete Factory）：实现抽象工厂接口，负责实例化具体的产品对象。
• 抽象产品（Abstract Product）：定义了产品的接口或抽象类，是工厂方法和抽象工厂模式中的基础。
• 具体产品（Concrete Product）：实现抽象产品接口，具体定义产品的功能和行为。

2.简单工厂模式

简单工厂模式（Simple Factory Pattern）：由一个工厂类根据传入的参数决定创建哪一种产品类的实例。它通常包含一个静态方法，这个方法根据参数创建相应的对象。

定义一个简单的例子：电脑有很多品牌，如惠普电脑、联想电脑，如果需要创建这两个对象时，主动new出来，使用了简单工厂模式后，可以把创建的动作交给工厂类，只需要指定参数即可获取对应的对象。

实现方法

1. 编写产品类

首先创建一个Computer接口，不同的产品实现这一接口

// 定义抽象产品接口 public interface Computer {     void compute(); }  // 定义具体产品，实现该接口 public class HPComputer implements Computer{     @Override     public void compute() {         System.out.println("我是惠普电脑");     } }  public class LenovoComputer implements Computer{     @Override     public void compute() {         System.out.println("我是联想电脑");     } } 

2. 编写工厂类

简单工厂模式不存在抽象工厂，只需编写一个工厂类即可。

// 根据传入的参数创建对应产品 public class SimpleFactory {     public static Computer createProduct(String type) {         if (type.equals("HP")) {             return new HPComputer();         } else if (type.equals("Lenovo")) {             return new LenovoComputer();         } else {             throw new IllegalArgumentException("该类型无法被生产");         }     } } 

3. 测试类使用工厂创建产品

public class Main {     public static void main(String[] args) {         // 创建HP电脑         Computer hp = SimpleFactory.createProduct("HP");         // 创建Lenovo电脑         Computer lenovo = SimpleFactory.createProduct("Lenovo");         hp.compute();         lenovo.compute();     } } 

输出结果如下：

小结

简单工厂模式虽然实现比较简单，但是工厂类的职责过重，增加新的产品类型需要修改工厂类，违背了开闭原则。

开闭原则： 软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。

对扩展开放（Open for extension）：软件实体应该允许在不改变其现有代码的情况下，通过增加新功能来对其进行扩展。也就是说，当软件的需求发生变化时，我们应该能够通过添加新代码来满足这些需求，而不需要修改已有的代码。

对修改关闭（Closed for modification）：一旦软件实体被开发完成并投入使用，其源代码就不应该再被修改。这可以防止对现有功能的破坏，减少引入新的错误的风险，并使软件更加稳定和可维护。

3.工厂方法模式

工厂方法模式（Factory Method Pattern）：定义一个创建对象的接口，但由子类决定实例化哪个类。工厂方法将对象的创建推迟到子类。

实现方法

1. 编写产品类

// 定义抽象产品接口 public interface Computer {     void compute(); }  // 定义具体产品，实现该接口 public class HPComputer implements Computer{     @Override     public void compute() {         System.out.println("我是惠普电脑");     } }  public class LenovoComputer implements Computer{     @Override     public void compute() {         System.out.println("我是联想电脑");     } } 

2. 编写工厂类

需要定义一个抽象工厂，然后由具体工厂创建对应的产品。

// 定义抽象工厂 public interface ComputerFactory {     Computer createComputer(); }  // 定义HP工厂 public class HPComputerFactory implements ComputerFactory{     @Override     public Computer createComputer() {         return new HPComputer();     } }  // 定义Lenovo工厂 public class LenovoComputerFactory implements ComputerFactory{     @Override     public Computer createComputer() {         return new LenovoComputer();     } } 

3. 测试类使用不同的具体工厂创建产品

public class Main {     public static void main(String[] args) {         // 创建HP电脑         HPComputerFactory hpFactory = new HPComputerFactory();         Computer hpComputer = hpFactory.createComputer();         hpComputer.compute();          // 创建Lenovo电脑         LenovoComputerFactory lenovoFactory = new LenovoComputerFactory();         Computer lenovoComputer = lenovoFactory.createComputer();         lenovoComputer.compute();     } } 

输出结果如下：

小结

优点：

• 遵循开闭原则，新增产品时不需要修改现有系统代码，只需要添加新的具体工厂和具体产品类。
• 更符合单一职责原则，每个具体工厂类只负责创建一种产品。

缺点：

• 增加了系统复杂度，需要增加额外的类和接口。

4.抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。适用于产品族的场景，即多个产品等级结构中相关的产品需要一起创建和使用。

产品等级结构： 指产品的继承结构，例如一个电脑抽象类，它有HP电脑、Lenovo电脑等实现类，那么这个电脑抽象类和他的实现类就构成了一个产品等级结构。

产品族： 产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如，Lenovo除了生产电脑还可以生产打印机等其他产品。

实现方法

1. 编写产品类

// 定义电脑抽象产品接口 public interface Computer {     void compute(); }  // 定义电脑具体产品，实现该接口 public class HPComputer implements Computer{     @Override     public void compute() {         System.out.println("我是惠普电脑");     } }  public class LenovoComputer implements Computer{     @Override     public void compute() {         System.out.println("我是联想电脑");     } }  // 定义打印机抽象产品接口 public interface Printer {     void print(); }  // 定义打印机具体产品，实现该接口 public class HPPrinter implements Printer {     @Override     public void print() {         System.out.println("我是惠普打印机");     } }  public class LenovoPrinter implements Printer{     @Override     public void print() {         System.out.println("我是联想打印机");     } } 

2. 编写工厂类

定义一个抽象工厂，该工厂可以创建多个产品。

// 定义抽象工厂 public interface AbstractFactory {     Computer createComputer();      Printer createPrinter(); }  // 定义HP工厂 public class HPFactory implements AbstractFactory{     @Override     public Computer createComputer() {         return new HPComputer();     }      @Override     public Printer createPrinter() {         return new HPPrinter();     } }  // 定义Lenovo工厂 public class LenovoFactory implements AbstractFactory {     @Override     public Computer createComputer() {         return new LenovoComputer();     }      @Override     public Printer createPrinter() {         return new LenovoPrinter();     } } 

3. 测试类使用不同的具体工厂创建产品

public class Main {     public static void main(String[] args) {         HPFactory hpFactory = new HPFactory();         Computer hpComputer = hpFactory.createComputer();         Printer hpPrinter = hpFactory.createPrinter();          hpComputer.compute();         hpPrinter.print();          System.out.println("===============");          LenovoFactory lenovoFactory = new LenovoFactory();         Computer lenovoComputer = lenovoFactory.createComputer();         Printer lenovoPrinter = lenovoFactory.createPrinter();         lenovoComputer.compute();         lenovoPrinter.print();     } } 

输出结果如下：

小结

优点：

• 符合开闭原则，新增产品族时无需修改现有系统代码。
• 符合单一职责原则，每个具体工厂类只负责创建一类产品族。
• 保证产品族的一致性，同一个工厂创建的产品是属于同一个产品族的。

缺点：

• 增加了系统的复杂度。修改产品族时，需要修改所有具体工厂类，扩展性稍差。

5.总结

适用场景：

• 简单工厂模式：适用于产品种类较少，客户端只需根据参数获得具体产品的简单场景。适合产品种类不经常变化的场合。

• 工厂方法模式：适用于产品种类较多，每个产品有相应的具体工厂类。适合需要扩展新产品，且不希望修改现有代码的场合。

• 抽象工厂模式：适用于产品族较多，每个产品族中包含多个相关产品。适合创建一系列相关或相互依赖的产品，且希望统一管理产品族的场合。