设计模式 (二) 创建型设计模式系列

目录

1.单例模式

2.工厂模式

3.抽象工厂模式

4.建造者模式

5.原型模式

---

创建型设计模式是一组用于处理对象创建的模式，包括单例模式、工厂模式、抽象工厂模式、建造者模式和原型模式。在这个系列中，我们将介绍这些模式的使用方法和实例。

1.单例模式

单例模式确保一个类只有一个实例，并提供全局访问点。这种模式通常用于控制资源的访问，例如数据库连接池、线程池等。单例模式的实现方式有多种，最常见的是饿汉式和懒汉式。饿汉式在类加载时就创建实例，懒汉式在第一次使用时才创建实例。

下面是一个饿汉式的单例模式实现：

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

2.工厂模式

工厂模式定义一个用于创建对象的接口，让子类决定实例化哪个类。这种模式通常用于创建复杂对象或者对象的创建过程需要根据条件动态确定的情况。

工厂模式有三种实现方式：简单工厂模式、工厂方法模式和抽象工厂模式。其中，简单工厂模式是最简单的一种实现方式，工厂方法模式和抽象工厂模式则更加灵活和扩展性强。

下面是一个简单工厂模式的实现：

public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("Invalid product type: " + type);
        }
    }
}

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");
    }
}

3.抽象工厂模式

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。这种模式通常用于创建一组相互依赖的对象，例如 GUI 工具包中的组件。

抽象工厂模式的实现方式比较简单，只需要定义一个抽象工厂接口和一组抽象产品接口，然后让具体工厂实现抽象工厂接口，具体产品实现抽象产品接口即可。

下面是一个抽象工厂模式的实现：

public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

public interface ProductA {
    void use();
}

public interface ProductB {
    void eat();
}

public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

public class ConcreteProductA1 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using product A1");
    }
}

public class ConcreteProductA2 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using product A2");
    }
}

public class ConcreteProductB1 implements ProductB {
    @Override
    public void eat() {
        System.out.println("Eating product B1");
    }
}

public class ConcreteProductB2 implements ProductB {
    @Override
    public void eat() {
        System.out.println("Eating product B2");
    }
}

4.建造者模式

建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。这种模式通常用于创建复杂对象，例如汽车、电脑等。

建造者模式的实现方式比较灵活，可以使用链式调用、Builder 模式等方式实现。下面是一个使用链式调用的建造者模式实现：

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

    public Product(Builder builder) {
        this.partA = builder.partA;
        this.partB = builder.partB;
        this.partC = builder.partC;
    }

    public String getPartA() {
        return partA;
    }

    public String getPartB() {
        return partB;
    }

    public String getPartC() {
        return 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 Product build() {
            return new Product(this);
        }
    }
}

使用方法如下：

Product product = new Product.Builder()
    .setPartA("partA")
    .setPartB("partB")
    .setPartC("partC")
    .build();

5.原型模式

原型模式通过复制现有的实例来创建新的实例。这种模式通常用于创建成本较高的对象，例如数据库连接、线程等。

原型模式的实现方式比较简单，只需要让对象实现 Cloneable 接口，并重写 clone() 方法即可。

下面是一个原型模式的实现：

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();
    }
}

使用方法如下：

Prototype prototype1 = new Prototype("prototype1");
Prototype prototype2 = prototype1.clone();

以上就是创建型设计模式系列的内容，希望能够帮助你更好地理解创建型设计模式的使用方法和实例。