Java设计模式：创建型模式详解与应用

在软件开发中，设计模式是解决常见问题的经典解决方案。Java作为一门广泛使用的编程语言，其设计模式的应用尤为重要。本文将深入探讨Java中的创建型模式，包括单例模式、工厂模式、抽象工厂模式、建造者模式和原型模式，并展示它们在实际开发中的应用。

Java设计模式：创建型模式详解与应用

单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。其核心在于构造函数的私有化和静态方法获取实例。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

应用场景：数据库连接池、配置管理器等。

工厂模式

工厂模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂模式使对象的创建过程与使用过程分离。

public interface Product {
    void use();
}

public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}

public class Factory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}

应用场景：对象的创建过程复杂或需要根据不同条件创建不同对象时。

抽象工厂模式

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。

public interface AbstractFactory {
    Product createProduct();
    AnotherProduct createAnotherProduct();
}

public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }

    @Override
    public AnotherProduct createAnotherProduct() {
        return new ConcreteAnotherProductA();
    }
}

public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }

    @Override
    public AnotherProduct createAnotherProduct() {
        return new ConcreteAnotherProductB();
    }
}

应用场景：需要创建一系列相关或互相依赖的对象时。

建造者模式

建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

public class ComplexObject {
    private String partA;
    private String partB;
    private String partC;

    private ComplexObject(Builder builder) {
        this.partA = builder.partA;
        this.partB = builder.partB;
        this.partC = builder.partC;
    }

    public static class Builder {
        private String partA;
        private String partB;
        private String partC;

        public Builder setPartA(String partA) {
            this.partA = partA;
            return this;
        }

        public Builder setPartB(String partB) {
            this.partB = partB;
            return this;
        }

        public Builder setPartC(String partC) {
            this.partC = partC;
            return this;
        }

        public ComplexObject build() {
            return new ComplexObject(this);
        }
    }
}

应用场景：对象创建过程复杂，且需要灵活配置时。

原型模式

原型模式通过复制现有的实例来创建新的实例，而不是通过构造函数。

public class Prototype implements Cloneable {
    private String field;

    public Prototype(String field) {
        this.field = field;
    }

    public void setField(String field) {
        this.field = field;
    }

    public String getField() {
        return field;
    }

    @Override
    public Prototype clone() throws CloneNotSupportedException {
        return (Prototype) super.clone();
    }
}

应用场景：对象的创建成本较大，且新对象与现有对象相似时。