设计模式—原型模式(Prototype)

这篇具有很好参考价值的文章主要介绍了设计模式—原型模式(Prototype)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一、什么是原型模式?

二、原型模式具有什么优缺点吗?

三、有什么缺点?

四、什么时候用原型模式?

五、代码展示

①、简历代码初步实现

②、原型模式

③、简历的原型实现

④、深复制

⑤、浅复制

一、什么是原型模式?

用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。

原型模式其实就是从一个对象再创建另外一个可定制的对象,而且不需知道任何创建的细节

简单说就是先创建一个原型类实例,然后通过克隆的方法来复制一个一样的新对象,这个对象和原来的对象相同或相似

设计模式—原型模式(Prototype),设计模式,原型模式,java

核心:通过自带的Clone()方法和ICloneable接口创建跟该对象相同的新对象,不需要知道具体的创建细节。

二、原型模式具有什么优缺点吗?

  • 隐藏对象创建细节,提高性能:一般在初始化的信息不发生变化的情况下,克隆是最好的办法。这既隐藏了对象创建的细节,又对性能是大大的提高。
  • 不用重新初始化对象,而是动态地获得对象运行时的状态;

三、有什么缺点?

  • 根据实际应用需要涉及到深浅复制问题;
  • 每一个类都需要一个Clone方法;
  • Clone方法位于类的内部,当对已有类进行改造的时候,需要修改代码,违背开闭原则;

四、什么时候用原型模式?

  • 同一个类当需要实例化多次的时候;
  • 对象之间相同或相似,即只是个别的几个属性不同的时候;

五、代码展示

场景:小菜最近在找工作,需要复印大量的简历发给求职公司,小菜和大鸟通过复制简历这个事情来谈到了了六七年前和现在复印简历的不同:六七年前:简历一般都是手写,很珍贵;现在:只要有一份简历原版,直接复印就可以了。对于编程来说,直接Ctrl+C和Ctrl+V直接复制代码就可以了,但简单的复制代码有时候也会带来重复代码的灾难的。大鸟要求小菜写一个简历类,里面必须有姓名、性别、年龄、工作经历,最后要求有三份简历。

①、简历代码初步实现

简历类

//简历
class Resume
{
        private string name;         //姓名
        private string sex;          //性别
        private string age;         //年龄
        private string timeArea;        //工作时间
        private string company;         //公司

        public Resume(string name)      //有参的构造方法
        {
            this.name = name;           //赋值
        }

        //设置个人信息
        public void SetPersonalInfo(string sex,string age)
        {
            this.sex = sex;   //赋值
            this.age = age;     //赋值
        }

        //设置工作经历
        public void SetWorkExperience(string timeArea,string company)
        {
            this.timeArea = timeArea;       //赋值
            this.company = company;         //赋值
        }

        //显示
        public void Display()
        {
            Console.WriteLine("{0}{1}{2}", name, sex, age);   //姓名,性别,年龄
            Console.WriteLine("工作经历:{0}{1}", timeArea, company); //工作经历:工作时间,公司
        }
}

客户端调用代码

class Program
{
        static void Main(string[] args)
        {
            #region 第一种方法
            //Resume a = new Resume("大鸟 ");              //实例化简历对象
            //a.SetPersonalInfo("男", "29");               //设置个人信息
            //a.SetWorkExperience("1998-2000 ", "xx公司");   //设置工作经历

            //Resume b = new Resume("大鸟 ");
            //b.SetPersonalInfo("男 ", "29");
            //b.SetWorkExperience("1998-2000 ", "xx公司");

            //Resume c = new Resume("大鸟 ");
            //c.SetPersonalInfo("男 ", "29 ");
            //c.SetWorkExperience("1998-2000 ", "xx公司");                        
            #endregion
                
            缺点:每new一次,都需要执行一次构造函数,如果构造函数的执行时间很长,那么多次的执行这个初始化操作就很低效。
                  三份简历就需要实例化3次,如果是需要20份简历,就需要实例化20次,如果98写成99年,就需要改20次。
                  每次实例化出来的对象都存放在堆内存里面,按照这样的方式实例化对堆内存的消耗就非常大。
            如何改进这个问题呢?可以使用第二种方法,先实例化出来一个对象a,然后把a引用所指向的地址赋值给b和c,这样在堆内存里面
            
            #region 第二种方法
            Resume a = new Resume("大鸟 ");              //实例化简历对象
            a.SetPersonalInfo("男", "29");               //设置个人信息
            a.SetWorkExperience("1998-2000 ", "xx公司");   //设置工作经历

            Resume b = a;
            Resume c = a;
            #endregion

            a.Display();                //显示
            b.Display();
            c.Display();

            Console.ReadKey();
        }
}

