Java工厂设计模式详解(3种工厂设计模式)

Java工厂设计模式详解(3种工厂设计模式)-mikechen

Java工厂设计模式是Java设计模式最常用的一种，下面我就重点来详解Java工厂设计模式@mikechen

Java工厂设计模式

Java工厂设计模式是一种创建型设计模式，它提供了一种方法来创建对象，而不需要直接实例化这些对象。

在Java工厂设计模式可以实现不同类型对象的创建，例如不同的类、接口、数组、枚举等。

通常情况下，Java工厂设计模式被分为三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式

简单工厂模式也叫静态工厂方法模式，它是最基本的工厂模式。

简单工厂模式通过一个工厂类来创建不同的对象，客户端只需要知道所需对象的名称或类型即可，而无需知道创建对象的具体过程。

如下图所示：

Java工厂设计模式详解(3种工厂设计模式)-mikechen

简单工厂模式主要包含三类角色：

产品（Product）：需要创建的对象的通用接口，该接口应该是一个抽象类或者接口。
具体产品（Concrete Product）：实现产品接口的具体类，是简单工厂模式创建的对象。
工厂（Factory）：负责创建具体产品的工厂类，包含创建对象的逻辑，常常是一个静态方法。

简单工厂模式优点：

简单工厂模式可以很好地遵循单一职责原则和开闭原则，因为创建对象的逻辑被封装在一个独立的工厂类中。
通过工厂类创建对象，可以使客户端代码更简洁，更易于维护和扩展。

简单工厂模式缺点：

工厂类负责创建所有的产品对象，如果产品种类过多，会导致工厂类的代码变得非常复杂，不易于维护。
工厂类的职责过重，增加新的产品需要修改工厂类的代码，违反了开闭原则。

简单工厂模式示例如下：

首先，我们定义一个抽象产品类 Product：

public abstract class Product {
    public abstract void use();
}

然后，我们定义两个具体产品类 ProductA 和 ProductB，它们都继承自 Product：

public class ProductA extends Product {
    public void use() {
        System.out.println("ProductA is being used");
    }
}

public class ProductB extends Product {
    public void use() {
        System.out.println("ProductB is being used");
    }
}

接下来，我们定义一个工厂类 SimpleFactory，用于创建产品对象：

public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        } else {
            throw new IllegalArgumentException("Invalid product type: " + type);
        }
    }
}

最后，我们可以使用工厂类来创建具体产品对象：

Product productA = SimpleFactory.createProduct("A");
Product productB = SimpleFactory.createProduct("B");

productA.use();  // Output: ProductA is being used
productB.use();  // Output: ProductB is being used

工厂方法模式

工厂方法模式（Factory Method Pattern）也是一种创建型设计模式，它解决了简单工厂模式中工厂类职责过重的问题。

工厂方法模式包含如下4类角色：
Java工厂设计模式详解(3种工厂设计模式)-mikechen

抽象产品（Product）：需要创建的对象的通用接口，该接口应该是一个抽象类或者接口。
具体产品（Concrete Product）：实现产品接口的具体类，是工厂方法模式创建的对象。
抽象工厂（Factory）：包含一个抽象方法，用于创建具体产品的工厂类，通常是一个抽象类或者接口。
具体工厂（Concrete Factory）：实现抽象工厂接口的具体类，用于创建具体产品对象。

工厂方法模式优点：

工厂方法模式比简单工厂模式更加灵活，因为具体产品的创建过程由具体工厂类完成，可以根据实际情况选择不同的具体工厂类创建不同的产品对象。
工厂方法模式遵循开闭原则，添加新的产品对象只需要添加具体产品类和相应的具体工厂类，而无需修改原有代码。

工厂方法模式缺点：

工厂方法模式需要客户端代码自己负责选择具体工厂类，增加了客户端的复杂度。
如果产品种类过多，需要定义大量的抽象工厂和具体工厂类，导致代码量增大。

工厂方法模式示例：

首先，我们定义一个抽象产品类 Product：

public abstract class Product {
    public abstract void use();
}

然后，我们定义两个具体产品类 ProductA 和 ProductB，它们都继承自 Product：

public class ProductA extends Product {
    public void use() {
        System.out.println("ProductA is being used");
    }
}

