创造型模式

最新推荐文章于 2024-05-06 10:37:06 发布
最新推荐文章于 2024-05-06 10:37:06 发布
阅读量272 收藏
点赞数
分类专栏： 设计模式 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44816731/article/details/129676670
版权

创造型模式

创建模式分成五种模式

  1. 单例模式
  2. 工厂模式
  3. 抽象工厂模式
  4. 建造者模式
  5. 原型模式

设计模式总结前言：

​ 设计模式是软件开发过程中的基础，是针对软件设计过程中经常出现的问题提供一个典型的解决方案。我们可以将之称之为一种固定的问题的特定的解决的方案，软件的设计模式是一种思想，他没有提供一种特定的代码片段，而是提供了一种设计的思想，这些思想能够改变我们的开发思想，以及优化我们的产品，缩短我们在开发中存在的一些问题。

设计模式学习网站：

设计模式

1. 单例模式

前言：

	初开始的时候，会感觉单例模式的主要问题是需要解决多线程的问题，但是在编译期的时候构建对象的方法，需要考虑到类加载的问题，于是饿汉单例模式出现，但是发现线程太多了，会突破单检索模型，后来引入了双检索模型，还有具体的volatile的计划，当然看似进展的没有问题，这时候需要考虑的是人们自身上的问题，反射破坏。

单例模式的要求：

​ 确保一个类只有一个实例，而且自行实例化并且向整个系统提供这个实例。

【重点】：

​ 程序运行的过程中一个类只能够创建一个对象

​ 构造器私有化

​ 调用静态的方法获取对象

【应用场景】
    同时如果创建某个对象需要消耗较多的资源的话，比如IO 或者是数据库资源的时候，我们可以使用单例模式来减少资源的消耗.
    1.windows中的任务管理器、回收站
    2.项目中读取配置文件的类
    3.网站的计数器
    4.Spring中，每一个Bean默认都是单例的
    5.servlet编程中，每一个servlet中都是单例存在的。
    6.Spring MVC 中，控制器都是单例的存在

1.1. 饿汉式

专业：类初始化的时候，会立即记载该对象，线程天生安全，调用率比较高。

理解：不管不顾，上来就new对象

/**
 * @author sky
 * 单例模式：其中最为重要的是两个一个是饿汉模式一个是懒汉模式
 */
public class Sun {

    /**
     * 创建自我独有的单例，自己创建自己
     *  private关键字确保：实例的私有化操作，不可见性和不可访问的特性；
     *  static：确保太阳的静态化操作，将太阳放在内存里的静态区中，在类加载的时候进行了初始化操作，该实例会在内存中和类一起永生
     *  final：确保这个太阳的地址，一旦被赋值就不能够被修改，等同于房产，一旦进行赋值操作就不能再动了
     *  new关键字初始化静态的实例
     * 总结：在初始化的阶段就主动进行实例化操作，犹如饿汉所以就是饿汉模式
     */
    private static final Sun sun = new Sun();

    /**
     * 构造方法私有化操作，将此类进行完全的封印，外界无法通过创建对象的方式访问此类
     */
    private Sun() {
        System.out.println("Sun 对象私有构造方法");
    }


    /**
     *    将方法进行公开化，对于外部来说，只需要调用 Sun.getSun()  就能够得到太阳的对象了，并且不管是是谁得到，或者说得到几次，
     * 得到的都是同一个对象实例，这样就能够确保太阳的唯一合法性操作。
     *
     * @return 阳光普照
     */
    public static Sun getSun() {
        System.out.println("调用Sun方法，实现太阳的东升");
        return sun;
    }

    /**
     * 检验单例模型的饿汉模式
     */
    public static void main(String[] args) {
        Sun sun = Sun.getSun();
        Sun sun1 = Sun.getSun();
        
 		/**
         * 判断sun 和 sun1 是否是同一个对象实例
         */
        if (sun1.equals(sun)) {
            System.out.println("初次判断比较的是地址一致");
        }
      
    }
}
运行结果：
Sun 对象私有构造方法
调用Sun方法，实现太阳的东升
调用Sun方法，实现太阳的东升
初次判断比较的是地址一致

