深入剖析Java工厂模式让你的代码更灵活

一、概述

1.1 什么是Java工厂模式

Java工厂模式是一种创建对象的设计模式，它提供了一种方法，通过该方法可以在不暴露对象创建逻辑的情况下，将对象的创建委托给子类或者其他对象。工厂模式可以隐藏对象的创建细节，提高了代码的可维护性、可扩展性和可重用性。

工厂模式主要有三种类型：简单工厂、工厂方法和抽象工厂。这三种类型的工厂模式各有优缺点，在不同的场景下有不同的应用。

二、简单工厂

2.1 什么是简单工厂

简单工厂模式是一种创建对象的工厂模式，它定义了一个工厂类，该工厂类根据传递的参数来决定创建哪种类型的对象。简单工厂模式适用于创建的对象比较少，且客户端只需要知道创建对象的参数。

2.2 示例代码

//抽象产品类
interface Product {
   void show();
}

//具体产品类A
class ConcreteProductA implements Product {
   public void show() {
       System.out.println("This is product A");
   }
}

//具体产品类B
class ConcreteProductB implements Product {
   public void show() {
       System.out.println("This is product B");
   }
}

//工厂类
class SimpleFactory {
   public static Product createProduct(String type) {
       Product product = null;
       if (type.equals("A")) {
           product = new ConcreteProductA();
       } else if (type.equals("B")) {
           product = new ConcreteProductB();
       }
       return product;
   }
}

//客户端
public class Client {
   public static void main(String[] args) {
       Product productA = SimpleFactory.createProduct("A");
       productA.show();

Product productB = SimpleFactory.createProduct("B");
       productB.show();
   }
}

2.3 优点和缺点

简单工厂模式的优点是可以隐藏产品的创建细节，客户端不需要知道产品的创建过程，只需要传递相应的参数即可得到想要的产品。简单工厂模式可以使客户端和产品类解耦，提高代码的可维护性和可扩展性。

简单工厂模式的缺点是当需要新增产品时，需要修改工厂类的代码，这违反了开闭原则。另外，简单工厂模式通常只有一个工厂类，如果产品种类较多，工厂类的代码会变得比较臃肿，不易于维护。

三、工厂方法

3.1 什么是工厂方法

工厂方法模式是一种创建对象的工厂模式，它定义了一个抽象工厂类，该抽象工厂类有一个工厂方法，该工厂方法返回一个产品对象。具体的产品对象由实现该抽象工厂类的子类来创建，这样每个具体工厂类只负责创建特定的产品对象，从而将客户端和具体产品解耦。

工厂方法模式通常包括四个角色：抽象产品类、具体产品类、抽象工厂类和具体工厂类。

3.2 示例代码

//抽象产品类
interface Product {
   void show();
}

//具体产品类A
class ConcreteProductA implements Product {
   public void show() {
       System.out.println("This is product A");
   }
}

//具体产品类B
class ConcreteProductB implements Product {
   public void show() {
       System.out.println("This is product B");
   }
}

//抽象工厂类
interface Factory {
   Product createProduct();
}

//具体工厂类A
class ConcreteFactoryA implements Factory {
   public Product createProduct() {
       return new ConcreteProductA();
   }
}

//具体工厂类B
class ConcreteFactoryB implements Factory {
   public Product createProduct() {
       return new ConcreteProductB();
   }
}

//客户端
public class Client {
   public static void main(String[] args) {
       Factory factoryA = new ConcreteFactoryA();
       Product productA = factoryA.createProduct();
       productA.show();

Factory factoryB = new ConcreteFactoryB();
       Product productB = factoryB.createProduct();
       productB.show();
   }
}

3.3 优点和缺点

工厂方法模式的优点是可以将客户端和具体产品解耦，每个具体工厂类只负责创建特定的产品对象，从而使系统更加灵活、可扩展和易于维护。工厂方法模式遵循了开闭原则，当需要新增产品时，只需要添加相应的具体产品类和具体工厂类即可，而不需要修改抽象工厂类和客户端代码。

工厂方法模式的缺点是如果需要创建的产品对象比较多，就需要创建相应的具体工厂类，这会导致系统中类的个数增加，增加了系统的复杂度。另外，由于每个具体工厂类只能创建特定的产品对象，如果需要创建的产品对象较为复杂，可能需要创建多个具体工厂类来创建这些产品对象，这会导致代码的重复和冗余。

四、抽象工厂

4.1 什么是抽象工厂

