Java设计模式精简版总结整理（一）：创建型模式-CSDN博客

本文链接：https://blog.csdn.net/Jiang216/article/details/116015859

一、单例模式

单例模式是指一个类只有一个实例，且该类能自行创建这个实例的一种模式。适合需要频繁创建的类或只要求生成一个对象等情况，如ServletContext 、 ServletContextConfig、Spring 框架应用中的 ApplicationContext、数据库中的连接池等也都是单例模式。

单例模式的关键在于：

类构造方法的私有化：避免类在外部被实例化
线程安全：懒汉式单例需要保证线程安全

public class LazySingleton {
    
    private static volatile LazySingleton instance = null;//保证instance在多线程中同步

    private LazySingleton() {}//避免类在外部被实例化

    //保证方法的线程同步
    public static synchronized LazySingleton getInstance() {
        if(instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }

}

二、原型模式

原型模式是指用一个已经创建的实例作为原型，通过复制该原型对象来创建一个新对象。Java提供了对象的clone方法，因此实现较为简单。

//具体原型类
class Realizetype implements Cloneable {
    Realizetype() {
        System.out.println("具体原型创建成功！");
    }
    public Object clone() throws CloneNotSupportedException {
        System.out.println("具体原型复制成功！");
        return (Realizetype) super.clone();
    }
}
//原型模式的测试类
public class PrototypeTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Realizetype obj1 = new Realizetype();
        Realizetype obj2 = (Realizetype) obj1.clone();
        System.out.println("obj1==obj2?" + (obj1 == obj2));
    }
}

运行结果输出如下：

具体原型创建成功！
具体原型复制成功！
obj1==obj2?false

三、简单工厂模式

工厂模式是指定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类中，满足创建型模式中要求的“创建与使用相分离”的特点。（Spring的IOC即借鉴了工厂模式思想，当然其中Bean默认为单例模式）

我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”。

public class Client {
    //抽象产品
    public interface Product {
        void show();
    }
    //具体产品：ProductA
    static class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }
    //具体产品：ProductB
    static class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }
    final class Const {
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
    }
    static class SimpleFactory {
        public static Product makeProduct(int kind) {
            switch (kind) {
                case Const.PRODUCT_A:
                    return new ConcreteProduct1();
                case Const.PRODUCT_B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }
}

四、工厂方法模式

工厂方法模式是对简单工厂模式的进一步抽象化，其好处是可以让系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

工厂方法应用场景包括：

客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
客户不关心创建产品的细节，只关心产品的品牌

工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品4个要素构成

//抽象产品：提供了产品的接口
interface Product {
    public void show();
}
//具体产品1：实现抽象产品中的抽象方法
class ConcreteProduct1 implements Product {
    public void show() {
        System.out.println("具体产品1显示...");
    }
}
//具体产品2：实现抽象产品中的抽象方法
class ConcreteProduct2 implements Product {
    public void show() {
        System.out.println("具体产品2显示...");
    }
}
//抽象工厂：提供了厂品的生成方法
interface AbstractFactory {
    public Product newProduct();
}
//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("具体工厂1生成-->具体产品1...");
        return new ConcreteProduct1();
    }
}
//具体工厂2：实现了厂品的生成方法
class ConcreteFactory2 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("具体工厂2生成-->具体产品2...");
        return new ConcreteProduct2();
    }
}

五、抽象工厂模式

前面工厂方法模式中考虑的是一类产品的生产，而抽象工厂模式考虑的是多类产品的生产。

抽象工厂模式是指为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无需指定所要产品的具体类就能得到多个等级产品的设计模式。

使用抽象工厂模式一般要满足以下条件。

系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
系统一次只可能消费其中某一族产品，即同族的产品一起使用。

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。

//抽象工厂：提供产品的生成方法
interface AbstractFactory {
    public Product1 newProduct1();
    public Product2 newProduct2();
}
//具体工厂：实现产品的生成方法
class ConcreteFactory1 implements AbstractFactory {
    public Product1 newProduct1() {
        System.out.println("具体工厂 1 生成-->具体产品 11...");
        return new ConcreteProduct11();
    }
    public Product2 newProduct2() {
        System.out.println("具体工厂 1 生成-->具体产品 21...");
        return new ConcreteProduct21();
    }
}

六、建造者模式

当需要创建的对象较为复杂，内部属性较多时，前面的工厂模式就不再适合，而建造者模式则可以较好地描述该类产品的创建。

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

建造者模式由产品、抽象建造者、具体建造者、指挥者等4个要素构成。

//产品类：包括多个组成部件的复杂对象
class Product {
    private String partA;
    private String partB;
    private String partC;
    public void setPartA(String partA) {
        this.partA = partA;
    }
    public void setPartB(String partB) {
        this.partB = partB;
    }
    public void setPartC(String partC) {
        this.partC = partC;
    }
    public void show() {
        //显示产品的特性
    }
}
//抽象建造者：包含创建产品各个子部件的抽象方法
abstract class Builder {
    //创建产品对象
    protected Product product = new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    //返回产品对象
    public Product getResult() {
        return product;
    }
}
//具体建造者：实现了抽象建造者接口
public class ConcreteBuilder extends Builder {
    public void buildPartA() {
        product.setPartA("建造 PartA");
    }
    public void buildPartB() {
        product.setPartB("建造 PartB");
    }
    public void buildPartC() {
        product.setPartC("建造 PartC");
    }
}
//指挥者：调用建造者中的方法完成复杂对象的创建
class Director {
    private Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }
    //产品构建与组装方法
    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}
//客户类：调用指挥者执行对象创建
public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        Product product = director.construct();
        product.show();
    }
}

本文主要参考：http://c.biancheng.net/