设计模式之工厂模式-简单工厂、工厂方法、抽象工厂模式

工厂模式是一种常见的创建型设计模式，它提供了一种创建对象的方法，将对象的创建与使用分离开来，可以减少代码的耦合度。在工厂模式中，我们通过一个工厂类来创建对象，而不是直接在代码中实例化对象。

工厂模式有三种常见的实现方式：简单工厂模式、工厂方法模式和抽象工厂模式。下面我将简单介绍一下这三种模式的实现方式。

简单工厂模式

简单工厂模式又称为静态工厂模式，它通过一个工厂类来创建对象，客户端只需要知道要创建的产品的类型，而不需要知道具体的实现细节。简单工厂模式适用于创建的对象比较少的情况。

下面是一个简单工厂模式的示例代码：

// 抽象产品类
interface Product {void use();
}// 具体产品类
class ConcreteProductA implements Product {public void use() {System.out.println("使用产品A");}
}class ConcreteProductB implements Product {public void use() {System.out.println("使用产品B");}
}// 工厂类
class SimpleFactory {public static Product createProduct(String type) {if (type.equals("A")) {return new ConcreteProductA();} else if (type.equals("B")) {return new ConcreteProductB();} else {throw new IllegalArgumentException("不支持的产品类型");}}
}// 客户端
public class Client {public static void main(String[] args) {Product productA = SimpleFactory.createProduct("A");productA.use();Product productB = SimpleFactory.createProduct("B");productB.use();}
}

上面的代码中，我们定义了一个抽象产品类 Product 和两个具体产品类 ConcreteProductA 和 ConcreteProductB。然后我们定义了一个工厂类 SimpleFactory，其中的 createProduct 方法根据传入的参数创建不同的产品对象。

客户端只需要调用 SimpleFactory.createProduct 方法，传入对应的参数，就可以得到不同的产品对象。

工厂方法模式

工厂方法模式是指定义一个抽象工厂接口，具体的工厂类实现这个工厂接口，并且每个具体工厂类只能创建对应的产品。工厂方法模式适用于创建的对象比较多的情况。

下面是一个工厂方法模式的示例代码：

// 抽象产品类
interface Product {void use();
}// 具体产品类
class ConcreteProductA implements Product {public void use() {System.out.println("使用产品A");}
}class ConcreteProductB implements Product {public void use() {System.out.println("使用产品B");}
}// 抽象工厂类
interface Factory {Product createProduct();
}// 具体工厂类
class ConcreteFactoryA implements Factory {public Product createProduct() {return new ConcreteProductA();}
}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.use();Factory factoryB = new ConcreteFactoryB();Product productB = factoryB.createProduct();productB.use();}
}

上面的代码中，我们定义了一个抽象产品类 Product 和两个具体产品类 ConcreteProductA 和 ConcreteProductB。然后我们定义了一个抽象工厂类 Factory，其中的 createProduct 方法用于创建产品对象。

接着我们定义了两个具体工厂类 ConcreteFactoryA 和 ConcreteFactoryB，它们分别实现了 Factory 接口，并且每个工厂类只能创建对应的产品。

客户端需要先创建对应的具体工厂类对象，然后通过工厂对象的 createProduct 方法来创建产品对象。

抽象工厂模式

抽象工厂模式是指定义一个抽象工厂接口，具体的工厂类实现这个工厂接口，并且每个工厂类可以创建一组产品。抽象工厂模式适用于创建的对象有多个产品族的情况。

下面是一个抽象工厂模式的示例代码：

// 抽象产品类
interface ProductA {void use();
}interface ProductB {void eat();
}// 具体产品类
class ConcreteProductA1 implements ProductA {public void use() {System.out.println("使用产品A1");}
}class ConcreteProductA2 implements ProductA {public void use() {System.out.println("使用产品A2");}
}class ConcreteProductB1 implements ProductB {public void eat() {System.out.println("吃产品B1");}
}class ConcreteProductB2 implements ProductB {public void eat() {System.out.println("吃产品B2");}
}// 抽象工厂类
interface Factory {ProductA createProductA();ProductB createProductB();
}// 具体工厂类
class ConcreteFactory1 implements Factory {public ProductA createProductA() {return new ConcreteProductA1();}public ProductB createProductB() {return new ConcreteProductB1();}
}class ConcreteFactory2 implements Factory {public ProductA createProductA() {return new ConcreteProductA2();}public ProductB createProductB() {return new ConcreteProductB2();}
}// 客户端
public class Client {public static void main(String[] args) {Factory factory1 = new ConcreteFactory1();ProductA productA1 = factory1.createProductA();productA1.use();ProductB productB1 = factory1.createProductB();productB1.eat();Factory factory2 = new ConcreteFactory2();ProductA productA2 = factory2.createProductA();productA2.use();ProductB productB2 = factory2.createProductB();productB2.eat();}
}