java 工厂模式

工厂模式（Factory Pattern）是 Java 中常用的一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

Java 中的工厂模式主要有三种：简单工厂模式（Simple Factory Pattern）、工厂方法模式（Factory Method Pattern）和抽象工厂模式（Abstract Factory Pattern）。

1.简单工厂模式（Simple Factory Pattern）
简单工厂模式不属于 GoF 23 种设计模式，但它可以作为工厂方法模式的一个引导，有时候也被看作工厂方法模式的一种特例。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

public interface Product {  
    void use();  
}  
  
public class ConcreteProductA implements Product {  
    @Override  
    public void use() {  
        System.out.println("使用具体产品A");  
    }  
}  
  
public class ConcreteProductB implements Product {  
    @Override  
    public void use() {  
        System.out.println("使用具体产品B");  
    }  
}  
  
public class SimpleFactory {  
    public Product createProduct(String type) {  
        if ("A".equals(type)) {  
            return new ConcreteProductA();  
        } else if ("B".equals(type)) {  
            return new ConcreteProductB();  
        }  
        return null;  
    }  
}  
  
// 客户端代码  
SimpleFactory factory = new SimpleFactory();  
Product productA = factory.createProduct("A");  
productA.use();

2.工厂方法模式（Factory Method Pattern）
工厂方法模式定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

public interface Product {  
    void use();  
}  
  
public class ConcreteProductA implements Product {  
    @Override  
    public void use() {  
        System.out.println("使用具体产品A");  
    }  
}  
  
public class ConcreteProductB implements Product {  
    @Override  
    public void use() {  
        System.out.println("使用具体产品B");  
    }  
}  
  
public interface Factory {  
    Product createProduct();  
}  
  
public class ConcreteFactoryA implements Factory {  
    @Override  
    public Product createProduct() {  
        return new ConcreteProductA();  
    }  
}  
  
public class ConcreteFactoryB implements Factory {  
    @Override  
    public Product createProduct() {  
        return new ConcreteProductB();  
    }  
}  
  
// 客户端代码  
Factory factoryA = new ConcreteFactoryA();  
Product productA = factoryA.createProduct();  
productA.use();  
  
Factory factoryB = new ConcreteFactoryB();  
Product productB = factoryB.createProduct();  
productB.use();

3.抽象工厂模式（Abstract Factory Pattern）
抽象工厂模式提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

public interface ProductA {  
    void use();  
}  
  
public interface ProductB {  
    void eat();  
}  
  
public class ConcreteProductA1 implements ProductA {  
    @Override  
    public void use() {  
        System.out.println("使用具体产品A1");  
    }  
}  
  
public class ConcreteProductA2 implements ProductA {  
    @Override  
    public void use() {  
        System.out.println("使用具体产品A2");  
    }  
}  
  
public class ConcreteProductB1 implements ProductB {  
    @Override  
    public void eat() {  
        System.out.println("使用具体产品B1");  
    }  
}  
  
public class ConcreteProductB2 implements ProductB {  
    @Override  
    public void eat() {  
        System.out.println("使用具体产品B2");  
    }  
}  
  
public interface AbstractFactory {  
    ProductA createProductA();  
    ProductB createProductB();  
}  
  
public class ConcreteFactory1 implements AbstractFactory {  
    @Override  
    public ProductA createProductA() {  
        return new ConcreteProductA1();  
    }  
  
    @Override  
    public ProductB createProductB() {  
        return new ConcreteProductB1();  
    }  
}  
  
public class ConcreteFactory2 implements AbstractFactory {  
    @Override  
    public ProductA createProductA() {  
        return new ConcreteProductA2();  
    }  
  
    @Override  
    public ProductB createProductB() {  
        return new ConcreteProductB2();  
    }  
}  
  
// 客户端代码  
AbstractFactory factory1 = new ConcreteFactory1();  
ProductA productA1 = factory1.createProductA();  
ProductB productB1 = factory1.createProductB();  
productA1.use();  
productB1.eat();  
  
AbstractFactory factory2 = new ConcreteFactory2();  
ProductA productA2 = factory2.createProductA();  
ProductB productB2 = factory2.createProductB();  
productA2.use();  
productB2.eat();

在抽象工厂模式中，客户端使用抽象工厂和抽象产品接口，而不需要了解具体实现的类。这种方式在需要创建产品家族的时候非常有用，因为它能够保持产品的一致性。如果系统需要增加新的产品族，只需要扩展相应的工厂类和产品类，而不需要修改已有的代码，这符合开闭原则。