根据结果分析，不管什么情况，上来先创建一个实例对象。

1.2 懒汉式

​ 专业：调用方法时实例化，多线程应用中有安全隐患，防止出现多线程的同步执行，。

​ 解说：饿汉模式的上来就创建对象，容易造成内存浪费。根据市场的供需关系，啥时候需要啥时候生产的模式，规定某些商品必须提前预定，这就是懒汉模式。

初次改造

改动地点：
	// 不在进行赋值的操作，因为第一开始没有创建太阳实例，所以去除关键字final
    
private static Sun sun;
//如果没有太阳，则进行太阳的创造
public static Sun getSun() {
    if (sun == null) {
        sun = new Sun();
    }
    return sun;
}

出现的问题：在多线程的模式下操作，是会存在缺陷的，试想一下如果是并发请求的操作，判空的逻辑就会同时成立，这就会造成创建多个单例模式，这时候我们可以追加上同步锁的概念。这样就会让线程调用的时候必须获取同步锁，调用完成之后会释放锁给其他的线程使用，也就是请求排队。

private static Sun sun; 
public static synchronized Sun getSun() {
        if (sun == null) {
            sun = new Sun();
        }
        return sun;
 }

出现的问题： 线程还没有进入到方法内部，便开始进行加锁排队等候，会造成线程的阻塞，资源与时间进行白白的浪费。我们只是为了进行实例化一个单例对象，所以可以改正加锁的位置。

private static Sun sun;

public static Sun getSun() {
        /**
         * 观日台的入口
         */
        if (sun == null) {
            //观日台进行排队
            synchronized (Sun.class){
                if (sun == null) {
                    // 最头的人造出了太阳，实现太阳的东升操作。
                    sun = new Sun();   
                }
            }
        }
        // 阳光普照，其余的不能够再造太阳
        return sun;
}


总结：在程序中我们使用到了两个嵌套式的判断方式，这就是懒加载中的   双检索  ，外层放宽入口，保证线程并发的高效性；内层加入锁同步，保证实例化的单词运行。

关键字：volatile对于静态变量的修饰则能够保证变量的值在各个线程访问时间的同步性、唯一性。

相比较懒汉模式，在大多数的情况下，我们仍然是采用饿汉模式的操作方法，原因是这个单例迟早是被进行实例化的操作，延迟懒加载的意义并不是特别的大，加锁解锁的方式反而是一种资源的浪费，同步更是会降低CPU的利用效率，大道至简。

单例防止反射漏洞攻击,更改程序段。

private static boolean flag = false;

    /**
     * 构造方法私有化操作，将此类进行完全的封印，外界无法通过创建对象的方式访问此类
     */
    private Sun() {

        if (flag == false){
            flag = !flag;
        }else {
            throw new RuntimeException("单例模式被侵犯");
        }

        System.out.println("Sun 对象私有构造方法");
    }

1.3 单例模式的优点

	1.单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源的时候，如果读取配置，产生其他的依赖对象的时候，则可以通过在应用启动的时候直接产生一个单例对象，然后永久驻留内存的方式来解决。
	2.单例模式可以在系统设置全局访问点，优化共享资源的访问，例如可以设计一个单例类，负责所有数据表的映射处理。

1.4 单例模式的缺点

	1.不适合用于变化的对象，如果同一个类型的对象总是要在不同的用例场景发生变化，单例会引起数据的错误，不能保存彼此的状态
    2.由于单例模式模式中没有抽象层，因此单例类的扩展性有很大的困难。
    3.单例类的职责过于重要， 在一定的程度上违背了 单一职责原则。
    4.滥用单例将带来一些负面的问题，如为了节省资源将数据库连接池对象设计为单例类，可能会导致共享连接对象的程序过多出现的连接池溢出；如果实例化的对象长时间不会被利用，系统会认为是垃圾而被回收操作，这将导致对象状态的丢失。

2.工厂模式

