工厂方法模式（Factory Method Pattern）

是一种创建型设计模式，它在父类中提供一个创建对象的方法，允许子类决定实例化哪一个类。工厂方法模式将对象的实例化推迟到子类中进行，使得系统在不修改原有代码的情况下可以扩展，从而实现了开闭原则（对扩展开放，对修改关闭）

模式结构

1. 抽象工厂（Abstract Factory）：声明了一个创建产品的抽象方法，由子类决定实现。
2. 具体工厂（Concrete Factory）：实现了抽象工厂中的抽象方法，完成具体产品的创建。
3. 抽象产品（Abstract Product）：定义了产品的接口，是工厂方法模式所创建对象的超类型，也就是产品对象的共同父类或接口。
4. 具体产品（Concrete Product）：实现了抽象产品接口的具体产品。

工作原理

1. 客户端调用抽象工厂中的工厂方法以获取所需产品的实例。
2. 抽象工厂将具体产品的创建推迟到其子类（即具体工厂）中进行。
3. 具体工厂根据需求创建并返回具体产品的实例。

优点

1. 降低耦合度：客户端只需要知道所需产品的抽象接口，而不需要知道具体产品的类名，降低了客户端与具体产品之间的耦合度。
2. 扩展性好：当需要添加新的产品时，只需要增加相应的具体产品类和具体工厂类，而不需要修改原有的代码，符合开闭原则。
3. 隐藏实现细节：客户端只需要关注产品的抽象接口，而不需要关心产品的具体实现细节，降低了系统的复杂度。

缺点

1. 增加了类的数量：由于需要为每个产品都提供一个具体的工厂类，因此会增加系统中类的数量。
2. 增加了系统的复杂度：对于简单的场景，使用工厂方法模式可能会增加系统的复杂度，使得代码难以理解和维护。

应用场景

1. 当一个类不知道它所必须创建的对象的类的时候。
2. 当一个类希望由它的子类来指定它所创建的对象的时候。
3. 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

实例代码

// 抽象产品  
public interface Product {  
    void use();  
}  
`
// 具体产品A  
public class ConcreteProductA implements Product {  
    @Override  
    public void use() {  
        System.out.println("使用产品A");  
    }  
}  

// 具体产品B  
public class ConcreteProductB implements Product {  
    @Override  
    public void use() {  
        System.out.println("使用产品B");  
    }  
}  
  
// 抽象工厂  
public abstract class AbstractFactory {  
    public abstract Product createProduct();  
}  
  
// 具体工厂A  
public class ConcreteFactoryA extends AbstractFactory {  
    @Override  
    public Product createProduct() {  
        return new ConcreteProductA();  
    }  
}  
  
// 具体工厂B  
public class ConcreteFactoryB extends AbstractFactory {  
    @Override  
    public Product createProduct() {  
        return new ConcreteProductB();  
    }  
}  
// 客户端代码  
public class Client {  
    public static void main(String[] args) {  
        AbstractFactory factoryA = new ConcreteFactoryA();  
        Product productA = factoryA.createProduct();  
        productA.use(); // 输出：使用产品A  
        AbstractFactory factoryB = newConcreteFactoryB();  

        Product productB = factoryB.createProduct();  
        productB.use(); // 输出：使用产品B  
    }  
}