Java设计模式之工厂模式

需要注意的是，虽然工厂模式可以提高代码的灵活性和可维护性，但是如果工厂的创建过程非常复杂，可能会影响系统的性能。此时需要权衡设计的复杂度和系统的性能要求，选择合适的创建方式。

Java 有几种常见的工厂模式：

简单工厂模式（Simple Factory Pattern）又称为静态工厂方法模式

在 Java 中，简单工厂模式的实现一般包括以下几个角色：

1. 工厂类（Factory）：负责创建具体产品的对象，提供一个静态方法来创建对象。通常情况下，工厂类会根据客户端的请求创建不同的具体产品对象。
2. 抽象产品类（Product）：定义了具体产品类的共同属性和行为。
3. 具体产品类（Concrete Product）：实现抽象产品类定义的属性和行为。

// 抽象产品类
public abstract class Product {
    abstract void use();
}

// 具体产品类 A
public class ProductA extends Product{
    @Override
    void use() {
        System.out.println("productA is used");
    }
}

// 具体产品类 B
public class ProductB extends Product{
    @Override
    void use() {
        System.out.println("productB is used");
    }
}

// 工厂类
public class Factory {
    public static Product createProduct(String type){
        Product product = null;
        switch (type){
            case "A":
                product= new ProductA();
                break;
            case "B":
                product= new ProductB();
                break;
            default:
                break;
        }
        return product;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Product productA = Factory.createProduct("A");
        productA.use(); // Output: ProductA is used

        Product productB = Factory.createProduct("B");
        productB.use(); // Output: ProductB is used
    }
}

简单工厂模式的优点是能够将对象的创建和使用分离，使得客户端不需要知道具体产品的类名，降低了客户端和具体产品的耦合度。同时，工厂类可以通过封装对象的创建过程来实现对对象的统一管理，提高代码的可维护性和可读性。缺点是如果需要新增产品，需要修改工厂类的代码，不符合开闭原则。此外，工厂类的静态方法可能会变得过于臃肿，难以维护。

是一种写代码的习惯，不属于23种设计模式中的一种。

工厂方法模式（Factory Method Pattern）

在 Java 中，工厂方法模式的实现一般包括以下几个角色：

1. 抽象产品类（Product）：定义了具体产品类的共同属性和行为。
2. 具体产品类（Concrete Product）：实现抽象产品类定义的属性和行为。
3. 抽象工厂类（Factory）：负责定义创建抽象产品。
4. 具体工厂类（Concrete Factory）：继承抽象工厂重写了创建产品方法，负责创建一种具体产品对象。

// 抽象产品类
public abstract class Product {
    abstract void use();
}

// 具体产品类 A
public class ProductA extends Product{
    @Override
    void use() {
        System.out.println("productA is used");
    }
}

// 具体产品类 B
public class ProductB extends Product{
    @Override
    void use() {
        System.out.println("productB is used");
    }
}

// 抽象工厂类
public abstract class AbstractFactory {
    abstract Product createProduct();
}

// 具体工厂类 A
public class AFactory extends AbstractFactory{
    @Override
    Product createProduct() {
        return new ProductA();
    }
}

// 具体工厂类 B
public class BFactory extends AbstractFactory{
    @Override
    Product createProduct() {
        return new ProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory aFactory = new AFactory();
        Product productA = aFactory.createProduct();
        productA.use(); //Output: Product A is used
        AbstractFactory bFactory = new BFactory();
        Product productB = bFactory.createProduct();
        productB.use(); //Output: Product B is used
    }
}

客户端代码只需要创建具体工厂对象，并调用具体工厂对象的 createProduct() 方法来创建具体产品对象，而不需要知道具体产品的类名。这样可以实现客户端和具体产品的解耦，并且通过定义抽象工厂类，可以方便地添加新的产品类型，符合开闭原则。

适合用于产品族的创建（一维）

抽象工厂模式（Abstract Factory Pattern）

在 Java 中，抽象工厂模式的实现一般包括以下几个角色：

1. 抽象工厂类（Abstract Factory）：定义了一组用于创建一系列产品对象的方法，这些方法返回抽象产品类型的对象。
2. 具体工厂类（Concrete Factory）：实现抽象工厂类定义的一组用于创建一系列产品对象的方法，每个方法返回具体产品类型的对象。
3. 抽象产品类（Abstract Product）：抽象产品类中的方法通常是抽象的。
4. 具体产品类（Concrete Product）：每个具体产品类对应一个具体工厂类。

// 抽象产品 A
public abstract class ProductA {
    abstract void use();
}

// 具体产品 A1
public class ProductA1 extends ProductA{
    @Override
    void use() {
        System.out.println("productA1 is used");
    }
}

// 具体产品 A2
public class ProductA2 extends ProductA{
    @Override
    void use() {
        System.out.println("productA2 is used");
    }
}

// 抽象产品 B
public abstract class ProductB {
    abstract void consume();
}

// 具体产品 B1
public class ProductB1 extends ProductB{
    @Override
    void consume() {
        System.out.println("ProductB1 is consumed");
    }
}

// 具体产品 B2
public class ProductB2 extends ProductB{
    @Override
    void consume() {
        System.out.println("ProductB2 is consumed");
    }
}

// 抽象工厂类
public abstract class AbstractFactory {
    abstract ProductA createProductA();
    abstract ProductB createProuductB();
}

// 具体工厂类 1
public class ConcreteFactory1 extends AbstractFactory{
    @Override
    ProductA createProductA() {
        return new ProductA1();
    }
    @Override
    ProductB createProuductB() {
        return new ProductB1();
    }
}

// 具体工厂类 2
public class ConcreteFactory2 extends AbstractFactory{
    @Override
    ProductA createProductA() {
        return new ProductA2();
    }
    @Override
    ProductB createProuductB() {
        return new ProductB2();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory concreteFactory1 = new ConcreteFactory1();
        ProductA productA = concreteFactory1.createProductA();
        productA.use(); //Output: productA1 is used
        ProductB prouductB = concreteFactory1.createProuductB();
        prouductB.consume(); //Output: ProductB1 is consumed

        AbstractFactory concreteFactory2 = new ConcreteFactory2();
        ProductA productA2 = concreteFactory2.createProductA();
        productA2.use(); //Output: productA2 is used
        ProductB prouductB2 = concreteFactory2.createProuductB();
        prouductB2.consume(); //Output: productB2 is consumed
    }
}

适合用于产品族的创建和扩展（二维）

工厂模式可以提高代码的可维护性、可扩展性和灵活性，而且能够隐藏对象的创建过程，降低客户端对于具体产品的依赖。因此，工厂模式是一种非常常用的设计模式。