如何解决?Clone克隆

②、原型模式

设计模式—原型模式(Prototype),设计模式,原型模式,java

Prototype类

abstract class Prototype           //抽象原型类
{
        private string id;          //私有的成员变量
        public Prototype(string id) //有参的构造方法
        {
            this.id = id;
        }

        public string Id           //属性
        {
            get { return id; }     //取值
        }

        public abstract Prototype Clone();   //抽象克隆方法
}

ConcretePrototype1

class ConcretePrototype1 : Prototype      //继承原型类
{
       private string id;
        public ConcretePrototype1(string id) : base(id) { }  //重写有参的构造方法
        
        public override Prototype Clone()   //重写原型类抽象方法
        {
            //创建当前对象的浅表副本
            return (Prototype)this.MemberwiseClone();    //返回Prototype类型的克隆对象,括号里的作用是指定要创建的对象种类
        }
} 

设计模式—原型模式(Prototype),设计模式,原型模式,java

设计模式—原型模式(Prototype),设计模式,原型模式,java

③、简历的原型实现

思想

Resume:

  • 记录相关属性、方法、变量
  • Clone()方法

客户端

  1. 实例化一个原型对象
  2. 调用要复制类的Clone()方法进行复制,并返回复制完的对象

方法:创建一个新对象,然后将当前对象的非静态字段复制到该新对象

  (复制类型)this.MemberwiseClone();

  值类型:逐位复制

  引用类型:复制引用但不赋值引用的对象

  1. 可修改简历
  2. 显示

设计模式—原型模式(Prototype),设计模式,原型模式,java

简历类

class Resume:ICloneable
{
        private string name;         //姓名
        private string sex;          //性别
        private string age;          //年龄
        private string timeArea;        //工作时间
        private string company;         //公司

        public Resume(string name)      //有参的构造方法
        {
            this.name = name;           //赋值
        }

        //设置个人信息
        public void SetPersonalInfo(string sex, string age)
        {
            this.sex = sex;   //赋值
            this.age = age;     //赋值
        }

        //设置工作经历
        public void SetWorkExperience(string timeArea, string company)
        {
            this.timeArea = timeArea;       //赋值
            this.company = company;         //赋值
        }

        //显示
        public void Display()               //实现接口的方法,用来克隆对象
        {
            Console.WriteLine("{0}{1}{2}", name, sex, age);   //姓名,性别,年龄
            Console.WriteLine("工作经历:{0}{1}", timeArea, company); //工作经历:工作时间,公司
        }

        public Object  Clone()      //克隆的方法
        {
            return (Object)this.MemberwiseClone();
        }
}

客户端

static void Main(string[] args)
{
            Resume a = new Resume("大鸟");       //实例化简历类,调用Resume类有参的构造方法
            a.SetPersonalInfo("男", "29");       //调用SetPersonalInfo方法,并传值
            a.SetWorkExperience("1998-2000", "xx公司"); //调用SetWorkExperience方法,并传值

            //调用Clone方法,实现新简历的生成,并且可以再修改新简历的细节
            Resume b = (Resume)a.Clone();         //克隆a对象,并赋值给简历对象b,此时a和b一样
            b.SetWorkExperience("1998-2006", "yy公司");       //b对象可以修改自己简历的细节

            Resume c = (Resume)a.Clone();          //克隆a对象给简历对象c
            c.SetPersonalInfo("男", "24");         //c对象可以修改自己简历的细节

            a.Display();       //显示简历a
            b.Display();       //显示简历a
            c.Display();       //显示简历a

            Console.ReadKey();  //等待用户按下某键退出
}

