创建型设计模式
概述：主要用于创建对象的过程中，封装对象的实例化逻辑。它通过定义一个创建对象的公共接口，但允许子类决定要实例化的类是哪一个。
优势：可以将对象的实例化过程与客户端代码解耦，使客户端代码更加灵活、可扩展。
举例说明：此代码段为公共代码段
// 定义产品接口A
public interface ProductA {
void operation();
}
// 实现具体产品A1
public class ConcreteProductA1 implements ProductA {
@Override
public void operation() {
System.out.println("ConcreteProductA1 operation");
}
}
// 实现具体产品A2
public class ConcreteProductA2 implements ProductA {
@Override
public void operation() {
System.out.println("ConcreteProductA2 operation");
}
}
// 定义产品接口B
public interface ProductB {
void operation();
}
// 实现具体产品B1
public class ConcreteProductB1 implements ProductB {
@Override
public void operation() {
System.out.println("ConcreteProductB1 operation");
}
}
// 实现具体产品B2
public class ConcreteProductB2 implements ProductB {
@Override
public void operation() {
System.out.println("ConcreteProductB2 operation");
}
}
工厂模式
创建只生成特定产品的工厂
// 实现具体工厂1
public class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
// 只生成产品A1
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
// 只生成产品B1
return new ConcreteProductB1();
}
}
// 实现具体工厂2
public class ConcreteFactory2 implements AbstractFactory {
@Override
public ProductA createProductA() {
// 只生成产品A2
return new ConcreteProductA2();
}
@Override
public ProductB createProductB() {
// 只生成产品B2
return new ConcreteProductB2();
}
}
抽象工厂模式
抽象工厂，可以创建多个工厂
// 抽象工厂接口
public interface AbstractFactory {
// 负责创建A1、B1产品的工厂
ProductA createProductA();
// 负责创建A2、B2产品的工厂
ProductB createProductB();
}
最后运行工厂代码段
// 客户端代码
public class Client {
public static void main(String[] args) {
// 创建多个工厂，以至于来生成特定工厂所支持的产品
AbstractFactory factory1 = new ConcreteFactory1();
AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA1.operation();
productB1.operation();
productA2.operation();
productB2.operation();
}
}
单例模式
保证一个类只有一个实例，并提供一个全局访问点来访问该实例，但是会出现线程安全（采用加锁方法解决）
public class Singleton {
// 私有的静态成员变量，用于保存单例的实例
private static Singleton instance;
// 私有的构造函数，防止外部代码通过new关键字创建该类的实例
private Singleton() {
}
// 公共的静态方法，用于获取单例的实例
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
// 其他业务逻辑方法
public void someMethod() {
System.out.println("Singleton's someMethod");
}
}
// 调用单例模式的实例
public class Client {
public static void main(String[] args) {
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
// 输出 true，说明两个变量指向同一个实例
System.out.println(singleton1 == singleton2);
singleton1.someMethod();
singleton2.someMethod();
}
}
原型模式
通过复制现有的对象来生成新的对象，而无需通过构造函数进行创建，原型模式允许根据需要进行修改
public class Prototype implements Cloneable {
private String name;
public Prototype(String name) {
this.name = name;
}
public String getName() {
return name;
}
@Override
public Prototype clone() throws CloneNotSupportedException{
// 实现对象的浅拷贝
return (Prototype) super.clone();
}
}
// 使用原型模式
public class Client {
public static void main(String[] args) {
Prototype prototype = new Prototype("Prototype");
try {
Prototype clone = prototype.clone();
System.out.println(clone.getName()); // 输出 "Prototype"
// 修改原型对象的属性值
prototype.name = "Modified Prototype";
System.out.println(prototype.getName()); // 输出 "Modified Prototype"
System.out.println(clone.getName()); // 输出 "Prototype"
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}