Java设计模式——工厂模式,java工厂设计模式
工厂模式是一种常见的创建型设计模式，它提供了一种创建对象的方法，将对象的创建与使用分离开来，可以减少代码的耦合度。在工厂模式中，我们通过一个工厂类来创建对象，而不是直接在代码中实例化对象。
工厂模式有三种常见的实现方式：简单工厂模式、工厂方法模式和抽象工厂模式。下面我将简单介绍一下这三种模式的实现方式。
1. 简单工厂模式
简单工厂模式又称为静态工厂模式，它通过一个工厂类来创建对象，客户端只需要知道要创建的产品的类型，而不需要知道具体的实现细节。简单工厂模式适用于创建的对象比较少的情况。
下面是一个简单工厂模式的示例代码：
```java
// 抽象产品类
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` 方法，传入对应的参数，就可以得到不同的产品对象。
2. 工厂方法模式
工厂方法模式是指定义一个抽象工厂接口，具体的工厂类实现这个工厂接口，并且每个具体工厂类只能创建对应的产品。工厂方法模式适用于创建的对象比较多的情况。
下面是一个工厂方法模式的示例代码：
```java
// 抽象产品类
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` 方法来创建产品对象。
3. 抽象工厂模式
抽象工厂模式是指定义一个抽象工厂接口，具体的工厂类实现这个工厂接口，并且每个工厂类可以创建一组产品。抽象工厂模式适用于创建的对象有多个产品族的情况。
下面是一个抽象工厂模式的示例代码：
```java
// 抽象产品类
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();
}
}
```
上面的代码中，我们定义了两个抽象产品类 `ProductA` 和 `ProductB`，以及四个具体产品类 `ConcreteProductA1`、`ConcreteProductA2`、`ConcreteProductB1` 和 `ConcreteProductB2`。
然后我们定义了一个抽象工厂类 `Factory`，其中的 `createProductA` 和 `createProductB` 方法分别用于创建 `ProductA` 和 `ProductB` 对象。
接着我们定义了两个具体工厂类 `ConcreteFactory1` 和 `ConcreteFactory2`，它们分别实现了 `Factory` 接口，并且每个工厂类可以创建一组产品。
客户端需要先创建对应的具体工厂类对象，然后通过工厂对象的 `createProductA` 和 `createProductB` 方法来创建产品对象。