设计模式—原型模式(Prototype),设计模式,原型模式,java

问题:‘简历’对象里的数据都是string类型的,如果类当中有对象引用,那么引用的对象数据是不会被克隆过来的。

④、深复制

设计模式—原型模式(Prototype),设计模式,原型模式,java

WorkExperience类

//工作经历类
class WorkExperience : ICloneable
{
        private string workDate;
        public string WorkDate
        {
            get { return workDate; }
            set { workDate = value; }
        }

        private string company;
        public string Company
        {
            get { return company; }
            set { company = value; }
        }

        public Object Clone()       //让“工作经历”类实现克隆方法
        {
            return (Object)this.MemberwiseClone();
        }
}

Resume类

// 简历类
class Resume:ICloneable
{
        private string name;
        private string age;
        private string sex;
        private WorkExperience work;

        public Resume (string name)     //有参的构造方法
        {
            this.name = name;           //赋值姓名
            work = new WorkExperience();  //在“简历”类实例化时同时实例化“工作经历”
        }

        //提供Clone方法调用的私有构造函数,以便克隆“工作经历”的数据
        private Resume(WorkExperience work)
        {
            this.work = (WorkExperience)work.Clone();
        }
        public  void SetPersonalInfo(string sex,string age)   //设置个人信息
        {
            this.sex = sex;   //赋值性别
            this.age = age;   //赋值年龄
        }

        public void SetWorkExperience (string workDate,string company)  //设置工作经历
        {
            work.WorkDate = workDate;   //赋值工作时间
            work.Company = company;     //赋值公司
        }

        public void Display()           //显示
        {
            Console.WriteLine("{0} {1} {2}", name, sex, age);
            Console.WriteLine("工作经历:{0}{1}", work.WorkDate, work.Company);
        }
        public Object Clone()         //克隆方法
        {
            //调用私有的构造方法,让“工作经历”克隆完成,
            //然后再给这个“简历”对象的相关字段赋值,
            //最终返回一个深复制的简历对象
            Resume obj = new Resume(this.work);
            obj.name = this.name;
            obj.sex = this.sex;
            obj.age = this.age;
            return obj;
        }
}

设计模式—原型模式(Prototype),设计模式,原型模式,java

⑤、浅复制

设计模式—原型模式(Prototype),设计模式,原型模式,java

WorkExperience类

//工作经历
class WorkExperience
{
        private string workDate;    //字段:时间区间
        public string WorkDate     //属性:时间区间
        {
            get { return workDate; }        //读
            set { workDate = value; }       //写
        }

        private string company;    //字段:公司
        public string Company     //属性:公司
        {
            get { return company; }       //读
            set { company = value; }      //写
        }
}

Resume类

class Resume
{
        private string name;     //姓名
        private string sex;      //性别
        private string age;      //年龄        
        private WorkExperience work;    //工作经历

        public Resume(string name)   //构造方法
        {
            this.name = name;    //赋值姓名
            work = new WorkExperience(); //在“简历”类实例化时同时实例化“工作经历”
        }

        public void SetPersonalInfo(string sex, string age) //设置个人信息
        {
            this.sex = sex; //赋值性别
            this.age = age; //赋值年龄
        }

        public void SetWorkExperience(string workDate, string company) //设置工作经历
        {
            work.WorkDate=workDate; //赋值工作时间
            work.Company=company;    //赋值公司
        }

        public void Display()           //显示
        {
            Console.WriteLine("{0} {1} {2}", name, sex, age);         //输出姓名,性别,年龄
            Console.WriteLine("工作经历:{0}{1}", work.WorkDate, work.Company); //输出工作经历:工作时间,公司
        }

