设计模式——工厂模式

工厂模式

工厂模式是一种创建型设计模式，提供创建对象的方式，不需要客户端实例化对象

主要包括简单工厂模式，工厂方法模式和抽象工厂模式

简单工厂模式

提供统一接口来创建对象，客户端不需要知道具体的创建逻辑

优点：将对象的创建和使用分离开，使得代码易于维护和扩展

缺点：一旦需要添加新的产品类，需要修改工厂的代码，违反了开闭原则

代码示例

public interface Product {
    void operator();
}
public class ProductA implements Product {
    @Override
    public void operator() {
        System.out.println("ProductA");
    }
}
public class ProductB implements Product{
    @Override
    public void operator() {
        System.out.println("ProductB");
    }
}

public class ProductFactory {
    public static Product produce(String type) {
        Product product;
        switch (type) {
            case "A" :
                return new ProductA();
            case "B" :
                return new ProductB();
            default:
                break;
        }
    }
}

工厂方法模式

定义一个创建对象的接口，将具体的实现延迟到子类；每个具体的产品都有对应的工厂来创建，避免了简单工厂模式中工厂类的修改。

好处：符合开闭原则，但客户端需要知道具体的工厂类

代码示例

public interface Product {
    void operator();
}
public class ProductA implements Product {
    @Override
    public void operator() {
        System.out.println("ProductA");
    }
}
public class ProductB implements Product{
    @Override
    public void operator() {
        System.out.println("ProductB");
    }
}
public interface  Facotry {
    public Product produce();
}
public class FacotryA implements Facotry {
    @Override
    public Product produce() {
        new ProductA();
    }
}
public class FacotryB implements Facotry{
    @Override
    public Product produce() {
        new ProductB();
    }
}

抽象工厂模式

提供一个接口，用于创建一系列相关或相互依赖的对象，而不需要指定具体类。

抽象工厂模式通过提供一组接口来创建一系列相关的对象，这些对象通常组成一个产品族。

相对于工厂方法模式，更加灵活，能够创建更多类型的对象

当需要增加新的产品族时，需要修改接口及所有实现类，违反了开闭原则

代码示例

public interface ProductA {
    void operator();
}
public class ProductA1 implements ProductA{
    @Override
    public void operator() {
        System.out.println("ProductA1");
    }
}
public class ProductA2 implements ProductA{
    @Override
    public void operator() {
        System.out.println("ProductA2");
    }
}
public interface ProductB {
    void operator();
}
public class ProductB1 implements ProductB{
    @Override
    public void operator() {
        System.out.println("ProductB1");
    }
}
public class ProductB2 implements ProductB{
    @Override
    public void operator() {
        System.out.println("ProductB2");
    }
}
public interface Facotry {
    public ProductA produceA();
    public ProductB produceB();
}
public class FacotryA implements Facotry {
    @Override
    public ProductA produceA() {
        return new ProductA1();
    }

    @Override
    public ProductB produceB() {
        return new ProductB1();
    }
}
public class FacotryB implements Facotry {
    @Override
    public ProductA produceA() {
        return new ProductA2();
    }
    @Override
    public ProductB produceB() {
        return new ProductB2();
    }
}
public class Client {
    public static void main(String[] args) {
        Facotry facotryA = new FacotryA();
        ProductA productA1 = facotryA.produceA();
        ProductB productB1 = facotryA.produceB();
        productA1.operator();
        productB1.operator();

        FacotryB facotryB = new FacotryB();
        ProductA productA2 = facotryB.produceA();
        ProductB productB2 = facotryA.produceB();
        productA2.operator();
        productB2.operator();
    }
}