深入剖析Java工厂模式，让你的代码更灵活、可扩展、易维护！

「爱情、让人受尽委屈。」 2023-09-27 19:49 46阅读 0赞

# 一、概述 #

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