        public Object Clone()       //克隆
        {
            return (Object)this.MemberwiseClone();  //返回Object类型的克隆对象
        }
}

客户端程序代码

Resume a = new Resume("大鸟");    //实例化一个叫大鸟的简历对象,调用有参构造方法
a.SetPersonalInfo("男", "29");    //调用方法,赋值性别,年龄
a.SetWorkExperience("1998-2000", "xx公司");   //调用方法,赋值工作时间,公司

Resume b = (Resume)a.Clone();       //克隆对象a给b
b.SetWorkExperience("1998-2006", "yy公司"); //修改细节
//b和c都克隆于a,但当它们都设置了“工作经历”时,我们希望的结果是三个的显示不一样

Resume c = (Resume)a.Clone();        //克隆对象a 给c
c.SetPersonalInfo("男", "24");       //调用方法,赋值性别,年龄
c.SetWorkExperience("1998-2003", "zz公司");   //修改细节
                
a.Display();        //显示简历a
b.Display();        //显示简历b   
c.Display();        //显示简历c

Console.ReadKey();

它在内存里面的形式是这样的。

设计模式—原型模式(Prototype),设计模式,原型模式,java


六、涉及到的知识点

1、一个类里面有哪些东西?

设计模式—原型模式(Prototype),设计模式,原型模式,java

2、类和实例

什么是类?

就是具有相同的属性和功能的对象的抽象的集合。注意:

  • 类名称首字母大写。多个单词则各个首字母大写;
  • 对外公开的方法需要用‘public’修饰符。

什么是实例?

就是一个真实的对象。比如我们都是‘人’,而你和我其实就是‘人’类的实例了。

什么是实例化?

创建对象的过程,使用new关键字来创建。

Cat cat = new Cat();     //其实做了两件事情

Cat cat;          //第一步、声明一个Cat的对象,对象名为cat
cat = new Cat();  //第二步、将此cat对象实例化

3、字段和属性

什么是字段?

是存储类要满足其设计所需要的数据,字段是与类相关的变量。

private  string  name = "";     //name就是一个字段,私有的类变量

注意

  • 如果在定义字段时,在字段的类型前面使用了readonly关键字,那么字段就为只读字段,它只能在以下两个位置被赋值或者传递到方法中被改变。
  • 在定义字段时赋值;
  • 在类的构造函数内被赋值,或传递到方法中被改变,而且在构造函数中可以被多次赋值。
属性是什么?

是一个方法或一对方法体。提供对类或对象的访问。

属性怎么用呢?

它有两个方法get和set。

get访问器:从属性获取值。返回与声明的属性相同的数据类型,表示的意思是调用时可以得到内部字段的值或引用;

set访问器:为属性赋值。没有显式设置参数,但它有一个隐式参数,用关键字value表示,它的作用是调用属性时可以给内部的字段或引用赋值。

属性有什么作用?

限制外部类对类中成员的访问权限,定义在类级别上。

private int _age;          //年龄
public int Age                    
{
    get                    //也可以直接在属性中进行判断操作、设置限制
    {
        if (_age >= 0 && _age <= 150)     //如果年龄大于 0并且小于150的,(表示输入正确)
        {
        	return _age;                  //则返回输入的年龄
        }
        else                              //否则,(表示输入错误)
        {
         	return 18;                    //返回指定年龄18
        }
     }

    set { _age = value; }
}
静态属性是什么?

在属性前面加static关键字,这个属性就成为了静态属性。

有什么作用呢?

  • 不管类是否有实例,它们都是存在的。
  • 当从类的外部访问时,必须使用类名引用,而不是实例名。
class Person
{
    private static  string name;   //字段
    public static string Name      //属性
    {
        get { return name; }
        set { name = value; }
    }
}
static void Main(string[] args)
{
	Person.Name = "小菜";      //不需要实例化Person类即可直接对属性赋值
}
属性和字段的公有部分解释:

