轻松搞定Java大话创建型设计模式，掌握设计之道

2023-04-13 15:25:35

Java 大话：创建型设计模式的终极指南

作为一名 Java 开发人员，了解设计模式至关重要，而创建型模式更是重中之重。本文将带你踏上一段奇妙的旅程，深入探索七大创建型设计模式，助你掌握创建对象和管理复杂结构的艺术。

1. 工厂方法模式：化繁为简

工厂方法模式的魅力在于它将对象创建的具体实现与使用该对象的代码分离，引入一个工厂类来负责创建对象。这种模式让代码变得更易于维护和扩展，轻松应对不同场景下的对象创建需求。

// 工厂类
interface ShapeFactory {
  Shape getShape(String shapeType);
}

// 具体工厂类
class CircleFactory implements ShapeFactory {
  @Override
  public Shape getShape(String shapeType) {
    return new Circle();
  }
}

// 使用工厂方法
ShapeFactory circleFactory = new CircleFactory();
Shape circle = circleFactory.getShape("CIRCLE");

2. 抽象工厂模式：一站式服务

抽象工厂模式更进一步，它提供一个统一的接口来创建一系列相关或相互依赖的对象，而无需指定它们的具体类。通过使用抽象工厂模式，你可以轻松地创建一组具有相同外观和感觉的对象，从而简化代码结构，提升代码的可维护性。

// 抽象工厂类
interface GUIFactory {
  Button createButton();
  CheckBox createCheckBox();
}

// 具体工厂类
class MacGUIFactory implements GUIFactory {
  @Override
  public Button createButton() {
    return new MacButton();
  }

  @Override
  public CheckBox createCheckBox() {
    return new MacCheckBox();
  }
}

// 使用抽象工厂方法
GUIFactory macGUIFactory = new MacGUIFactory();
Button button = macGUIFactory.createButton();
CheckBox checkBox = macGUIFactory.createCheckBox();

3. 单例模式：独一无二

单例模式旨在确保一个类只有一个实例，并提供一个全局访问点来获取该实例。这种模式通常用于管理全局资源、配置信息等，通过使用单例模式，你可以防止创建多个不必要的对象，保证系统资源的合理分配。

// 单例类
public class Singleton {
  private static Singleton instance;

  private Singleton() {}

  public static Singleton getInstance() {
    if (instance == null) {
      instance = new Singleton();
    }
    return instance;
  }
}

// 使用单例方法
Singleton singleton = Singleton.getInstance();

4. 建造者模式：一步一步

建造者模式旨在将一个复杂对象的创建过程分解成一系列独立、易于管理的步骤，通过使用建造者模式，你可以将复杂对象的创建过程抽象化，提高代码的可读性和可维护性。

// 建造者类
class StringBuilder {
  private String value = "";

  public StringBuilder append(String str) {
    value += str;
    return this;
  }

  public StringBuilder reverse() {
    value = new StringBuilder(value).reverse().toString();
    return this;
  }

  @Override
  public String toString() {
    return value;
  }
}

// 使用建造者方法
StringBuilder sb = new StringBuilder();
String reversedString = sb.append("Hello").reverse().toString();

5. 原型模式：克隆有术

原型模式的核心思想是通过克隆一个现有的对象来创建新的对象，这种模式可以极大地提高对象的创建效率，并减少创建新对象的开销。通过使用原型模式，你可以轻松地创建具有相同或相似属性的对象，从而降低代码的复杂度，提高代码的运行效率。

// 原型类
class Person implements Cloneable {
  private String name;
  private int age;

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  @Override
  public Person clone() {
    try {
      return (Person) super.clone();
    } catch (CloneNotSupportedException e) {
      throw new RuntimeException(e);
    }
  }
}

// 使用原型方法
Person person = new Person("John", 30);
Person clone = person.clone();

6. 复合模式：整体与局部

复合模式的精髓在于将一组对象组合成树形结构，从而实现对复杂对象的管理和控制。通过使用复合模式，你可以将复杂的对象分解成更小的、更易于管理的子对象，从而简化代码结构，提高代码的可维护性。

// 组件类
interface Component {
  void operation();
}

// 树叶类
class Leaf implements Component {
  @Override
  public void operation() {
    // 执行叶节点操作
  }
}

// 组合类
class Composite implements Component {
  private List<Component> components;

  public Composite() {
    components = new ArrayList<>();
  }

  public void add(Component component) {
    components.add(component);
  }

  @Override
  public void operation() {
    for (Component component : components) {
      component.operation();
    }
  }
}

// 使用复合模式
Component root = new Composite();
Component leaf1 = new Leaf();
Component leaf2 = new Leaf();
root.add(leaf1);
root.add(leaf2);
root.operation();

7. 桥接模式：解耦精华

桥接模式的思想在于将抽象与实现分离，从而使两者可以独立变化。通过使用桥接模式，你可以轻松地将抽象层与实现层解耦，从而提高代码的可扩展性和可维护性。

// 抽象类
abstract class Abstraction {
  protected Implementor implementor;

  public Abstraction(Implementor implementor) {
    this.implementor = implementor;
  }

  public abstract void operation();
}

// 实现类
interface Implementor {
  void operationImp();
}

// 具体抽象类
class RefinedAbstraction extends Abstraction {
  public RefinedAbstraction(Implementor implementor) {
    super(implementor);
  }

  @Override
  public void operation() {
    implementor.operationImp();
  }
}

// 具体实现类
class ConcreteImplementorA implements Implementor {
  @Override
  public void operationImp() {
    // 具体实现 A
  }
}

// 使用桥接模式
Implementor implementor = new ConcreteImplementorA();
Abstraction abstraction = new RefinedAbstraction(implementor);
abstraction.operation();