抽象工厂模式是一种创建对象的工厂模式，它可以创建一组相关或相互依赖的对象，而无需指定它们的具体类。在抽象工厂模式中，有一个抽象工厂类，它定义了一些方法用于创建一组产品对象，每个方法对应一种产品。具体工厂类实现了这些方法，用于创建具体的产品对象。

抽象工厂模式通常包括四个角色：抽象产品类、具体产品类、抽象工厂类和具体工厂类。

4.2 示例代码

//抽象产品类1
interface Product1 {
   void show();
}

//具体产品类1A
class ConcreteProduct1A implements Product1 {
   public void show() {
       System.out.println("This is product 1A");
   }
}

//具体产品类1B
class ConcreteProduct1B implements Product1 {
   public void show() {
       System.out.println("This is product 1B");
   }
}

//抽象产品类2
interface Product2 {
   void show();
}

//具体产品类2A
class ConcreteProduct2A implements Product2 {
   public void show() {
       System.out.println("This is product 2A");
   }
}

//具体产品类2B
class ConcreteProduct2B implements Product2 {
   public void show() {
       System.out.println("This is product 2B");
   }
}

//抽象工厂类
interface Factory {
   Product1 createProduct1();
   Product2 createProduct2();
}

//具体工厂类A
class ConcreteFactoryA implements Factory {
   public Product1 createProduct1() {
       return new ConcreteProduct1A();
   }

public Product2 createProduct2() {
       return new ConcreteProduct2A();
   }
}

//具体工厂类B
class ConcreteFactoryB implements Factory {
   public Product1 createProduct1() {
       return new ConcreteProduct1B();
   }

public Product2 createProduct2() {
       return new ConcreteProduct2B();
   }
}

//客户端
public class Client {
   public static void main(String[] args) {
       Factory factoryA = new ConcreteFactoryA();
       Product1 product1A = factoryA.createProduct1();
       Product2 product2A = factoryA.createProduct2();
       product1A.show();
       product2A.show();

Factory factoryB = new ConcreteFactoryB();
       Product1 product1B = factoryB.createProduct1();
       Product2 product2B = factoryB.createProduct2();
       product1B.show();
       product2B.show();
   }
}

4.3 优点和缺点

抽象工厂模式的优点是它可以创建一组相关或相互依赖的对象，而无需指定它们的具体类，从而使系统更加灵活、可扩展和易于维护。抽象工厂模式遵循了开闭原则，当需要新增产品时，只需要添加相应的抽象产品类、具体产品类和具体工厂类即可，不需要修改已有代码，这样可以减少系统的维护成本和风险。

抽象工厂模式还可以实现产品族的概念，即一组位于不同产品等级结构中、功能相关联的产品组成的家族，例如不同品牌的汽车，它们都有轮胎、发动机、座椅等共同特点，但具体实现各不相同。使用抽象工厂模式可以将不同品牌的汽车组成一个产品族，实现同一功能的产品可以进行互换。

抽象工厂模式的缺点是抽象工厂类需要定义一组方法用于创建产品对象，增加新产品对象时，需要修改抽象工厂类及其所有的具体工厂类，这将导致系统的维护复杂度增加。抽象工厂模式将一组相关的产品对象集合在一起创建，当产品族中的产品等级结构发生变化时，将会影响到整个系统，需要重构整个工厂。

4.4 使用工厂模式的例子

一个常见的使用抽象工厂模式的例子是操作系统的界面风格，例如Windows系统有Aero和Classic两种界面风格，而Mac OS有Aqua和Metal两种界面风格。每种界面风格都有自己的按钮、文本框、滚动条等组件，因此可以将每种界面风格看作一个产品族，而每个组件则看作产品等级结构中的一个产品。使用抽象工厂模式可以将不同界面风格的组件组成一个产品族，实现同一功能的组件可以进行互换。例如，用户可以选择使用Aero风格的按钮和Metal风格的文本框，而系统仍然能够正常工作。

另一个使用抽象工厂模式的例子是游戏中的角色创建，例如一个RPG游戏中有魔法师、战士和弓箭手三种角色，而每种角色又可以选择不同的装备，例如不同的武器、防具和饰品。可以将每种角色看作一个产品族，而每个装备则看作产品等级结构中的一个产品。使用抽象工厂模式可以将不同角色的装备组成一个产品族，实现同一功能的装备可以进行互换。例如，魔法师可以选择使用火属性的魔杖和光属性的魔法书，而战士可以选择使用铁剑和钢盾，而系统仍然能够正常工作。

来源：https://juejin.cn/post/7229891190899785765