创建型模式主要解决对象创建过程中的复杂性。通过这些模式，可以灵活地控制对象的实例化，避免系统中硬编码的实例化逻辑。每种模式都适用于不同的场景，并且可以根据项目需求选择合适的模式来解耦系统，提高代码的可维护性和扩展性。
1. 单例模式 (Singleton Pattern)
确保某个类只有一个实例，并提供全局访问点。单例模式通常用于控制共享资源，如数据库连接池、配置管理等。
实现方式
私有化构造函数，防止外部创建多个实例。
提供一个静态方法来获取实例。
使用双重锁定检查（
Double-Checked Locking）来确保线程安全。
Java实现
public class Singleton {
// 使用 volatile 确保多线程环境下的正确性
private static volatile Singleton instance;
// 私有构造函数，防止外部实例化
private Singleton() {}
// 获取实例的方法，采用双重检查锁定的方式保证线程安全
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
// 示例方法
public void showMessage() {
System.out.println("Hello from Singleton!");
}
public static void main(String[] args) {
Singleton singleton = Singleton.getInstance();
singleton.showMessage(); // 输出: Hello from Singleton!
}
}
getInstance()方法是双重锁定检查，它确保在多线程环境下只会创建一个实例。使用
volatile关键字，避免在构造实例时出现问题，确保实例的可见性。
2. 工厂方法模式 (Factory Method Pattern)
定义一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法让类的实例化延迟到子类中实现。
实现方式
定义一个抽象工厂接口，具体工厂类来实现创建不同类型对象的方法。
Java实现
// 产品接口
interface Product {
void create();
}
// 具体产品类A
class ConcreteProductA implements Product {
public void create() {
System.out.println("ConcreteProductA created");
}
}
// 具体产品类B
class ConcreteProductB implements Product {
public void create() {
System.out.println("ConcreteProductB created");
}
}
// 抽象工厂
abstract class Creator {
public abstract Product factoryMethod();
}
// 具体工厂类A
class ConcreteCreatorA extends Creator {
public Product factoryMethod() {
return new ConcreteProductA();
}
}
// 具体工厂类B
class ConcreteCreatorB extends Creator {
public Product factoryMethod() {
return new ConcreteProductB();
}
}
public class FactoryMethodDemo {
public static void main(String[] args) {
Creator creatorA = new ConcreteCreatorA();
Product productA = creatorA.factoryMethod();
productA.create(); // 输出: ConcreteProductA created
Creator creatorB = new ConcreteCreatorB();
Product productB = creatorB.factoryMethod();
productB.create(); // 输出: ConcreteProductB created
}
}
Creator 类是抽象的，提供了
factoryMethod()方法，子类实现该方法来返回不同的产品对象。ConcreteCreatorA 和 ConcreteCreatorB 实现了具体的工厂方法，返回不同的产品实例。
3. 抽象工厂模式 (Abstract Factory Pattern)
提供一个创建一组相关或依赖对象的接口，而无需指定它们的具体类。抽象工厂模式通常用于生产多个系列的产品。
实现方式
定义多个产品系列的接口（每个产品都有对应的工厂接口）。
每个具体工厂实现这些接口，创建系列中的不同产品。
Java实现
// 产品A接口
interface Button {
void render();
}
// 产品B接口
interface Checkbox {
void paint();
}
// 具体产品A：Windows按钮
class WindowsButton implements Button {
public void render() {
System.out.println("Rendering Windows Button");
}
}
// 具体产品B：Windows复选框
class WindowsCheckbox implements Checkbox {
public void paint() {
System.out.println("Painting Windows Checkbox");
}
}
// 具体产品A：Mac按钮
class MacButton implements Button {
public void render() {
System.out.println("Rendering Mac Button");
}
}
// 具体产品B：Mac复选框
class MacCheckbox implements Checkbox {
public void paint() {
System.out.println("Painting Mac Checkbox");
}
}
// 抽象工厂接口
interface GUIFactory {
Button createButton();
Checkbox createCheckbox();
}
// 具体工厂：Windows工厂
class WindowsFactory implements GUIFactory {
public Button createButton() {
return new WindowsButton();
}
public Checkbox createCheckbox() {
return new WindowsCheckbox();
}
}
// 具体工厂：Mac工厂
class MacFactory implements GUIFactory {
public Button createButton() {
return new MacButton();
}
public Checkbox createCheckbox() {
return new MacCheckbox();
}
}
public class AbstractFactoryDemo {
public static void main(String[] args) {
GUIFactory factory = new WindowsFactory();
Button button = factory.createButton();
Checkbox checkbox = factory.createCheckbox();
button.render(); // 输出: Rendering Windows Button
checkbox.paint(); // 输出: Painting Windows Checkbox
}
}
GUIFactory 是抽象工厂接口，定义了创建相关产品的方法。
WindowsFactory 和 MacFactory 是具体工厂，实现了创建不同平台的按钮和复选框。
4. 建造者模式 (Builder Pattern)
将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。建造者模式可以用于构建复杂的对象，它通常涉及多个步骤。
实现方式
使用Builder 来分步创建复杂对象，每个步骤有专门的方法来构建对象的不同部分。
Java实现
// 产品类
class Product {
private String part1;
private String part2;
public void setPart1(String part1) {
this.part1 = part1;
}
public void setPart2(String part2) {
this.part2 = part2;
}
@Override
public String toString() {
return "Product [part1=" + part1 + ", part2=" + part2 + "]";
}
}
// 抽象建造者
abstract class Builder {
protected Product product = new Product();
public abstract void buildPart1();
public abstract void buildPart2();
public abstract Product getResult();
}
// 具体建造者
class ConcreteBuilder extends Builder {
public void buildPart1() {
product.setPart1("Part 1");
}
public void buildPart2() {
product.setPart2("Part 2");
}
public Product getResult() {
return product;
}
}
// 指导者
class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public Product construct() {
builder.buildPart1();
builder.buildPart2();
return builder.getResult();
}
}
public class BuilderDemo {
public static void main(String[] args) {
Builder builder = new ConcreteBuilder();
Director director = new Director(builder);
Product product = director.construct();
System.out.println(product); // 输出: Product [part1=Part 1, part2=Part 2]
}
}
Builder 是抽象建造者类，提供构建不同部分的抽象方法。
ConcreteBuilder 实现了这些方法，逐步构建产品对象。
Director 控制构建过程，它依赖于具体的 Builder 来构建完整的产品。
5. 原型模式 (Prototype Pattern)
通过复制现有对象来创建新对象，而不是通过构造器创建对象。适用于创建多个相似对象的场景，避免重复的构建过程。
实现方式
定义一个原型接口，包含一个克隆方法。
具体类实现这个接口，并提供自己的克隆实现。
Java实现
// 原型接口
interface Prototype {
Prototype clone();
}
// 具体原型类
class ConcretePrototype implements Prototype {
private String name;
public ConcretePrototype(String name) {
this.name = name;
}
public Prototype clone() {
return new ConcretePrototype(this.name);
}
public String getName() {
return name;
}
}
public class PrototypeDemo {
public static void main(String[] args) {
ConcretePrototype prototype1 = new ConcretePrototype("Prototype 1");
ConcretePrototype clonedPrototype = (ConcretePrototype) prototype1.clone();
System.out.println(prototype1.getName()); // 输出: Prototype 1
System.out.println(clonedPrototype.getName()); // 输出: Prototype 1
}
}
Prototype 是原型接口，定义了
clone()方法用于复制对象。ConcretePrototype 实现了
clone()方法，返回新的对象实例。