内存:

  • 字段:分配内存
  • 属性:不分配内存

命名规范:

  • 字段:Camel大小写
  • 属性:Pascal小写

4、修饰符

在变量前面可以加上访问修饰符(readonly、static)

设计模式—原型模式(Prototype),设计模式,原型模式,java

readonly(只读):读取该字段的值不能给字段赋值

static:静态字段,可以直接通过类名访问该字段

5、访问修饰符有哪些?

  • public:公有的,对任何类可访问
  • private:私有的,只在类的内部可以访问,成员默认是这个
  • protected:保护的,只允许该类的派生类访问
  • internal:内部的,同一项目所有类可访问                

设计模式—原型模式(Prototype),设计模式,原型模式,java

6、this关键字传递的是什么?

  • 用于区分类的成员和本地变量或参数;
  • 作为调用方法的实参                
//this调用成员变量或成员方法
class Person
{
    private string name;               //字段

    public void setName(string name)    //方法
    {
    	this.name = name;       //将参数值赋予类中的成员变量
    }
    //成员变量和setName()方法中的形式参数的名称相同,都为name,那么如何区分使用的是哪一个变量呢?
    //使用this关键字代表本类对象的引用,this.name指Person类中name成员变量,等号后面的name指传过来的形参name
}
this作为方法的返回值
public Book getBook()
{
    return this;                 //返回Book类引用
}

在getBook()类中,方法的返回值为Book类,所以方法体中使用return this这种形式将Book类的对象返回
this关键字和对象之间有什么关系?

this引用的就是本类的一个对象。

如果省略this会怎么样?

直接写成name=name,只是把形参name赋值给参数变量本身而已,成员变量name的值没有改变            

7、构造方法

  • 什么时候用?就是对类进行初始化(在创建该类的对象时就会调用)。
  • 有哪些特点?与类同名

     无返回值

     不需要void,在new时候调用      

//希望每个小猫一诞生就有姓名
class Cat
{
    private string name ="";        //声明Cat类的私有字符串变量name
    public Cat(string name)         //定义Cat类的构造方法,参数是输入一个字符串
    {
        this.name =name;            //将参数赋值给私有变量name
    }
    
    public string Shout()
    {
        return "我的名字叫"+name+" 喵";
    }
}

注:所有类都有构造方法,如果你不编码则系统默认生成空的构造方法,若有定义的构造方法,那么默认的构造方法就会失效(这个构造方法什么也不做,只是为了让用户能够顺利地实例化)

8、方法重载

是什么?指方法名相同,但参数的数据类型、个数或顺序不同的方法。(一同二不同)

有什么好处?在不改变原方法的基础上,新增功能。

class Animal
{
    private string name;
    
    //方法重载:方法名相同、数据类型、个数/顺序不同
    public Animal(){}          //无参的构造方法
    public Animal(string name) //有参的构造方法
    {
        this.name = name;
    }
}

9、抽象类

什么是抽象类?

目的:抽取相同代码,实现封装思想

特点:

  • 抽象类不能实例化;
  • 抽象方法是必须被子类重写的方法;
  • 如果类中包含抽象方法,那么类就必须定义为抽象类,不论是否还包含其他一般方法

什么是重写?

将父类实现替换为它自己的实现

虚成员

抽象成员

关键字

virtual

abstract

实现体

有实现体

没有实现体,被分号取代

在派生类中被覆写

可重写,也可不重写,使用override

必须被重写,使用override

10、值类型和引用类型

值类型:修改其中一个对另一个不会有影响,在栈上存的是值

引用类型:对第二个变量修改会影响到第一个变量。因为他们指向同一个引用。在栈上存的是地址,堆上存的是值

设计模式—原型模式(Prototype),设计模式,原型模式,java

11、六大原则

六大原则

12、六大关系

六大关系


七、思维导图

设计模式—原型模式(Prototype),设计模式,原型模式,java文章来源地址https://www.toymoban.com/news/detail-678925.html

