工厂方法模式
1. 模式简述
工厂方法模式(Factory Method Pattern)是一种创建型设计模式,它定义了一个用于创建对象的接口,但将实际创建对象的过程延迟到子类中。这样,工厂方法模式允许子类决定实例化哪个具体类。
2. UML类图
@startuml
interface Product {
+ operation(): void
}
class ConcreteProductA {
+ operation(): void
}
class ConcreteProductB {
+ operation(): void
}
abstract class Creator {
+ abstract factoryMethod(): Product
+ anOperation(): void
}
class ConcreteCreatorA {
+ factoryMethod(): Product
}
class ConcreteCreatorB {
+ factoryMethod(): Product
}
Creator <|-- ConcreteCreatorA
Creator <|-- ConcreteCreatorB
Product <|.. ConcreteProductA
Product <|.. ConcreteProductB
@enduml
3. 详细说明
Product
:抽象产品接口,定义了产品的通用操作方法。ConcreteProductA
、ConcreteProductB
:具体产品类,实现了抽象产品接口,是工厂方法模式所创建的目标产品。Creator
:抽象创建者,声明了一个工厂方法用于返回一个产品对象,并可以提供一个默认的实现,通常会包含一些公共的业务逻辑。ConcreteCreatorA
、ConcreteCreatorB
:具体创建者,实现了工厂方法,负责实际创建具体产品对象。
4. Java代码示例
// 抽象产品接口
public interface Product {
void operation();
}
// 具体产品A
public class ConcreteProductA implements Product {
@Override
public void operation() {
System.out.println("ConcreteProductA operation");
}
}
// 具体产品B
public class ConcreteProductB implements Product {
@Override
public void operation() {
System.out.println("ConcreteProductB operation");
}
}
// 抽象创建者
public abstract class Creator {
public abstract Product factoryMethod();
public void anOperation() {
// 公共的业务逻辑
System.out.println("anOperation");
// 使用工厂方法创建产品
Product product = factoryMethod();
// 调用产品的操作方法
product.operation();
}
}
// 具体创建者A
public class ConcreteCreatorA extends Creator {
@Override
public Product factoryMethod() {
return new ConcreteProductA();
}
}
// 具体创建者B
public class ConcreteCreatorB extends Creator {
@Override
public Product factoryMethod() {
return new ConcreteProductB();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
Creator creatorA = new ConcreteCreatorA();
creatorA.anOperation(); // 输出:anOperation ConcreteProductA operation
Creator creatorB = new ConcreteCreatorB();
creatorB.anOperation(); // 输出:anOperation ConcreteProductB operation
}
}
以上是一个简单的工厂方法模式的示例。通过抽象创建者和具体创建者来实现产品的创建,客户端只需要与抽象接口进行交互,而不需要直接依赖于具体产品类。通过具体创建者的实现来决定创建哪种具体产品对象。
抽象工厂模式
1. 模式简述
抽象工厂模式(Abstract Factory Pattern)是一种创建型设计模式,它提供了一个创建一系列相关或相互依赖对象的接口,而无需指定具体的类。抽象工厂模式允许客户端使用抽象接口来创建一组相关的产品,而无需关心具体的实现。
2. UML类图
@startuml
interface AbstractProductA {
+ operation(): void
}
interface AbstractProductB {
+ operation(): void
}
class ConcreteProductA1 {
+ operation(): void
}
class ConcreteProductA2 {
+ operation(): void
}
class ConcreteProductB1 {
+ operation(): void
}
class ConcreteProductB2 {
+ operation(): void
}
interface AbstractFactory {
+ createProductA(): AbstractProductA
+ createProductB(): AbstractProductB
}
class ConcreteFactory1 {
+ createProductA(): AbstractProductA
+ createProductB(): AbstractProductB
}
class ConcreteFactory2 {
+ createProductA(): AbstractProductA
+ createProductB(): AbstractProductB
}
AbstractFactory <|.. ConcreteFactory1
AbstractFactory <|.. ConcreteFactory2
AbstractProductA <|.. ConcreteProductA1
AbstractProductA <|.. ConcreteProductA2
AbstractProductB <|.. ConcreteProductB1
AbstractProductB <|.. ConcreteProductB2
@enduml
3. 详细说明
AbstractProductA
、AbstractProductB
:抽象产品接口,定义了一系列相关产品的通用操作方法。ConcreteProductA1
、ConcreteProductA2
、ConcreteProductB1
、ConcreteProductB2
:具体产品类,实现了抽象产品接口,属于某个产品族的产品实现。AbstractFactory
:抽象工厂接口,声明了一组用于创建产品的工厂方法。ConcreteFactory1
、ConcreteFactory2
:具体工厂类,实现了抽象工厂接口,负责创建某个产品族的具体产品。
4. Java代码示例
//抽象产品A接口
public interface AbstractProductA {
void operation();
}
// 具体产品A1
public class ConcreteProductA1 implements AbstractProductA {
@Override
public void operation() {
System.out.println("ConcreteProductA1 operation");
}
}
// 具体产品A2
public class ConcreteProductA2 implements AbstractProductA {
@Override
public void operation() {
System.out.println("ConcreteProductA2 operation");
}
}
// 抽象产品B接口
public interface AbstractProductB {
void operation();
}
// 具体产品B1
public class ConcreteProductB1 implements AbstractProductB {
@Override
public void operation() {
System.out.println("ConcreteProductB1 operation");
}
}
// 具体产品B2
public class ConcreteProductB2 implements AbstractProductB {
@Override
public void operation() {
System.out.println("ConcreteProductB2 operation");
}
}
// 抽象工厂接口
public interface AbstractFactory {
AbstractProductA createProductA();
AbstractProductB createProductB();
}
// 具体工厂1
public class ConcreteFactory1 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB1();
}
}
// 具体工厂2
public class ConcreteFactory2 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB2();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
// 创建具体工厂1
AbstractFactory factory1 = new ConcreteFactory1();
// 使用工厂1创建产品A、B
AbstractProductA productA1 = factory1.createProductA();
AbstractProductB productB1 = factory1.createProductB();
productA1.operation(); // 输出:ConcreteProductA1 operation
productB1.operation(); // 输出:ConcreteProductB1 operation
// 创建具体工厂2
AbstractFactory factory2 = new ConcreteFactory2();
// 使用工厂2创建产品A、B
AbstractProductA productA2 = factory2.createProductA();
AbstractProductB productB2 = factory2.createProductB();
productA2.operation(); // 输出:ConcreteProductA2 operation
productB2.operation(); // 输出:ConcreteProductB2 operation
}
}
以上是一个简单的抽象工厂模式的示例。通过抽象工厂和具体工厂来创建一系列相关的产品,同时客户端只需要与抽象接口进行交互,而不需要关心具体的产品类。抽象工厂模式允许在运行时切换具体工厂,从而实现不同产品族的替换。