设计模式：03-原型模式 / 建造者模式(生成器模式)

最新推荐文章于 2024-04-27 08:50:14 发布
最新推荐文章于 2024-04-27 08:50:14 发布
阅读量453 收藏
点赞数
分类专栏： 设计模式 文章标签： 原型模式 建造者模式(生成器模式)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinglongsource/article/details/103118556
版权

文章目录

本篇博客主要是学习 韩顺平_Java设计模式 做一个学习笔记使用

5. 原型模式

基本介绍

  1. 原型模式(Prototype 模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
  2. 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
  3. 工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它 们自己来实施创建，即 对象.clone()
  4. 形象的理解：孙大圣拔出猴毛， 变出其它孙大圣

5.1. 问题的引入

/**
 * @author houyu
 * @createTime 2019/11/18 20:38
 */
public class Demo1 {

    /**
     * 定义个类 Person
     */
    public static class Person {
        private int age;
        private String name;

        public Person(int age, String name) {
            this.age = age;
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public String getName() {
            return name;
        }
        @Override
        public String toString() {
            final StringBuilder sb = new StringBuilder("Person{");
            sb.append("age=").append(age);
            sb.append(", name='").append(name).append('\'');
            sb.append('}');
            return sb.toString();
        }
    }

    public static void main(String[] args) {
        // 问题的引入:
        // 需要拷贝 Person 5份
        Person original = new Person(10, "tom");
        //
        Person person1 = new Person(original.getAge(), original.getName());
        Person person2 = new Person(original.getAge(), original.getName());
        Person person3 = new Person(original.getAge(), original.getName());
        Person person4 = new Person(original.getAge(), original.getName());
        Person person5 = new Person(original.getAge(), original.getName());
        //
        System.out.println(person1);
        System.out.println(person2);
        System.out.println(person3);
        System.out.println(person4);
        System.out.println(person5);
        /**
         * 分析问题:
         * 传统的方式的优缺点
         *
         * 1) 优点是比较好理解，简单易操作。
         * 2) 在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低
         * 3) 总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活
         * 4) 改进的思路分析
         */
    }
}

5.2 原型模式的浅拷贝

使用默认的原型模式实现的是对象的浅拷贝
什么是浅拷贝?
这个对象的类属性, 如果是基本类型 boolean int long double float char byte short 等类似会进行值传递, 如果是String(final) 也会> 进行值传递
如果是引用类型, 那就就引用拷贝, 比如 List Map Array(int[]…)

  1. 实现接口 implements Cloneable
  2. 重写方法: @Override protected Object clone(){}
  3. 调用端调用clone()即可

代码

import java.util.Arrays;

/**
 * @author houyu
 * @createTime 2019/11/18 20:38
 */
public class Demo2 {

    /**
     * 定义个类 Person
     */
    public static class Person implements Cloneable {
        private int age;
        private String name;
        private int[] array = {1, 2};

        public Person(int age, String name) {
            this.age = age;
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public String getName() {
            return name;
        }
        public int[] getArray() {
            return array;
        }

        @Override
        public String toString() {
            final StringBuilder sb = new StringBuilder("Person{");
            sb.append("age=").append(age);
            sb.append(", name='").append(name).append('\'');
            sb.append(", array=").append(Arrays.toString(array));
            sb.append('}');
            return sb.toString();
        }

        @Override
        protected Object clone() {
            try {
                return super.clone();
            } catch(CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }
    }

    public static void main(String[] args) {
        // 问题的引入:
        // 需要拷贝 Person 5份
        Person original = new Person(10, "tom");
        //
        Person person1 = (Person) original.clone();
        Person person2 = (Person) original.clone();
        Person person3 = (Person) original.clone();
        Person person4 = (Person) original.clone();
        Person person5 = (Person) original.clone();
        //
        System.out.println(person1 == original);
        System.out.println(person2 == original);
        System.out.println(person3.getArray() == original.getArray());
        System.out.println(person4);
        System.out.println(person5);
        /*
         * false
         * false
         * true
         * Person{age=10, name='tom', array=[1, 2]}
         * Person{age=10, name='tom', array=[1, 2]}
         */
        //
        /**
         * 注意点:
         *
         * 1. 使用默认的原型模式实现的是对象的浅拷贝
         *
         * 什么是浅拷贝?
         * 这个对象的类属性, 如果是基本类型 boolean int long double float char byte short 等类似会进行值传递, 如果是String(final) 也会进行值传递
         *
         * 如果是引用类型, 那就就引用拷贝, 比如 List Map Array(int[]...)
         *
         */
    }
}

5.3 重写默认原型模式实现深拷贝

注意点：

  • 使用默认的原型模式close，会导致引用类型没有深拷贝，引用是同一个，因此可能会导致其他问题，如：线程安全等。。。
  • 改进方案1(不推荐)：在原来的clone基础之上，手动一个一个添加引用类型的clone
  • 改进方案2(推荐)：使用流写入写出进行克隆（ObjectOutputStream，ObjectInputStream）
  • 改进方案3(推荐)：使用JSON序列化工具进行克隆（fastjson，gson，jackson…）
  1. 实现接口 implements Cloneable, Serializable
  2. 重写方法: @Override protected Object clone(){}，使用 ObjectOutputStream ObjectInputStream 实现
  3. 调用端调用clone()即可
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Arrays;

/**
 * @author houyu
 * @createTime 2019/11/18 20:38
 */
public class Demo3 {

    /**
     * 定义个类 Person
     */
    public static class Person implements Cloneable, Serializable {
        private int age;
        private String name;
        private int[] array = {1, 2};

        public Person(int age, String name) {
            this.age = age;
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public String getName() {
            return name;
        }
        public int[] getArray() {
            return array;
        }

        @Override
        public String toString() {
            final StringBuilder sb = new StringBuilder("Person{");
            sb.append("age=").append(age);
            sb.append(", name='").append(name).append('\'');
            sb.append(", array=").append(Arrays.toString(array));
            sb.append('}');
            return sb.toString();
        }

        @Override
        protected Object clone() {
            ObjectOutputStream objectOutputStream = null;
            ByteArrayOutputStream byteArrayOutputStream = null;
            ObjectInputStream objectInputStream = null;
            ByteArrayInputStream byteArrayInputStream = null;
            try {
                byteArrayOutputStream = new ByteArrayOutputStream();
                objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
                objectOutputStream.writeObject(this);
                byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
                objectInputStream = new ObjectInputStream(byteArrayInputStream);
                return objectInputStream.readObject();
            } catch(IOException | ClassNotFoundException e) {
                e.printStackTrace();
            } finally {
                close(objectOutputStream, byteArrayOutputStream, objectInputStream, byteArrayInputStream);
            }
            return null;
        }

        private void close(Closeable... closeables) {
            for(Closeable closeable : closeables) {
                if(closeable == null) {
                    continue;
                }
                try { closeable.close(); } catch(IOException e) {}
            }
        }
    }

    public static void main(String[] args) {
        // 问题的引入:
        // 需要拷贝 Person 5份
        Person original = new Person(10, "tom");
        //
        Person person1 = (Person) original.clone();
        Person person2 = (Person) original.clone();
        Person person3 = (Person) original.clone();
        Person person4 = (Person) original.clone();
        Person person5 = (Person) original.clone();
        //
        System.out.println(person1 == original);
        System.out.println(person2 == original);
        System.out.println(person3.getArray() == original.getArray());
        System.out.println(person4);
        System.out.println(person5);
        /*
         * false
         * false
         * true
         * Person{age=10, name='tom', array=[1, 2]}
         * Person{age=10, name='tom', array=[1, 2]}
         */
        //
        /**
         * 注意点:
         *
         * 1. 必须需要实现Serializable
         *
         */
    }
}

5.4 原型模式在 Spring 框架中源码分析(getBean)

// 1.0 org.springframework.context.support.AbstractApplicationContext
public Object getBean(String name) throws BeansException {
	assertBeanFactoryActive();
	return getBeanFactory().getBean(name);
}

// 2.0 org.springframework.beans.factory.support.AbstractBeanFactory
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

// 3.0 org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean()
// Create bean instance.
if (mbd.isSingleton()) {
	sharedInstance = getSingleton(beanName, () -> {
		try {
			return createBean(beanName, mbd, args);
		}
		catch (BeansException ex) {
			// Explicitly remove instance from singleton cache: It might have been put there
			// eagerly by the creation process, to allow for circular reference resolution.
			// Also remove any beans that received a temporary reference to the bean.
			destroySingleton(beanName);
			throw ex;
		}
	});
	bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

else if (mbd.isPrototype()) {
	// It's a prototype -> create a new instance.
	Object prototypeInstance = null;
	try {
		beforePrototypeCreation(beanName);
		prototypeInstance = createBean(beanName, mbd, args);
	}
	finally {
		afterPrototypeCreation(beanName);
	}
	bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}

else {
	String scopeName = mbd.getScope();
	final Scope scope = this.scopes.get(scopeName);
	if (scope == null) {
		throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
	}
	try {
		Object scopedInstance = scope.get(beanName, () -> {
			beforePrototypeCreation(beanName);
			try {
				return createBean(beanName, mbd, args);
			}
			finally {
				afterPrototypeCreation(beanName);
			}
		});
		bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
	}
	catch (IllegalStateException ex) {
		throw new BeanCreationException(beanName,
				"Scope '" + scopeName + "' is not active for the current thread; consider " +
				"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
				ex);
	}
}

6. 建造者模式(生成器模式)

基本介绍

  1. 建造者模式（Builder Pattern） 又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出 来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。
  2. 建造者模式 是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们， 用户不需要知道内部的具体构建细节。

6.1 建造者模式的四个角色

  1. Product（产品角色）： 一个具体的产品对象。
  2. Builder（抽象建造者）： 创建一个 Product 对象的各个部件指定的 接口/抽象类。
  3. ConcreteBuilder（具体建造者）： 实现接口，构建和装配各个部件。
  4. Director（指挥者）： 构建一个使用 Builder 接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作 用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。

建造者模式解决盖房需求应用实例

/**
 * @author houyu
 * @createTime 2019/11/18 20:00
 */
public class Demo1 {

    /**
     * 产品: 房屋
     */
    public static class House {
        private String wall;
        private String houseTop;

        public String getWall() {
            return wall;
        }

        public House setWall(String wall) {
            this.wall = wall;
            return this;
        }

        public String getHouseTop() {
            return houseTop;
        }

        public House setHouseTop(String houseTop) {
            this.houseTop = houseTop;
            return this;
        }

        @Override
        public String toString() {
            final StringBuilder sb = new StringBuilder("House{");
            sb.append(", wall='").append(wall).append('\'');
            sb.append(", houseTop='").append(houseTop).append('\'');
            sb.append('}');
            return sb.toString();
        }
    }

    /**
     * 抽象建造者: 房屋抽象构建者
     *
     * interface / abstract class
     */
    public interface HouseBuilder {
        /**
         * 做墙
         */
        void makeWall();

        /**
         * 做房顶
         */
        void makeHourTop();

        /**
         * 制作完成房子
         */
        House buildHouse();
    }


    /**
     * 具体构建者: 我的房屋构建者
     */
    public static class MyHouseBuilder extends House implements HouseBuilder {
        House house = new House();

        @Override
        public void makeWall() {
            house.setWall("MyHouseBuilder.makeWall");
        }
        @Override
        public void makeHourTop() {
            house.setHouseTop("MyHouseBuilder.makeHourTop");
        }

        @Override
        public House buildHouse() {
            /**
             * 由 具体构建者 进行构建
             */
            makeWall();
            makeHourTop();
            return house;
        }
    }

    /**
     * 指挥者: 我自己
     */
    public static class My {

        private HouseBuilder builder;

        public My setBuilder(HouseBuilder builder) {
            this.builder = builder;
            return this;
        }

        public House build() {
            return builder.buildHouse();
        }
    }

    public static void main(String[] args) {
        // 创建具体构建者
        HouseBuilder builder = new MyHouseBuilder();
        // 创建指挥者
        My my = new My();
        // 给指挥者传递构建者
        my.setBuilder(builder);
        // 指挥者调用构建者的具体流程构建完成返回房子
        House build = my.build();
        // 输出房子
        System.out.println("build.toString() = " + build.toString());
        /**
         * 这个案例的构建者模式是比较标准的, 很明确的存在4个角色
         *
         * 在很多源码中的构建者模式对于这4个角色, 分界比较模糊, 有些类担任双重角色也是有可能的, 如StringBuilder
         * 也有些构建者模式没有完全存在这4个角色, 有的只有三个角色也有可能的...
         */
    }
}

说明:
在很多源码中的构建者模式对于这4个角色, 分界比较模糊, 有些类担任双重角色也是有可能的, 如StringBuilder
也有些构建者模式没有完全存在这4个角色, 有的只有三个角色也有可能的…

6.2 构造者模式在 JDK 框架中源码分析(StringBuilder)

// 产品
public final class String implements java.io.Serializable, Comparable<String>, CharSequence, Constable, ConstantDesc {
}

// 抽象构建者
public interface Appendable {
	// ...
	Appendable append(CharSequence csq) throws IOException;
}

// 具体建造者 (AbstractStringBuilder 实现了 Appendable 接口方法，这里的 AbstractStringBuilder 已经是建造者，只是不能 实例化)
abstract class AbstractStringBuilder implements Appendable, CharSequence {
	// ...
    public AbstractStringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }
}

// StringBuilder 即充当了指挥者角色，同时充当了具体的建造者，建造方法的实现是由 AbstractStringBuilder 完成, 而 StringBuilder 继承了 AbstractStringBuilder
public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, Comparable<StringBuilder>, CharSequence {
	// ...
    public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }
}

6.3 构造者模式在 lombok 中的应用

6.3.1编写实体类

import lombok.Builder;

@Builder
public class Friend {
    private String name;
    private Integer age;
}

6.3.2编写使用类

public class Test {
    public static void main(String[] args) throws Exception {
	    // 下面一行代码充当了 指挥者 和 具体建造者
        Friend friend = Friend.builder().age(10).name("张三").build();
        System.out.println("friend = " + friend);
    }
}

6.3.3反编译 Friend 的构建者

public class Friend {
    private String name;
    private Integer age;

    Friend(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public static Friend.FriendBuilder builder() {
        return new Friend.FriendBuilder();
    }

	// 这里没有抽象构建者, 只有具体构建者, 因此构建者模式不一定说一定要存在4个角色的
    public static class FriendBuilder {
        private String name;
        private Integer age;

        FriendBuilder() {
        }

        public Friend.FriendBuilder name(String name) {
            this.name = name;
            return this;
        }

        public Friend.FriendBuilder age(Integer age) {
            this.age = age;
            return this;
        }

        public Friend build() {
            return new Friend(this.name, this.age);
        }

        public String toString() {
            return "Friend.FriendBuilder(name=" + this.name + ", age=" + this.age + ")";
        }
    }
}

6.4 建造者模式的注意事项和细节

  1. 客户端(使用程序)不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可 以创建不同的产品对象
  2. 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具 体建造者， 用户使用不同的具体建造者即可得到不同的产品对象
  3. 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰， 也更方便使用程序来控制创建过程
  4. 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭 原则”
  5. 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使 用建造者模式，因此其使用范围受到一定的限制。
  6. 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，因 此在这种情况下，要考虑是否选择建造者模式.
  7. 抽象工厂模式 VS 建造者模式
    抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采 用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。而建造者模式则是要求按照指定 的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品
IT加载中
关注
专栏目录
创建型模式：工厂/原型/建造者模式
略
07-11 617
在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。这些工厂只生产同种类产品，同种类产品称为同等级产品，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。纵轴是产品族，也就是同一品牌的产品，同一品牌的产品产自同一个工厂。
原型模式、装饰者模式、建造者模式原理及实例
BaiKnow的博客
02-03 512
原型模式 基本介绍 原型模式(Prototype模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象实例 原型模式是一种创建型设计模式，允许一个对象在创建另外一个可定制的对象时，无需知道如何创建的细节 工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象.clone() 通过克隆的方式创建 需要实现原型模式那么就要在相应的类上实现Cloneable接口，然后重写clone()方法。 实例演
生成器、原型模式——创建型设计模式
amara
04-04 255
生成器 封装一个对象的构造过程，并允许按步骤构造 参考JDK 1.8 源码简易的 StringBuilder 实现： class AbstractStringBuilder { protected: char[] value; int count; public: AbstractStringBuilder(int capacity) { count = 0; val...
【设计模式】单例模式-生成器模式-原型模式
weixin_30340819的博客
10-13 210
前面的几种工厂模式，主要用于选择实现，这里的三种模式：单例模式、生成器模式、原型模式，主要用于生成对象，在GoF的划分中，这是创建型的五种模式（不包括简单工厂，前面提到过，这不是一个标准意义上的设计模式）。 1.单例模式 2.生成器模式 3.原型模式 单例模式（Singleton） 1. 应用场景及问题描述 在大型项目开发中，许多数据要保存在属性文件或数据库里，其中有那么一类数据...
“设计模式”学习之二：单件、原型与生成器模式
vison20080808的专栏
07-24 567
一、单件（Singleton）1、引言C++中如何创建一个唯一的对象或实例？全局变量是一种，更好的替代方式是单件模式。当某系统只能有一个**时，应该想到该模式。比如，系统中只有一个文件系统、打印机。 2、思路图中，_instance用以记录唯一实例；GetInstace()用以返
建造者（Builder）模式
旅行人生
10-13 1138
一、 建造者（Builder）模式建造者模式可以将一个产品的内部表象与产品的生成过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。对象性质的建造有些情况下，一个对象会有一些重要的性质，在它们没有恰当的值之前，对象不能作为一个完整的产品使用。比如，一个电子邮件有发件人地址、收件人地址、主题、内容、附录等部分，而在最起码的收件人地址未被赋值之前，这个电子邮件不能发出。有些情况下，一
一句话说明生成器模式、原型模式和单例模式区别
pangwenyu1989620的博客
12-29 207
前文说了工厂模式和抽象工厂模式区别，接下来再来说说上面这三种设计模式区别，本文感想来源出自于《设计模式之禅》里的各种设计模式概述文章，各位可先翻看原文代码，再来看本人的观点总结，从而加深对设计模式的不同理解，时间宝贵，下面直奔主题咯： 生成器模式本质也是创建一个类似于工具类的创建类builder(工厂类和抽象工厂类是creator),然后统一由这个工具类的builder创建出需要的类，这里与工厂模式和抽象工厂模式不同的是，彼是因类名不同或类的业务逻辑上的差异而创建的工厂类，而此着重是考虑到复杂
设计模式-创建型模式、结构型模式和行为型模式
03-21
4. **建造者模式**： - **简介**：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。 - **应用场景**：当对象的创建步骤较为复杂，或者需要创建多个类似但又略有差异的对象时。 - **...
【资源免费下载】Java代码积累丨大话设计模式（Java实现版本）、线程协作
10-31
建造者模式 单例模式 结构型模式 队列模式 桥接模式 组合模式 装饰模式 外观模式 享元模式 代理模式 行为模式（类行为模式） 解释器模式 模板方法模式 行为模式（对象行为模式） 策略模式 观察者模式 状态模式 导入...
《研磨设计模式》读书笔记之：生成器模式、原型模式
You can either travel or read,but either your body or soul must be on the way.
07-26 327
前言：本篇系看完《研磨设计模式》一书的个人理解和总结，可能存在不正确的地方，看时需要持怀疑态度。另外，所有的图都是示意图，示意，示。 生成器模式（Builder）： 几点解释： 标准的构建器分为 Director和Builder 两个部分。Director中封装了相对固定的构建步骤，而变化的部分封装到具体的 Builder对象中。Director在执行具体的构建步骤时，会在需要的时候从...
设计模式之建造者模式与原型模式
时间静止
08-20 514
单例模式 设计模式总分类创建型模式( 5种 )结构型模式( 7种 )行为型模式( 11种 )建造者模式实质应用场景演示代码原型模式实质应用场景实现方式演示代码 设计模式总分类 创建型模式( 5种 ) 单例模式 工厂模式 抽象工厂模式 建造者模式 原型模式 结构型模式( 7种 ) 适配器模式 桥接模式 装饰模式 组合模式 外观模式 享元模式 代理模式 行为型模式(...
设计模式－－原型模式
为者常成，行者常至
11-13 1623
1.设计模式分类         所谓设计模式，是前人在开发过程中总结的经验。各自有各自的使用情况。分类条件不同 设计模式的分类也不尽相同。编程之道中大致分类如下 创建型 包括 单例设计模式，简单工厂模式，工厂方法模式 抽象工厂模式 原型模式 生成器模式  接口适配型  包括 适配器 桥接 外观对象去耦型 包括 中介者模式 观察者模式抽象集合型 组合模式 迭代器模式 行为扩展型 访问
23种设计模式之创建型模式（单例、工厂方法、抽象工厂、生成器和原型模式）
qq_41469636的博客
06-24 719
概述 设计模式是针对某一类问题的最优解决方案，是从许多优秀的软件系统中总结出的。 Java中设计模式（java design patterns）通常有23种。 模式可以分成3类：创建型、行为型和结构型。 创建型模式 创建型模式涉及对象的实例化，特点是不让用户代码依赖于对象的创建或排列方式，避免用户直接使用new创建对象。 创建型模式有以下5个： 工厂方法模式、抽象工厂方法模式、生成器模式、原型模式和单例模式。 行为型模式 ...
【设计模式学习笔记】建造者模式和原型模式案例详解（C++实现）
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
04-17 402
Bulider Pattern，建造者模式，也叫做生成器模式，是一种对象创建型模式。建造者模式用于创建具有多个部件的复合对象，并隐藏了复合对象的创建过程，不同的部件建造者（Builder生成器）有不同的建造方法。通过建造者模式实现了对象的构建和对象的表示的分离，也就是说，通过同样的构建过程（建造逻辑）可以创建出不同的表示（使用不同的建造者产生不同的建造方式）。
设计模式之——生产者模式（Builder）和原型模式（Prototype）
marken
11-12 1251
在创建型模式里面还有两个就是builder 和 prototype   1 生成器模式 生成者模式和工厂模式有点像，都是封装了创建对象的过程，创建出对象，但builder模式强调一步步创建，不同的输入参数，同样的创建过程而创建出不同的对象，在builder里面，对象一般是比较复杂并由很多对象组成的，每一步创建出其中的一部分；另外创建者模式不像工厂模式一样直接返回对象，而是提供一个接口来得到对
设计模式：单例、原型和生成器
最新发布
choice~的博客
04-27 1213
在我看来，这些模式不如工厂重要。然而，了解它们仍然很有用。我将提供UML描述，简单的java示例（这样即使你不了解java，你也可以理解），并提出来自着名Java框架或API的真实示例。创建模式是处理对象初始化并克服构造函数限制的设计模式。四人帮在他们的书“【设计模式：可重用面向对象软件的元素】中描述了其中的五个：自本书出版（1994年）以来，已经发明了许多创造模式：这种模式是最著名的。在过去的几十年里，它被过度使用，但自那以后它的受欢迎程度有所下降。我个人避免使用它，因为它使代码更难以进行单元测试并创建紧
<html>
weixin_34088583的博客
08-15 122
1：原型模式的本质 原型模式的本质：克隆生成对象。 克隆是手段。目的还是生成新的对象实例。正是由于原型的目的是为了生成新的对象实例。原型模式一般是被归类为创建型的模式。 原型模式也能够用来解决“仅仅知接口而不知实现的问题”，使用原型模式，能够出现一种独特的“接口造接口”的景象，这在面向接口编程中非常实用。相同的功能也能够考虑使用工厂来实现。 另外...
安徽大学软件构造（设计模式）实验集
风华正茂百花洲
01-29 3129
文章目录实验一：工程方法与抽象工厂模式实验题目目录结构实验代码简单工厂工厂方法抽象工厂实验二：生成器模式与原型模式的编程实现实验题目目录结构实验代码实验三：装饰模式的编程实现实验题目目录结构实现代码实验四：组合模式与责任链模式实验题目实验代码实验五：解释器模式实验题目目录结构实验代码大作业一题目项目目录结构实现代码UML图二题目项目目录结构实现代码UML图三题目项目目录结构实现代码UML图 实验一：工程方法与抽象工厂模式 实验题目 利用工厂方法和抽象工厂模式模拟实现服装工厂生产衣服的过程，具体内容如下： 现
Java设计模式详解：生成器模式及其优势
创建型模式包括工厂方法模式、抽象工厂模式、单例模式、建造者模式（生成器模式）和原型模式，它们都关注对象的创建。结构型模式关注如何将类或对象组合成更大的结构，而行为型模式则关注对象之间的交互和责任分配。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值