设计模式之工厂模式的三种分类

1.工厂模式：

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种将实例化对象的过程延迟到子类或具体实现类的方法。通过使用工厂模式，客户端代码可以创建对象，而无需了解具体类或其构造过程。

主要优点：

1. 解耦：客户端代码与具体类解耦，不需要知道如何创建这些类的实例。

2. 可扩展性：通过添加新的具体类和相应的工厂实现，可以轻松扩展系统而不修改现有代码。

3. 集中管理实例化逻辑：实例化逻辑集中在工厂类中，可以在一个地方进行更改和维护。

1.简单工厂模式

（Simple Factory Pattern）

• 定义：简单工厂模式通过一个工厂类来创建不同类型的对象，客户端通过传递不同的参数给工厂类，工厂类根据参数的不同来创建不同类型的对象。

• 特点：简单工厂模式只有一个工厂类，客户端只需要知道工厂类和产品类的名称，不需要关心产品的创建过程。

• 优点：实现简单，客户端代码简洁，隐藏了对象创建的细节。

• 缺点：违反了开闭原则，增加新产品时需要修改工厂类的代码。

interface Product {
    void use();
}
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("ConcreteProductA");
    }
}

class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("ConcreteProductB");
    }
}

class SimpleFactory {
    public static Product createProduct(String productType) {
        if (productType.equals("A")) {
            return new ConcreteProductA();
        } else if (productType.equals("B")) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("Unknown product type");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Product product = SimpleFactory.createProduct("A");
        product.use();
    }
}

​

2.工厂方法模式

（Factory Method Pattern）

• 定义：工厂方法模式定义了一个用于创建对象的接口，但是将具体的实现延迟到子类中。这样，客户端代码在不需要知道具体的产品类的情况下，就可以创建对象。

• 特点：工厂方法模式将对象的创建延迟到子类中，每个具体的工厂类负责创建一种类型的产品。

• 优点：符合开闭原则，添加新产品时只需要添加新的具体工厂类，不需要修改现有代码。

• 缺点：增加了类的个数，增加了系统的复杂度。

public interface Video {
    public void produce();
}
​
public interface VideoFactory {
    public Video getVideo();
}
​
public class JavaVideoFactory implements VideoFactory {
    @Override
    public Video getVideo() {
        return new JavaVideo();
    }
}
public class PythonVideoFactory implements VideoFactory {
    @Override
    public Video getVideo() {
        return new PythonVideo();
    }
}
​
public class JavaVideo implements Video {
    @Override
    public void produce() {
        System.out.println("Java 视频");
    }
}
public class PythonVideo implements Video{
    @Override
    public void produce() {
        System.out.println("Python 视频");
    }
}
​
 public static void main(String[] args) {
        VideoFactory javaVideoFactory = new JavaVideoFactory();
        Video javaVideo = javaVideoFactory.getVideo();
        javaVideo.produce();
​
        VideoFactory pythonVideoFactory = new PythonVideoFactory();
        Video pythonVideo = pythonVideoFactory.getVideo();
        pythonVideo.produce();
    }

3. 抽象工厂模式

（Abstract Factory Pattern）

• 定义：抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。这种模式涉及到一个抽象工厂类，它有多个方法，每个方法用于创建不同种类的对象。

• 特点：抽象工厂模式提供了一种创建一组相关或相互依赖对象的方式，可以创建一族产品。

• 优点：客户端代码与具体产品类解耦，易于替换产品系列。

• 缺点：难以支持新种类的产品，需要修改抽象工厂和所有的具体工厂类。

interface AbstractProductA {
    void use();
}
​
class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA1");
    }
}
​
class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA2");
    }
}
​
interface AbstractProductB {
    void interact(AbstractProductA productA);
}
​
class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void interact(AbstractProductA productA) {
        System.out.println("Interacting ConcreteProductB1 with " + productA.getClass().getSimpleName());
    }
}
​
class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void interact(AbstractProductA productA) {
        System.out.println("Interacting ConcreteProductB2 with " + productA.getClass().getSimpleName());
    }
}
​
interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}
​
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }
​
    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}
​
public class Main {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();
        AbstractProductA productA = factory.createProductA();
        AbstractProductB productB = factory.createProductB();
​
        productA.use();
        productB.interact(productA);
    }
}

三种工厂模式区别：

• 简单工厂模式适用于创建单一类型的产品，但不支持产品的扩展。

• 工厂方法模式适用于创建单一类型的产品，但支持产品的扩展，符合开闭原则。

• 抽象工厂模式适用于创建一组相关或相互依赖的产品，但不支持产品的扩展，需要修改抽象工厂和具体工厂类。