在工厂模式中，我们在创建对象的时候，不会对于客户端暴露创建逻辑，并且通过使用一个共同的接口来指向新创建的对象，实现创建者和调用者分离的操作。

核心：

​ 1.实例化对象不能够使用new，而是通过工厂方法来实现的。

​ 2.将选择实现类，创建对象统一管理和控制，从而调用者跟我们的实现类解耦合

2.1 简单工厂模型

简单工厂模型：相当于工厂中有各种产品，创建在一个类中，客户不需要支持具体的产品的名称，只需要知道产品类所对应的参数即可，但是工厂的职责过重，不利于系统的拓展需要。

  • 创建工厂产品类：
创建汽车类接口
/**
 * @author 法外狂徒张三
 * @package_name:cn.design.Factory
 * @des:创建产品类
 */
public interface Car {
    /**
     * 功能，产品的运行操作,接口中的方法的缺省参数是public static abstract
     */
    public abstract void run();
}
  • 创建工厂的产品一：
通过接口实现,产品一
    
/**
 * @author 法外狂徒张三
 * @package_name:cn.design.Factory
 * @des:
 */
public class BMW implements Car{
    @Override
    public void run() {
        System.out.println("宁愿在宝马车上哭，不愿在自行车上笑");
    }
}
  • 创建工厂的产品二：
创建工厂产品二奔驰商品
/**
 * @author 法外狂徒张三
 * @package_name:cn.design.Factory
 * @des:
 */
public class Benz implements Car{
    @Override
    public void run() {
        System.out.println("宁愿在奔驰车上哭，不愿在自行车上笑");
    }
}
  • 创建核心的工厂类：负责创建对象：
/**
 * @author 法外狂徒张三
 * @package_name:cn.design.Factory
 * @des:创建核心的工厂类
 * 主要的功能：扶着创建生产对象操作
 */
public class CarFactory {
    /**
     * 主要的功能是你告诉我生产什么我生产什么
     */
    /**
     * 根据名字创建对象
     *
     * @param name  需要生产的汽车的名字
     * @return 返回的是生产的对象
     */
    public static Car creatCar(String name){
        if (name.equals("")) {
            return null;
        }else if(name.equals("宝马")){
            return new BMW();
        }else if (name.equals("奔驰")){
            return new Benz();
        }else {
            return null;
        }
    }
}
  • 检测演示操作：
/**
 * @author 法外狂徒张三
 * @package_name:cn.design.Factory
 * @des:
 */
public class Main {
    public static void main(String[] args) {
        Car benz = CarFactory.creatCar("奔驰");
        Car bmw = CarFactory.creatCar("宝马");

        benz.run();
        bmw.run();


    }
}


运行的结果：
宁愿在奔驰车上哭，不愿在自行车上笑
宁愿在宝马车上哭，不愿在自行车上笑
2.1.1 简单工厂的优点

简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪一个具体的对象。明确区分了各自的职责和权力，有利于整个软件的体系结构的优化

2.1.2 简单工厂的缺点

很明显工厂类集中了所有实例的创建逻辑，再进行内容的添加，容易违反开放闭合原则。

2.2 工厂方法模型

标准概念：工厂方法模型：又称为多态性工厂模型。在工厂方法模型中**，核心的工厂不在负责所有的产品的创建，而是将具体创建的工作交给子类去做**。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一种产品类应当被实例化这个细节。

帮助理解：工厂方法的模式实际上是在简单工厂模式的基础之上，将原有的工厂类，进行处理，不在通过工厂类直接创建子类，而是通过封装，将其创建交给接口的实现类进行操作，也就是字面上的子类。当然注意和上述的简单方法的对比。

  • 创建汽车接口
public interface Car {
    void run();
}
  • 宝马汽车运行实现
public class Bmw implements Car{
    @Override
    public void run() {
        System.out.println("宝马车的实现操作");
    }
}
  • 奔驰汽车运行实现
public class Benz implements Car{
    @Override
    public void run() {
        System.out.println("奔驰车的正常运行操作");
    }
}
  • 创建汽车工厂接口
