设计模式——创建型模型

最新推荐文章于 2022-07-21 17:11:40 发布

zhaohong_bo

最新推荐文章于 2022-07-21 17:11:40 发布

阅读量1.4k

点赞数 1

CC 4.0 BY-SA版权

分类专栏：学习笔记文章标签： Java 创建型模型设计模式

本文链接：https://blog.youkuaiyun.com/zhaohong_bo/article/details/89465109

学习笔记专栏收录该内容

222 篇文章

订阅专栏

本文深入解析了单例模式、构建模式、原型模式、工厂方法模式和抽象工厂模式等五大创建型设计模式，详细介绍了每种模式的实现原理、应用场景及代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

单例模式（singleton）
构建模式（Builder）
原型模式（Prototype）
工厂方法模式（Factory）
抽象工厂模式（Abstract Factory）

一、5种创建型模型

1.1 单例模式（singleton）

简介：
单例模式特别简单，目的是为类创建唯一的对象。
下面是单例模式的一种实现方式（单例模式的5种实现方式见，传送门）：

public class Singleton {    

    private volatile static Singleton singleton = null; //volatile关键字


    private Singleton(){} //私有化构造函数，使其不可继承


    public static Singleton getInstance() {
         if(singleton == null) {
             synchronized (Singleton.class) {
                 if(singleton == null) {//double check，保证效率、安全性
                 singleton = new Singleton();
                 }
             }
         }
         return singleton;
    }
}

1.2 构建模式（Builder）

简介：
将一个复杂对象的构建和表现分离，使得不同的构建过程可以创建不同的表示
类图：

在这里插入图片描述

代码如下：

public class Product {
    /**
     * 定义一些关于产品的操作
     */
    private String part1;
    private String part2;
    public String getPart1() {
        return part1;
    }
    public void setPart1(String part1) {
        this.part1 = part1;
    }
    public String getPart2() {
        return part2;
    }
    public void setPart2(String part2) {
        this.part2 = part2;
    }

}

public interface Builder {
    public void buildPart1();
    public void buildPart2();
    public Product retrieveResult();

}

public class ConcreteBuilder implements Builder {
    private Product product = new Product();
    /**
     * 产品零件建造方法1
     */
    @Override
    public void buildPart1() {
        //构建产品的第一个零件
　　　　product.setPart1("编号：9527");
    }
    /**
     * 产品零件建造方法2
     */
    @Override
    public void buildPart2() {
        //构建产品的第二个零件
　　　　product.setPart2("名称：XXX");
    }
    /**
     * 产品返还方法
     */
    @Override
    public Product retrieveResult() {
        return product;
    }
}

public class Director {
    /**
     * 持有当前需要使用的建造器对象
     */
    private Builder builder;
    /**
     * 构造方法，传入建造器对象
     * @param builder 建造器对象
     */
    public Director(Builder builder){
        this.builder = builder;
    }
    /**
     * 产品构造方法，负责调用各个零件建造方法
     */
    public void construct(){
        builder.buildPart1();
        builder.buildPart2();
    }
}

public class Client {
    public static void main(String[]args){
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        director.construct();
        Product product = builder.retrieveResult();
        System.out.println(product.getPart1());
        System.out.println(product.getPart2());
    }

}

1.3 原型模式（Prototype）

简介：
原型模式要求对象实现一个可以“克隆”自身的接口，这样就可以通过复制一个对象实例来创建新的实例。通过原型来创建对象，就不需要关心实例本身的类型，只要实现了克隆自身的方法，就可以通过这个方法获取新的对象，而无需new
原型模式有两种表现形式：1）简单形式 2）登记形式

类图：

在这里插入图片描述
代码如下：

public interface Prototype{
    public Prototype clone();
    public String getName();
    public void setName(String name);
}

public class ConcretePrototype1 implements Prototype {
    private String name;
    public Prototype clone(){
        ConcretePrototype1 prototype = new ConcretePrototype1();
        prototype.setName(this.name);
        return prototype;
    }
    public String toString(){
        return "Now in Prototype1 , name = " + this.name;
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public void setName(String name) {
        this.name = name;
    }
}

public class ConcretePrototype2 implements Prototype {
    private String name;
    public Prototype clone(){
        ConcretePrototype2 prototype = new ConcretePrototype2();
        prototype.setName(this.name);
        return prototype;
    }
    public String toString(){
        return "Now in Prototype2 , name = " + this.name;
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public void setName(String name) {
        this.name = name;
    }
}

public class PrototypeManager {
    /**
     * 用来记录原型的编号和原型实例的对应关系
     */
    private static Map<String,Prototype> map = new HashMap<String,Prototype>();
    /**
     * 私有化构造方法，避免外部创建实例
     */
    private PrototypeManager(){}
    /**
     * 向原型管理器里面添加或是修改某个原型注册
     * @param prototypeId 原型编号
     * @param prototype    原型实例
     */
    public synchronized static void setPrototype(String prototypeId , Prototype prototype){
        map.put(prototypeId, prototype);
    }
    /**
     * 从原型管理器里面删除某个原型注册
     * @param prototypeId 原型编号
     */
    public synchronized static void removePrototype(String prototypeId){
        map.remove(prototypeId);
    }
    /**
     * 获取某个原型编号对应的原型实例
     * @param prototypeId    原型编号
     * @return    原型编号对应的原型实例
     * @throws Exception    如果原型编号对应的实例不存在，则抛出异常
     */
    public synchronized static Prototype getPrototype(String prototypeId) throws Exception{
        Prototype prototype = map.get(prototypeId);
        if(prototype == null){
            throw new Exception("您希望获取的原型还没有注册或已被销毁");
        }
        return prototype;
    }
}

public class Client {
    public static void main(String[]args){
        try{
            Prototype p1 = new ConcretePrototype1();
            PrototypeManager.setPrototype("p1", p1);
            //获取原型来创建对象
            Prototype p3 = PrototypeManager.getPrototype("p1").clone();
            p3.setName("张三");
            System.out.println("第一个实例：" + p3);
            //有人动态的切换了实现
            Prototype p2 = new ConcretePrototype2();
            PrototypeManager.setPrototype("p1", p2);
            //重新获取原型来创建对象
            Prototype p4 = PrototypeManager.getPrototype("p1").clone();
            p4.setName("李四");
            System.out.println("第二个实例：" + p4);
            //有人注销了这个原型
            PrototypeManager.removePrototype("p1");
            //再次获取原型来创建对象
            Prototype p5 = PrototypeManager.getPrototype("p1").clone();
            p5.setName("王五");
            System.out.println("第三个实例：" + p5);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

1.4 工厂方法模式（Factory）

简介：
工厂方法的用意是定义一个创建对象的工厂接口，将实际创建工作推迟到子类中。

类图：（工厂与抽象工厂）

在这里插入图片描述

代码如下：


interface Product {
	
}

class ProductA implements Product {
	
}

class ProductB implements Product {
	
}

abstract class Factory {
	
	public abstract Product makeProduct();
	
}

class FactoryA extends Factory {

	@Override
	public Product makeProduct() {
		return new ProductA();
	}
	
}

class FactoryB extends Factory {

	@Override
	public Product makeProduct() {
		return new ProductB();
	}
	
}

public class Client {
	
	public static void main(String[] args) {
		Factory factory = new FactoryA();
		Product product = factory.makeProduct();
		//对象为：com.obob.test.ProductA@15db9742
		System.out.println(product);
	}
	
}