到了这里,关于设计模式—原型模式(Prototype)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 设计模式——原型模式(Prototype Pattern)

    概述        原型模式(Prototype  Pattern):使用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。原型模式是一种对象创建型模式。原型模式的工作原理很简单:将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝自

    2024年01月16日
    浏览(47)
  • 设计模式|原型模式(Prototype Pattern)

    原型模式(Prototype Pattern)是一种创建型设计模式,其核心思想是通过复制现有对象来创建新对象,而无需显式地指定它们的类。这种模式通常用于当对象的创建成本较高,或者对象初始化过程比较复杂时。 原型模式的主要角色包括原型接口(Prototype Interface)、具体原型类(

    2024年04月23日
    浏览(27)
  • 设计模式六:原型模式(Prototype Pattern)

    原型模式是一种创建对象的设计模式。它允许我们通过复制一个现有对象来创建新的对象,而无需知道其具体实现细节。在使用原型模式时,我们首先创建一个原始对象,然后根据需要复制该对象,以获得新创建的对象。 原型模式的主要思想是基于对象的复制。通过使用原型

    2024年02月14日
    浏览(42)
  • 设计模式之原型模式Prototype的C++实现

    1、原型模式提出 在软件功能设计中,经常面临着“某些结构复杂的对象”的创建工作,且创建的对象想拥有其他对象在某一刻的状态,则可以使用原型模型。原型模型是通过拷贝构造函数来创建对象,并且该对象拥有其他对象在某一刻的状态。 2、需求描述 设计产品A,B,这

    2024年02月12日
    浏览(42)
  • 创建型设计模式:5、原型模式(Prototype Pattern)

    目录 1、原型模式的含义 2、C++实现原型模式的简单实例 1、原型模式的含义 通过复制现有对象来创建新对象,而无需依赖于显式的构造函数或工厂方法,同时又能保证性能。 The prototype pattern is a creational design pattern in software development. It is used when the type of objects to create is det

    2024年02月13日
    浏览(43)
  • 《golang设计模式》第一部分·创建型模式-02-原型模式(Prototype)

    用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象 Prototype(抽象原型类):它是声明克隆方法的接口,或所有具体原型类的公共父类 它可以是抽象类也可以是接口,甚至还可以是具体实现类。 ConcretePrototype(具体原型类):它实现在抽象原型类中声明的

    2024年02月14日
    浏览(40)
  • JAVA设计模式----原型设计模式

    定义 :用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。 类型 :创建类模式 类图 : 原型模式主要用于对象的复制,它的核心是就是类图中的原型类Prototype。Prototype类需要具备以下两个条件: 实现Cloneable接口。在java语言有一个Cloneable接口,它的作用只

    2024年02月13日
    浏览(51)
  • Java设计模式-原型模式

    原型模式是一种创建型设计模式,它允许在运行时通过复制现有对象来创建新对象,而不是通过构造函数创建。这个模式的核心思想是基于一个现有的对象克隆一个新的对象,这个过程对外部世界是透明的,就像对象从未被克隆过一样。 原型模式的一个关键优点是可以避免在

    2024年02月03日
    浏览(48)
  • 设计模式篇(Java):原型模式

    上一篇:设计模式篇(Java):工厂模式 需求示例—克隆羊 现在有一只羊tom,姓名为: tom, 年龄为:1,颜色为:白色,请编写程序创建和tom 羊属性完全相同的10只羊。 不使用设计模式(传统方式)实现: 分析: 优点是比较好理解,简单易操作。 在创建新的对象时,总是需要重

    2024年02月11日
    浏览(40)
  • Java设计模式之 - 原型模式

    原型模式是一种创建型设计模式,它允许我们通过克隆现有对象来创建新对象,而无需从头开始构建对象。 在该模式中,一个原型对象被克隆来生成新的对象,新对象的属性可以根据原型对象来设置,也可以进行修改。 原型模式主要解决的问题是对象的创建成本过高或者对

    2024年02月16日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包