public interface CarFactory {
    /**
     * 创建对象的方法，返回值的类型是Car对象
     * @return
     */
    Car createCar();
}
  • 创建具体奔驰汽车实现类
public class BenzFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new Benz();
    }
}
  • 创建具体宝马汽车实现类
public class BmwFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new Bmw();
    }
}
  • 测试类：根据自己的需求，直接联系对应的汽车工厂
public class MainTest {
    public static void main(String[] args) {
        /**
         * 需要那一辆车，直接找到对应的工厂进行生产操作
         */
        Car car = new BenzFactory().createCar();
        Car car1 = new BmwFactory().createCar();

        car.run();
        car1.run();
    }
}

3.抽象工厂模式

3.1 抽象工厂模式的概念

抽象工厂模式提供了一种可能性，可以将一组具有同一个主题的单独的工厂封装起来 ，抽象工厂简单的来说就是工厂的工厂，抽象工厂可以创建具体的工厂，由具体工厂来产生具体的产品。

3.2 抽象工厂模式的实现

  • 创建Car接口
public interface Car {
    void run();
}
  • 创建宝马汽车实现类
public class Bmw implements Car{

    @Override
    public void run() {
        System.out.println("宝马车运行正常");
    }
}
  • 创建奔驰汽车实现类
public class Beaz implements Car{
    @Override
    public void run() {
        System.out.println("奔驰车正常运行");
    }
}
  • 创建Engine接口
public interface Engine {
    void run();
}
  • 创建引擎一实现类
public class EngineA implements Engine{
    @Override
    public void run() {
        System.out.println("A引擎转的速度比较快");
    }
}
  • 创建引擎二实现类
public class EngineB implements Engine{
    @Override
    public void run() {
        System.out.println("运行速度慢");
    }
}
  • 创建总工厂接口
public interface TotalFactory {
    /**
    * 对于总工厂的实现
    */
    Car creatCar();
  
    Engine creatEngine();
    
}
  • 创建总工厂实现类
public class TotalFactoryImpl implements TotalFactory{
    @Override
    public Car creatCar() {
        return new Beaz();
    }

    @Override
    public Engine creatEngine() {
        return new EngineA();
    }

}
  • 实现类操作
public class Main {
    public static void main(String[] args) {

        /*
         创建总工厂的模式
         */
        TotalFactoryImpl totalFactory = new TotalFactoryImpl();
        /**
         * 创建一个奔驰车，并且进行测试跑动
         */
        Car car = totalFactory.creatCar();
        car.run();
       
        /**
         * 创建引擎一，并且进行引擎的检测
         */
        Engine engine = totalFactory.creatEngine();
        engine.run();

    }
}

运行结果：
        奔驰车正常运行  
        A引擎转的速度比较快

3.3 抽象工厂模式的总结

当定义一个具有相同特性的类的时候，只需要修改工厂类。创建多个工厂类而不是一个工厂类，一旦需要创建新的类对象，只需要增加新的工厂类型就可以了，不需要修改之前的代码，如此就可以较好的解决工厂方法模式的问题。

4.建造者模式

4.1 概述

4.1.1 问题

现在提出一个需求，需要建造一个房子。

abstract class Bulider {
    /**
     * 创建一个房子需要，地基、墙、屋顶、门、窗户
     */

    /**
     * 建造地基
     */
    abstract void buildBase();

    /**
     * 建造墙壁
     */
    abstract void buildWall();

    /**
     * 建造屋顶
     */
    abstract void buildRoof();

    /**
     * 建造屋顶
     */
    abstract void buildDoor();

    /**
     * 建造窗户
     */
    abstract void buildWindow();

    /**
     * 得到产品
     */
    abstract Product getResult();
}
4.1.2解决方案

​ 这里现在有两个解决方法，一种是创建很多不同参数的构造方法（折叠构造函数模式），来满足不同的需求，但是这样灵活性较差；第二种是使用JavaBean，setter方法实例化对象。这里的属性设置是分开的，如果参数过多，很可能会出现遗漏和出错的情况。

