定义：工厂模式是一种常见的设计模式，属于创建型模式。旨在提供一种统一的接口来创建一组（相关或依赖）对象，而无需指定它们的具体类。
在工厂模式中，我们将对象的创建和使用分离开来，通过一个工厂类来实现对象的创建。这样可以隐藏对具体类的实例化过程，降低了系统的耦合度，提高了代码的灵活性和可维护性。
工厂模式通常涉及四个角色：
抽象产品： 定义了产品的接口，是具体产品类的共同父类或共同拥有的接口。
具体产品： 实现了抽象产品接口的具体类，是工厂模式所创建的对象。
抽象工厂： 声明了创建抽象产品的接口，通常包含一个或多个创建产品的方法。
具体工厂： 实现了抽象工厂接口，负责创建具体产品的实例。
工厂模式有几种常见的形式：
简单工厂模式： 通过一个单独的类来创建对象，客户端只需要知道产品的类型，而不需要知道具体的实现类。但是这种模式违背了开放封闭原则，因为每次添加新产品都需要修改工厂类。
工厂方法模式： 将对象的实例化延迟到子类中进行，每个具体工厂类负责创建一类产品。客户端通过调用工厂方法来创建产品，而不需要关心具体的实现。
抽象工厂模式： 提供一个接口，用于创建一系列相关或依赖的产品，而不指定它们的具体类。每个具体工厂类负责创建一组产品，保证这些产品是相互兼容的。
1. 简单工厂模式
简单工厂模式使用一个工厂类负责创建所有的产品对象，客户端通过传递不同的参数来获取不同的产品实例。
// 抽象产品
interface Product {
void display();
}
// 具体产品A
class ConcreteProductA implements Product {
public void display() {
System.out.println("Product A");
}
}
// 具体产品B
class ConcreteProductB implements Product {
public void display() {
System.out.println("Product B");
}
}
// 简单工厂
class SimpleFactory {
public static Product createProduct(String type) {
if ("A".equals(type)) {
return new ConcreteProductA();
} else if ("B".equals(type)) {
return new ConcreteProductB();
}
return null;
}
}
// 客户端
public class Client {
public static void main(String[] args) {
Product productA = SimpleFactory.createProduct("A");
productA.display();
Product productB = SimpleFactory.createProduct("B");
productB.display();
}
}
2. 工厂方法模式
工厂方法模式通过定义一个接口来创建对象，具体的工厂类负责实现这个接口，每个具体工厂类负责创建一类产品。
// 抽象产品
interface Product {
void display();
}
// 具体产品A
class ConcreteProductA implements Product {
public void display() {
System.out.println("Product A");
}
}
// 具体产品B
class ConcreteProductB implements Product {
public void display() {
System.out.println("Product B");
}
}
// 抽象工厂
interface Factory {
Product createProduct();
}
// 具体工厂A
class ConcreteFactoryA implements Factory {
public Product createProduct() {
return new ConcreteProductA();
}
}
// 具体工厂B
class ConcreteFactoryB implements Factory {
public Product createProduct() {
return new ConcreteProductB();
}
}
// 客户端
public class Client {
public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.display();
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.display();
}
}
3. 抽象工厂模式
抽象工厂模式通过提供一个接口来创建一系列相关或依赖的产品，每个具体工厂类负责创建一组产品。
// 抽象产品A
interface ProductA {
void display();
}
// 具体产品A1
class ConcreteProductA1 implements ProductA {
public void display() {
System.out.println("Product A1");
}
}
// 具体产品A2
class ConcreteProductA2 implements ProductA {
public void display() {
System.out.println("Product A2");
}
}
// 抽象产品B
interface ProductB {
void display();
}
// 具体产品B1
class ConcreteProductB1 implements ProductB {
public void display() {
System.out.println("Product B1");
}
}
// 具体产品B2
class ConcreteProductB2 implements ProductB {
public void display() {
System.out.println("Product B2");
}
}
// 抽象工厂
interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
public ProductA createProductA() {
return new ConcreteProductA1();
}
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
public ProductA createProductA() {
return new ConcreteProductA2();
}
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
// 客户端
public class Client {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.display();
productB1.display();
AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.display();
productB2.display();
}
}
