在Java编程中，创建型模式是一种重要的设计模式，它关注对象的创建过程，通过抽象化和解耦对象的实例化过程，使得系统更加灵活、可扩展和易于维护。本文将详细介绍Java中的创建型模式及其具体实现方式。
一、什么是创建型模式?
创建型模式是设计模式三大分类之一，主要解决对象创建的复杂性问题。它通过将对象的创建逻辑封装在特定的类或方法中，避免直接使用new关键字来创建对象，从而实现代码的解耦和灵活性。这种模式特别适用于以下场景：
系统需要控制对象的创建过程：例如，确保一个类只有一个实例，或者需要动态决定对象的类型。
对象的创建逻辑复杂：例如，需要通过多个步骤逐步构建对象。
需要隐藏对象的创建细节：例如，封装工厂类或抽象工厂类来管理对象的生成。
二、Java中的创建型模式有哪些?
根据不同的需求和使用场景，Java中的创建型模式可以分为以下五种：
1. 单例模式(Singleton Pattern)
单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式适用于需要频繁访问且资源消耗较大的对象，如线程池、配置管理器等。
特点：
线程安全：通过双重检查锁定(Double-Checked Locking)实现线程安全。
隐藏构造函数：不允许外部直接实例化。
提高效率：避免重复创建对象。
实现方式：
public class Singleton {
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;
}
}
运行
优点：
确保全局唯一性。
提高性能。
缺点：
单例对象无法被垃圾回收。
不适合多线程环境下的动态创建。
2. 工厂方法模式(Factory Method Pattern)
工厂方法模式定义一个用于创建对象的接口，但由子类决定实例化哪一个类。这种模式将对象的实例化延迟到子类中完成。
特点：
接口统一：定义一个公共接口，由子类实现具体的创建逻辑。
扩展性强：可以通过扩展子类轻松添加新的产品类型。
实现方式：
// 抽象工厂类
public abstract class AbstractFactory {
public abstract Product createProduct();
}
// 具体工厂类
public class ConcreteFactory1 extends AbstractFactory {
@Override
public Product createProduct() {
return new ProductA();
}
}
// 产品接口
public interface Product {
void use();
}
// 具体产品类
public class ProductA implements Product {
@Override
public void use() {
System.out.println("Using Product A");
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
AbstractFactory factory = new ConcreteFactory1();
Product product = factory.createProduct();
product.use();
}
}
运行
优点：
解耦：客户端无需关心具体产品的创建逻辑。
扩展性好。
缺点：
创建多个相关产品时，工厂类数量较多。
[[Java工厂方法模式示意图]]
3. 抽象工厂模式(Abstract Factory Pattern)
抽象工厂模式提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。
特点：
提供统一的接口：定义一组工厂方法，用于创建一系列相关产品。
解耦：客户端无需了解具体产品的实现细节。
实现方式：
// 抽象工厂接口
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
// 具体工厂类
public class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ProductA1();
}
@Override
public ProductB createProductB() {
return new ProductB1();
}
}
// 产品接口
public interface ProductA {
void use();
}
// 具体产品类
public class ProductA1 implements ProductA {
@Override
public void use() {
System.out.println("Using Product A1");
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
AbstractFactory factory = new ConcreteFactory1();
ProductA productA = factory.createProductA();
productA.use();
}
}
运行
优点：
提供统一的接口，方便扩展。
解耦性强。
缺点：
如果产品种类过多，抽象工厂类会变得复杂。
[[Java抽象工厂模式示意图]]
4. 建造者模式(Builder Pattern)
建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
特点：
分离构建和表示：允许逐步构建复杂对象。
提高可读性和可维护性。
实现方式：
public class Builder {
private String part1;
private String part2;
public Builder() {}
public Builder setPart1(String part1) {
this.part1 = part1;
return this;
}
public Builder setPart2(String part2) {
this.part2 = part2;
return this;
}
public Product build() {
return new Product(part1, part2);
}
}
public class Product {
private String part1;
private String part2;
public Product(String part1, String part2) {
this.part1 = part1;
this.part2 = part2;
}
@Override
public String toString() {
return "Product{" +
"part1='" + part1 + '\'' +
", part2='" + part2 + '\'' +
'}';
}
}
public class Client {
public static void main(String[] args) {
Builder builder = new Builder();
Product product = builder.setPart1("Part1")
.setPart2("Part2")
.build();
System.out.println(product);
}
}
运行
优点：
提高代码可读性。
灵活性强。
缺点：
实现较为复杂。
[[Java建造者模式示意图]]
5. 原型模式(Prototype Pattern)
原型模式通过复制现有的对象来创建新的对象，而不是重新实例化。
特点：
复用现有对象：避免重复创建相同类型的对象。
提高性能。
实现方式：
public class Prototype implements Cloneable {
private String state;
public Prototype(String state) {
this.state = state;
}
public Prototype clone() throws CloneNotSupportedException {
return (Prototype) super.clone();
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
}
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
Prototype prototype = new Prototype("Initial State");
Prototype copyPrototype = (Prototype) prototype.clone();
System.out.println("Original: " + prototype.getState());
System.out.println("Copy: " + copyPrototype.getState());
}
}
运行
优点：
性能高。
简单易用。
缺点：
不适用于复杂对象的复制。
[[Java原型模式示意图]]
Java中的创建型模式主要包括单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。这些模式通过不同的方式解决了对象创建过程中的问题，提高了代码的灵活性和可维护性。开发者可以根据具体需求选择合适的模式来优化系统设计。