4.2 实现
4.2.1 分析

场景分析：

​ 建造者模式建议将对象构造代码从产品中抽取出来，并将其放在一个名为生成器的独立的对象中。

​ 将建造房子拆分，每个部分建造的东西不同，然后组合到一起生成一个完整的部分。

结构的分析：

  • Product`: 最终要生成的对象，例如 House实例。
  • Builder： 构建者的抽象基类（有时会使用接口代替）。其定义了构建Product的抽象步骤，(构建房子的步骤)其实体类需要实现这些步骤。其会包含一个用来返回最终产品的方法Product getProduct()。
  • ConcreteBuilder(具体建造者): Builder的实现类。
  • Director(指导者): 决定如何构建最终产品的算法. 其会包含一个负责组装的方法void Construct(Builder builder)， 在这个方法中通过调用builder的方法，就可以设置builder，等设置完成后，就可以通过builder的 getProduct()方法获得最终的产品。
// 接口
public interface Builder {
    /**
     * 创建一个房子需要，地基、墙、屋顶、门、窗户
     */

    /**
     * 建造地基
     */
    void buildBase();

    /**
     * 建造墙壁
     */
    void buildWall();

    /**
     * 建造屋顶
     */
    void buildRoof();

    /**
     * 建造屋顶
     */
    void buildDoor();

    /**
     * 建造窗户
     */
    void buildWindow();

    /**
     * 创建商品，最终的目的是为了创建商品
     * @return
     */
    Product getResult();
}


//Direct
public class Diretor {
    public void build(Builder builder){
        System.out.println(builder);
        // 给出要求，需要创建的部分
        builder.buildBase();
        builder.buildDoor();
        builder.buildRoof();
        builder.buildWall();
        builder.buildWindow();
    }
}

//Product
public class Product {
    /*
     * 作用是通过创建的部分组成一个完整的商品
     */

    // 创建集合用于内容的拼接操作
    ArrayList<String> list = new ArrayList<>();

    /**
     *  将生产的部分，组装成为一个完整的整体
     *
     * @param part 传入需要生产的东西
     */
    public void add(String part){
        list.add(part);
    }

    /** 将生产的东西展示出来
     *
     */
    public void show(){
        System.out.println("产品生成结束");
        for (String s : list) {
            System.out.println(s);
        }
    }

}

// 建造指定的建造者
public class BuilderFirst implements Builder{

    // 引入商品对象,没有实例化对象，所以存在空指针
    private Product product = new Product();


    @Override
    public void buildBase() {
        product.add("建造地基");
    }

    @Override
    public void buildWall() {
        product.add("建造外墙");
    }

    @Override
    public void buildRoof() {
        product.add("建造屋顶");
    }

    @Override
    public void buildDoor() {
        product.add("建造屋顶");
    }

    @Override
    public void buildWindow() {
        product.add("建造房顶");
    }

    @Override
    public Product getResult() {
        return product;
    }
}


// 测试
public class Test {
    public static void main(String[] args) {

        // 创建指挥者对象
        Diretor diretor = new Diretor();

        //创建需要呈现的对象
        BuilderFirst builderFirst = new BuilderFirst();

        //指挥者使用对象 创建产品
        diretor.build(builderFirst);

        Product result = builderFirst.getResult();
        result.show();

    }
}
4.3 总结
4.3.1 概念

​ 建造者模式是一种创建型的设计模式，也叫做生成器的模式，用户只需要指定需要建造的类型就可以得到该类型对应的产品的实例，不用关心建造的过程细节，实际上就是构建包含多个组件的对象，采用相同的构建过程，创建不同的产品。

4.3.2 优点
  1. 降低耦合性：建造者模式可以将对象的创建与使用分离，降低了对象之间的耦合性，使得系统更加灵活、易于维护和扩展。
  2. 增加可读性：使用建造者模式可以将复杂对象的创建过程分解为多个简单的步骤，使得代码更加清晰、易于理解和维护。
  3. 提高灵活性：通过建造者模式可以使用相同的创建过程来创建不同类型的对象，从而提高了系统的灵活性。
  4. 可以控制对象的创建过程：建造者模式可以控制对象的创建过程，从而可以根据需要对创建过程进行优化和调整，提高对象的性能和质量。
4.3.3 缺点
  1. 建造者模式的实现较为复杂，需要定义多个类和接口，因此增加了系统的复杂性。
  2. 如果对象较为简单，使用建造者模式可能会导致代码冗余，降低代码的可读性和可维护性。
  3. 对象创建过程一旦开始就无法中途取消或修改，因此建造者模式不适用于需要动态调整对象创建过程的场景。
4.3.4 工厂模式和建造者模式的对比
  1. 建造者模式和工厂模式的不同点在于它们解决的问题和实现的方式。
  2. 建造者模式更适用于创建复杂的对象，而工厂模式更适用于创建简单的对象。建造者模式通常需要一个指导者来控制构建过程, 通过设置不同的可选参数，“定制化”创建不同属性的对象。
  3. 工厂模式只需要一个工厂类即可。此外，建造者模式通常会在最终创建对象之前进行多个步骤的处理，而工厂模式直接创建对象。
4.3.5 适用的场景

结构复杂：对象有非常复杂的内部结构，有很多的属性

分离创建和使用：想把复杂对象的创建和使用分离，当创建一个对象需要很多的步骤，适合使用建造者模式，当创建一个对象的时候，只需要一个简单的方法就能够完成，适合使用工厂模式。

5.原型模式

5.1 问题场景

​ prototype 原型模式是用来创建重复的对象，同时能够保证有效的属性，这种类型的设计模式属于对象的创建型设计模式。它提供的是一种创建对象的最佳的方案，这种模式是实现了一个原型的接口，该接口用于创建当前对象的克隆。当创建一个对象的代价比较大的时候，能够采用这种模式，例如一个对象需要在一个高代价的数据库操作之后被创建，我们能够缓存该对象，在下一个请求的时候返回它的克隆，在需要的时候更新数据库，以此来减少数据库的调用。

5.2 场景假设


	针对于原型模式的开发的场景，如同创建一个类，其中定义一定的属性，创建对象，每个对象都需要输入自己的属性值，相当于对于对象中的内容进行重新的输入，就好比写手写简历，大家的简历，格式都是一致的，拿到表格的时候，都需要进行信息的完善。造成的结果就是如果需要创建一个对象的代价比较大的时候，就比较麻烦了。
    


// 代码的验证

/**
 * @author 法外狂徒张三
 *  设计学生类对象
 */
public class Student {
   private Integer id;
   private String name;
   private String address;
   private String company;


    /**
     * 该构造器创建对象的时候，需要的属性分别是 名字，地址，公司
     * 通过需要的属性创建需要的构造器，然后方便创建指定的对象
     * @param name 名称
     * @param address 地址
     * @param company 公司
     */
    public Student(String name, String address, String company) {
        this.name = name;
        this.address = address;
        this.company = company;
    }

    public Student(Integer id, String name, String address, String company) {
        this.id = id;
        this.name = name;
        this.address = address;
        this.company = company;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", company='" + company + '\'' +
                '}';
    }
}


Demo1 验证类的实现

public class Demo1 {
	public static void main(String[] args) {
		Student student = new Student("战三", "中国河南", "中国电力局");
		System.out.println(student);

		Student student1 = new Student("战三1", "中国河南1", "中国电力局1");
		System.out.println(student1);
  }
}

​ 总结：缺点是创建的对象都需要进行指定的信息填写，所以造成很多的不便之处，现在的信息是比较少，但是如果信息比较多的时候，我们将会十分的麻烦。

5.3 原型模式的实现

定义：原型模式，用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。

总结：原型模式实际上就是从一个对象再创建另外一个可以定制的对象，而且不需要知道任何创建的细节。

5.3.1 实现的方式
// 创建Student对象

/**
 * @author 法外狂徒张三
 * 2023/3/17
 *
 * 通过实现接口，进行方法的重写，实现接口中的方法
 */
public class Student implements Cloneable{
    private Integer id;
    private String name;
    private String address;
    private String company;

    /**
     * 根据需要的地址名称创建指定的对象
     * @param address 地址的名称
     */
    public Student(String address) {
        this.address = address;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }

    @Override
    protected Student clone() {
        Student student = null;
        try {
            student = (Student) super.clone();
        } catch (CloneNotSupportedException e){
            System.err.println("克隆出现异常的情况");
        }
        return student;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", company='" + company + '\'' +
                '}';
    }
}


// 验证操作

public class Demo2 {
    @Test
    public void test(){
        Student student = new Student("商海");
        student.setName("张三");

        Student student1 = student.clone();
        student1.setName("李四");

        System.out.println(student);
        System.out.println(student1);
    }
}

// 运行结果
Student{id=null, name='张三', address='商海', company='null'}
Student{id=null, name='李四', address='商海', company='null'}

  • 对比上面的操作的方式，对象增加了实现的接口Colneable ，需要进行重写方法 clone() 方法。

  • 以至于，只要调用指定的方法就能够克隆对象。然后在通过指定的方法，实现对于自定义的对象约束。

  • 一般在初始化的信息不发生改变的情况下，克隆是最好的解决的办法，这样既能够隐藏对象创建的细节，又能够对性能进行更大的提升。等于说不用初始化对象，而是动态地获取对象运行时的状态。

5.4 总结

5.4.1 概念

​ 原型模式：是用来创建重复的对象，同时又能够保证性能，这种类型的设计模式属于创建型设计模式。它提供了一种创建对象的最佳的方式之一。

​ 实现了一个原型的接口，该接口用于创建对象的克隆。当直接创建对象的代价比较大的时候，采用这种模式。例如：一个对象需要在一个高代价的数据库操作之后被创建，我们可以缓存该对象，在下一个请求时，返回它的克隆，在需要的时候更新数据库，以此来减少数据库的调用。

5.4.2 优点
  1. 性能高
  2. 逃避构造函数的约束
5.4.3 缺点
  1. 必须实现Cloneable接口
  2. 配备克隆方法需要对垒的功能进行通盘的考虑，这对于全新的类不是很难，但是对于已经有的类不一定很容易。特别当一个类引用不支持串行化的间接对象，或者引用含有循环的结构的时候。
5.4.4 使用场景
  1. 资源优化的场景
  2. 类初始化消耗非常多的资源，这个资源包括数据、硬件资源等，
  3. 性能和安全要求的场景
  4. 通过new产生一个对象需要非常繁琐的数据准备或者访问的权限，则可以使用原型的模式。
  5. 一个对象多个修改者的场景
  6. 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模型拷贝多个对象供调用者使用。
  7. 在实际的开发中，原型的项目很少单独的出现，一般都是和工厂模式一起出现，通过clone创建爱你一个对象，然后由工厂方法提供给调用者。
樵夫垒码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA设计模式之创造型模式介绍.docx
05-10
JAVA设计模式之创造型模式介绍.docx
软件设计模式-创造型模式
csy547415280的博客
10-26 224
软件设计模式-创造型模式单例模式饿汉式懒汉式工厂模式 关注点：怎样创建对象。 主要特点：将对象的创建与使用分离。 优点：降低系统的耦合度，使用者不需要关注对象的创建细节。 单例模式 角色： 单例类：只能创建一个对象，并提供一种访问其唯一的对象的方式。 访问类：使用单例类。 饿汉式 类加载时就创建实例对象。 静态变量方式 静态代码块方式 枚举方式（线程安全，并只会装载一次） 懒汉式 首次使用时才创建对象。 线程不安全 线程安全（增加Synchronized同步锁） 3.双重检查锁（在
JAVA设计模式--创造型模式--工厂模式
qq_56765408的博客
10-13 206
工厂模式是我们最常用的实例化对象模式，是用工厂方法代替new操作的一种模式。它是创造型模式。工厂模式有三种，简单工厂模式、工厂方法模式和抽象工厂模式。
创造型模式——单例模式
栗筝i的博客
01-22 1693
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 一、介绍 概述：保证一个类仅有一个实例，并提供一个访问它的全局访问点 **适用场景：**当您想控制实例数目，节省系统资源的时候。 实现方式：判断系统是否已经有这个单例，如果有则返回，如果没有则创..
创造型模式——建造者模式
栗筝i的博客
01-23 1684
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。 一、介绍 概述：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示 适用场景： 需要生成的对象具有复杂的内部结构。 需要生成的对象内部属性本身相互依赖。 实现方式：将变与不变分离开。 优点： 建造者独立，易扩展。 便于控制细节风..
【设计模式】创造型模式——工厂方法模式
这里是Mae。
04-06 517
设计模式——工厂方法模式总结。
创造型设计模式
martin-Cao
12-18 399
创造型设计模式总览 单例设计模式 我之前个人理解主要分为两个部分：懒汉式和饿汉式，因此从懒汉和饿汉出发进行分析
创造型模式-＞＞原型模式
weixin_57929476的博客
09-21 45
基本介绍 1）原型模式（Prototype模式）是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象 2）原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节 3）工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象.clone（） 浅拷贝 1)对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。 2)对于数据类型是引用数
创造型模式——工厂模式
栗筝i的博客
01-20 1671
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 一、介绍 概述：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。 适用场景： 类不知道自己要创建哪一个对象 类用它的子类来指定创建哪个对象 客户需要清楚创建了哪一个对象 **实现方式：**返回的也是一..
创造型模式3——工厂模式
qq_44824574的博客
03-10 105
前言 简单工厂模式虽然简单，但存在一个很严重的问题。当系统中需要引入新产品时，由于静态工厂方法通过所传入参数的不同来创建不同的产品，这必定要修改工厂类的源代码，将违背“开闭原则”，如何实现增加新产品而不影响已有代码？工厂方法模式应运而生，下面将介绍第二种工厂模式——工厂方法模式。 背景 日志记录器的设计 Sunny软件公司欲开发一个系统运行日志记录器(Logger)，该记录器可以通过多种途径保存系统的运行日志，如通过文件记录或数据库记录，用户可以通过修改配置文件灵活地更换日志记录方式。在设计各类日志记录器时
JAVA设计模式之创造型模式介绍.pdf
05-30
JAVA设计模式之创造型模式介绍.pdf
JAVA设计模式之创造型模式介绍.doc
09-30
JAVA设计模式之创造型模式介绍.doc
java学习资料-创造型设计模式 
06-16
java学习资料——创造型设计模式 ；java学习资料——创造型设计模式 ；java学习资料——创造型设计模式 ；java学习资料——创造型设计模式 ；java学习资料——创造型设计模式 ；
设计模式精解及面试攻略
02-18
第4章讨论创造型模式（抽象工厂、工厂方法、生成器、原型和单件模式）；第5章讨论结构型模式（适配器、桥接、组成、装饰、外观、享元和代理模式）；第6章阐释行为模式（职责链、命令、解释器、迭代器、中介者、备忘...
链表刷题集
yajunjiao的专栏
04-30 904
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
《设计一款蓝牙热敏打印机》
最新发布
唐顺才的博客
05-06 184
安卓apk用java + kotlin编写、上位机用Qt编写。主控芯片用易兆威蓝牙ic，通讯接口：蓝牙、串口、usb。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 1219
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
Nacos 配置中心实例分析实践
m0_73557631的博客
05-03 1016
​ 浏览器: http://localhost:5000/nacos/config/ip。先创建e-commerce-nacos-config-client5000 模块。​ 启动e-commerce-nacos-config-client5000。​ 启动Nacos Server。
向上造型 java
10-16
向上造型（upcasting）是指将一个子类对象赋值给一个父类引用变量的过程。这样做的好处是可以实现多态，即一个对象可以表现出多种形态。在 Java 中，向上造型是自动进行的，无需显式地进行类型转换。 例如，假设有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值