public class ProductB extends Product {
    public void use() {
        System.out.println("ProductB is being used");
    }
}

接下来，我们定义一个抽象工厂类 Factory，用于创建产品对象：

public abstract class Factory {
    public abstract Product createProduct();
}

然后，我们定义两个具体工厂类 FactoryA 和 FactoryB，它们都继承自 Factory：

public class FactoryA extends Factory {
    public Product createProduct() {
        return new ProductA();
    }
}

public class FactoryB extends Factory {
    public Product createProduct() {
        return new ProductB();
    }
}

最后，我们可以使用具体工厂类来创建具体产品对象：

Factory factoryA = new FactoryA();
Product productA = factoryA.createProduct();
productA.use();  // Output: ProductA is being used

Factory factoryB = new FactoryB();
Product productB = factoryB.createProduct();
productB.use();  // Output: ProductB is being used

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）也是一种创建型设计模式，它通过定义一组抽象工厂类和一组抽象产品类来描述一系列具有相同主题的工厂和产品。

每个工厂类负责创建一组具有相同主题的产品，工厂类和产品类之间存在一种层次关系。

抽象工厂模式包含如下角色：

Java工厂设计模式详解(3种工厂设计模式)-mikechen

抽象产品（Abstract Product）：需要创建的对象的通用接口，该接口应该是一个抽象类或者接口。
具体产品（Concrete Product）：实现产品接口的具体类，是抽象工厂模式创建的对象。
抽象工厂（Abstract Factory）：包含一组抽象方法，用于创建具有相同主题的产品对象，通常是一个抽象类或者接口。
具体工厂（Concrete Factory）：实现抽象工厂接口的具体类，用于创建具有相同主题的产品对象。

抽象工厂模式示例：

首先，我们定义一个抽象产品族 ProductFamily：

public abstract class ProductFamily {
    public abstract ProductA createProductA();
    public abstract ProductB createProductB();
}

然后，我们定义两个抽象产品类 ProductA 和 ProductB：

public abstract class ProductA {
    public abstract void use();
}

public abstract class ProductB {
    public abstract void consume();
}

接下来，我们定义两个具体产品族 ProductFamily1 和 ProductFamily2，它们都继承自 ProductFamily，并分别实现了 createProductA() 和 createProductB() 方法：

public class ProductFamily1 extends ProductFamily {
    public ProductA createProductA() {
        return new ProductA1();
    }

    public ProductB createProductB() {
        return new ProductB1();
    }
}

public class ProductFamily2 extends ProductFamily {
    public ProductA createProductA() {
        return new ProductA2();
    }

    public ProductB createProductB() {
        return new ProductB2();
    }
}

然后，我们定义四个具体产品类 ProductA1、ProductB1、ProductA2 和 ProductB2，它们都分别继承自 ProductA 或 ProductB：

public class ProductA1 extends ProductA {
    public void use() {
        System.out.println("ProductA1 is being used");
    }
}

public class ProductB1 extends ProductB {
    public void consume() {
        System.out.println("ProductB1 is being consumed");
    }
}

public class ProductA2 extends ProductA {
    public void use() {
        System.out.println("ProductA2 is being used");
    }
}

public class ProductB2 extends ProductB {
    public void consume() {
        System.out.println("ProductB2 is being consumed");
    }
}

最后，我们可以使用具体工厂类来创建具体产品对象：

ProductFamily factory1 = new ProductFamily1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.use();  // Output: ProductA1 is being used
productB1.consume();  // Output: ProductB1 is being consumed

ProductFamily factory2 = new ProductFamily2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.use();  // Output: ProductA2 is being used
productB2.consume();  // Output: ProductB2 is being consumed

以上就是Java工厂设计模式详解，更多Java设计模式请查看：Java设计模式：23种设计模式(万字图文全面总结)

陈睿mikechen

十余年BAT架构经验，资深技术专家，就职于阿里、淘宝、百度等一线互联网大厂。

关注「mikechen」公众号，获取更多技术干货！

后台回复【面试】即可获取《史上最全阿里Java面试题总结》，后台回复【架构】，即可获取《阿里架构师进阶专题全部合集》

Java工厂设计模式详解(3种工厂设计模式)