工厂设计模式
工厂设计模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，工厂模式的核心是定义一个创建对象的接口，但是让实现这个接口的类来决定实例化哪一个类。工厂模式将实例化的过程延迟到子类中进行。
类型：
工厂设计模式有不同的变种，其中包括：
- 简单工厂模式：由一个工厂对象来决定创建出哪一个类的对象。
简单工厂模式负责创建产品对象而不向客户端直接暴露创建逻辑。简单工厂模式中，客户端请求创建一个产品对象，工厂返回一个根据参数创建的产品对象。如下面的代码：
public class Main {
public static void main(String[] args) {
SimpleFactory factory = new SimpleFactory();
Product productA = factory.createProduct("A");
Product productB = factory.createProduct("B");
productA.operation();
productB.operation();
}
}
// 产品接口
interface Product {
// 每一个产品需要完成的功能
void operation();
}
// 具体产品A
class ProductA implements Product {
@Override
public void operation() {
System.out.println("Product A is doing its job...");
}
}
// 具体产品B
class ProductB implements Product {
@Override
public void operation() {
System.out.println("Product B is doing its job...");
}
}
// 简单工厂类
class SimpleFactory {
public Product createProduct(String type) {
if ("A".equals(type)) {
return new ProductA();
} else if ("B".equals(type)) {
return new ProductB();
}
return null;
}
}
结果如下:
Product A is doing its job...
Product B is doing its job...
- 工厂方法模式：定义一个创建产品对象的工厂接口，而子类决定实例化哪一个具体的类。
工厂方法模式定义了一个创建产品对象的接口，但允许子类决定实例化哪一个类。工厂方法模式让类的实例化推送到子类中。如下面的代码：
public class Main {
public static void main(String[] args) {
AbstractFactory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
AbstractFactory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productA.operation();
productB.operation();
}
}
// 抽象产品接口
interface Product {
void operation();
}
// 具体产品A
class ConcreteProductA implements Product {
@Override
public void operation() {
System.out.println("A 产品正在工作");
}
}
// 具体产品B
class ConcreteProductB implements Product {
@Override
public void operation() {
System.out.println("B 产品正在工作");
}
}
// 抽象工厂接口
interface AbstractFactory {
Product createProduct();
}
// 具体工厂A
class ConcreteFactoryA implements AbstractFactory{
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
// 具体工厂B
class ConcreteFactoryB implements AbstractFactory{
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}
运行结果如下：
A 产品正在工作
B 产品正在工作
- 抽象工厂模式：提供一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类。
抽象工厂模式提供一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类，抽象工厂模式通常适用于一组相关的对象，它们共同工作，如下面的代码：
public class Main {
public static void main(String[] args) {
AbstractFactory factory = new ConcreteFactory();
ProductA productA = factory.createProductA();
ProductB productB = factory.createProductB();
productA.operationA();
productB.operationB();
}
}
// 抽象产品族A接口
interface ProductA {
void operationA();
}
// 抽象产品族B接口
interface ProductB {
void operationB();
}
// 具体产品族A实现
class ConcreteProductA implements ProductA{
@Override
public void operationA() {
System.out.println("A族产品正在工作");
}
}
// 具体产品族B实现
class ConcreteProductB implements ProductB{
@Override
public void operationB() {
System.out.println("B族产品正在工作");
}
}
// 抽象工厂接口
interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
// 具体工厂
class ConcreteFactory implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB();
}
}
运行结果如下：
A族产品正在工作
B族产品正在工作
优点：
- 减少系统耦合度
- 符合开闭原则，增加新的产品对象不影响已存在的工厂结构。
总结：
- 简单工厂模式：适用于客户端只需要知道产品的类型，不需要关注具体的产品创建逻辑。
- 工厂方法模式：适用于需要将产品的创建逻辑封装在不同的工厂中，客户端可以根据需要选择不同的工厂。
- 抽象工厂模式：适用于需要创建一组相关或依赖的对象，并希望将这些对象的创建逻辑封装在一个工厂中。