精华内容
下载资源
问答
  • 原型模式和单例模式1.原型模式1.1.浅克隆1.2.深克隆2.单例模式 1.原型模式 克隆:给出一个对象,调用对象内部的clone方法,返回一个新对象。 1.1.浅克隆 定义:旧对象copy出一个新对象,为新对象分配新地址。 ...

    1.原型模式

    克隆:给出一个对象,调用对象内部的clone方法,返回一个新对象。

    1.1.浅克隆

    • 定义:旧对象copy出一个新对象,为新对象分配新地址。

    • 变化:新对象值类型的成员变量占用新的内存空间。

    • 不变:新对象引用类型的成员变量指向的是同一个内存地址。

    • 要求:实现克隆的Java类必须实现一个标识接口Cloneable。

    • 模式结构:
      在这里插入图片描述

    • demo1:

    public class PrototypeDemo implements Cloneable
    {
        ……
      public Object clone()
      {
        Object object = null;
        try {
          object = super.clone();
        } catch (CloneNotSupportedException exception) {
          System.err.println("Not support cloneable");
        }
        return (PrototypeDemo)object;
        }
        ……
    }
    
    • demo2:
    public class PrototypeDemo implements Cloneable
    {
        ……
      public Object clone()
      {
        Object object = null;
        try {
          object = super.clone();
          (PrototypeDemo)object.set某个引用类型属性(this.引用类型属性.clong())//这时引用类型的成员变量指向的就不是同一个内存地址
        } catch (CloneNotSupportedException exception) {
          System.err.println("Not support cloneable");
        }
        return (PrototypeDemo)object;
        }
        ……
    }
    

    1.2.深克隆

    • 定义:旧对象copy出一个新对象,为新对象分配新地址。
    • 变化:新对象值类型的成员变量占用新的内存空间,新对象引用类型的成员* 变量指向的不是同一个内存地址。
    • 要求:旧对象以及其引用类型的成员变量所属类实现序列化接口。

    易错点:如果对象间存在多重的嵌套引用,要实现深克隆,有两种方法:
    1.对象和多重的嵌套引用所属的类都需要实现序列化接口,这样就可以实现深克隆。
    2.对象和多重的嵌套引用所属的类都有内部都有一个克隆方法,整体在克隆的时候必须以调用部分的克隆方法为参进行对属性的设置注入;当然,“都有一个克隆方法”是底线,如果能实现序列化接口式的深克隆就不必要了。
    例子:a类有b类的引用,b类有c类的引用,a、b都实现序列化接口,a中有序列化接口式的深克隆方法,c没有实现序列化接口,这时对于a类就不能实现深克隆。
    解决:1.c实现序列化接口;2.c有浅克隆方法,b以调用c的克隆方法为参进行对属性的设置注入。

    • 模式结构:
      在这里插入图片描述
    • demo:
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述

    2.单例模式

    展开全文
  • 原型模式和单例模式的区别

    千次阅读 2014-03-27 11:20:27
    原型模式和单例模式的区别 1. 定义上的区别 1.1. 原型模式原型模式是在已指定对象的基础上,然后通过拷贝这些原型对象创建新的对象。 当要实例化的类是在运行时刻指定或者为了避免创建一个与产品类层次...


    1.   定义上的区别

    1.1.  原型模式

    原型模式是在已指定对象的基础上,然后通过拷贝这些原型对象创建新的对象。

    当要实例化的类是在运行时刻指定或者为了避免创建一个与产品类层次平行的工厂类层次时或者当一个类的实例只能有几个不同状态组合中的一种时 —— 建立相应数目的原型克隆它们可能比每次用合适的状态手工实例化该类更方便一些。 

    1.2.  单例模式

    单态设计模式的核心就是:将类的构造方法私有化,之后在类的内部产生实例化对象,并通过静态方法返回实例化对象的应用。

    如果不希望一个类产生更多对象的情况下,必须使用单态模式,所谓单态就是在对象的入口处(构造方法)限制了对象的实例化操作。

    2.   JAVA实现上的区别

    2.1.  原型模式

    1. import java.util.ArrayList;  
    2.  
    3. class ConcretePrototype implements Cloneable {  
    1.  
    2.  
    3.     private String name;  
    4.     private ArrayList<String> nameList = new ArrayList<String>();  
    5.  
    6.     public ConcretePrototype(String name) {  
    7.         this.name = name;  
    8.         this.nameList.add(this.name);  
    9.     }  
    10.  
    11.     // 添加nameList中的对象  
    12.     public void setName(String name) {  
    13.         this.nameList.add(name);  
    14.     }  
    15.  
    16.     public ArrayList<String> getNameList() {  
    17.         return this.nameList;  
    18.     }  
    19.  
    20.     // 覆盖Object基类中的clone()方法,并扩大该方法的访问权限,具体化返回本类型  
    21.     public ConcretePrototype clone() {  
    22.         try {  
    23.             return (ConcretePrototype) super.clone();  
    24.         } catch (CloneNotSupportedException e) {  
    25.             e.printStackTrace();  
    26.         }  
    27.         return null;  
    28.     }  
    29. }  
    30.  
    31. public class TestConcretePrototype {  
    32.     public static void main(String args[]) {  
    33.         try {  
    34.             ConcretePrototype prototype = new ConcretePrototype("调用原型方法");  
    35.             // 通过clone获取一个拷贝  
    36.             System.out.println(prototype.getNameList());  
    37.             ConcretePrototype fromClone = prototype.clone();  
    38.             fromClone.setName("调用克隆方法");  
    39.             System.out.println(fromClone.getNameList());  
    40.         } catch (Exception e) {  
    41.             e.printStackTrace();  
    42.         }  
    43.     }  
    44. }  

    2.2.  单例模式

    2.2.1. 单利模式的通用代码

    1. class Singleton {  
    2.  
    3.     private Singleton() {  
    4.         // 将构造方法进行封装,私有化  
    5.         // 定义为private的,是为了不让Singleton在外部生成对象,这才能体现单例模式  
    6.     }  
    7.       
    8.     // 在内部产生本类的实例化对象  
    9.     // 注意这是private只供内部调用  
    10.     private static Singleton instance = new Singleton();  
    11.  
    12.     public static Singleton getInstance() {  
    13.         // 通过静态方法取得instance对象  
    14.         // 这里提供了一个供外部访问本class的静态方法,可以直接访问  
    15.         return instance;  
    16.     }  
    17.  
    18.     public static void setInstance(Singleton instance) {  
    19.         Singleton.instance = instance;  
    20.     }  
    21. }  
    22.  
    23. public class TestSingleton {  
    24.     public static void main(String args[]) {  
    25.         // 初始化  
    26.         Singleton s1 = null;  
    27.         Singleton s2 = null;  
    28.         // 实例化对象  
    29.         s1 = Singleton.getInstance();  
    30.         s2 = Singleton.getInstance();  
    31.         // 若相等则表示生成的对象是唯一的  
    32.         System.out.println(s1 == s2);  
    33.     }  
    34. }  

    2.2.2. 懒汉似的单例模式

    1. class SingletonLazy {
    2. // 在内部产生本类的实例化对象
    3. private static SingletonLazy instance = null;
    4. private SingletonLazy() {
    5. }
    6. // 线程安全,确保内存中只有一个实例
    7. public static synchronized SingletonLazy getInstance() {
    8. // 这个方法比上边有所改进,不用每次都进行生成对象,只是第一次使用时生成实例
    9. if (instance == null) {
    10. instance = new SingletonLazy();
    11. }
    12. return instance;
    13. }
    14. }
    15. public class TestSingletonLazy {
    16. public static void main(String args[]) {
    17. // TODO Auto-generated method stub
    18. // 初始化
    19. SingletonLazy s1 = null;
    20. SingletonLazy s2 = null;
    21. // 实例化对象
    22. s1 = SingletonLazy.getInstance();
    23. s2 = SingletonLazy.getInstance();
    24. // 若相等则表示生成的对象是唯一的
    25. System.out.println(s1 == s2);
    26. }
    27. }

    3.   Spring源码学习

    3.1.  Spring的原型模式

    1. abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
    2. implements BeanDefinition, Cloneable {
    3. private String scope = SCOPE_DEFAULT;
    4. private boolean singleton = true;
    5. private boolean prototype = false;
    6. public void setScope(String scope) {
    7. this.scope = scope;
    8. this.singleton = SCOPE_SINGLETON.equals(scope)
    9. || SCOPE_DEFAULT.equals(scope);
    10. this.prototype = SCOPE_PROTOTYPE.equals(scope);
    11. }
    12. public String getScope() {
    13. return this.scope;
    14. }
    15. @Override
    16. public Object clone() {
    17. return cloneBeanDefinition();
    18. }
    19. public abstract AbstractBeanDefinition cloneBeanDefinition();
    20. }
    21. public class SpringAbstractBeanDefinition {
    22. }

    3.2.  Spring的单例模式

     

     

     

    1. import java.util.HashMap;
    2. import java.util.Map;
    3. class SingletonBeanFactoryLocator implements BeanFactoryLocator {
    4. private static final Map<String, BeanFactoryLocator> instances = new HashMap<String, BeanFactoryLocator>();
    5. public SingletonBeanFactoryLocator(String resourceLocation) {
    6. }
    7. public static BeanFactoryLocator getInstance(String selector)
    8. throws BeansException {
    9. String resourceLocation = selector;
    10. // 线程安全,确保内存中只有一个实例
    11. synchronized (instances) {
    12. BeanFactoryLocator bfl = instances.get(resourceLocation);
    13. if (bfl == null) {
    14. bfl = new SingletonBeanFactoryLocator(resourceLocation);
    15. instances.put(resourceLocation, bfl);
    16. }
    17. }
    18. return getInstance(null);
    19. }
    20. }
    21. public class SpringSingletonBeanFactoryLocator {
    22. }
    展开全文
  • 创建型模式之原型模式和单例模式

    千次阅读 热门讨论 2016-01-29 16:58:08
    创建型模式除了三大工厂和建造者模式,就剩下这两个了,原型模式和单例模式。下面就谈谈这两个模式。 一、原型模式 定义 原型模式(prototype):用原型实例指定创建对象的种类,并通过拷贝这些原型创建新...

          创建型模式除了三大工厂和建造者模式,就剩下这两个了,原型模式和单例模式。下面就谈谈这两个模式。

    一、原型模式

    定义

    原型模式(prototype):用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。

    自己的理解:说白了就是复制。就像简历的例子一样,我们肯定是需要好多份简历不能每次都执行一遍程序,所以肯定得把制作简历抽象出一个类,用的时候实例化就OK了嘛,但是,如果需要1000份就非要实例化1000次吗?太浪费资源空间了吧,所以就用了一个非常洋气的方法叫clone。clone其实就是复制嘛,但是不能老克隆一模一样的吧,我想给别人也写个简历呢,所以就涉及到深复制和浅复制了。

    UML类图



    代码示例(简历)

    namespace 原型模式
    {
        class Program
        {
            static void Main(string[] args)
            {
                Resume a = new Resume("大鸟");
                a.SetPersonalInfo("男","29");
                a.SetWorkExperience("1998-2000","xx公司");
    
                Resume b = (Resume)a.Clone();
                b.setPersonalInfo("女","55");
                b.SetWorkExperinece("2000-3000","yy企业");
    
                a.Display();
                b.Display();
    
                Console.Read();
    
    
            }
        }
    
    
        #region 简历 深复制和浅复制
        //工作经历
        //class WorkExperience 
          class WorkExperience:ICloneable  //工作经历实现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();
            }
    
        }
    
        //简历
        class Resume : ICloneable
        {
            private string name;
            private string sex;
            private string age;
    
            private WorkExperience work; //引用工作经历对象
    
            public Resume(string name)
            {
                this.name = name;
                work = new WorkExperience();// 在“简历类”实例化的同时实例化“工作经历”
    
            }
    
            //提供clone方法调用的私有构造函数,以便克隆工作经历的数据
            private Resume(WorkExperience work)
            {
                this.work = (WorkExperience)work.<span style="color:#3366ff;">Clone()</span>;
            }
    
            //设置个人信息
            public void SetPersonalInfo(string sex, string age)
            {
                this.sex = sex;
                this.age = age;
            }
    
            //设置工作经历
            public void SetWorkExperinece(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();  浅复制
    
                //调用私有的构造方法,让工作经历克隆完成,然后再给这个简历对象的相关字段赋值,最终返回一个深复制的简历对象
                Resume obj = new Resume(this.work);
                obj.name = this.name;
                obj.sex = this.sex;
                obj.age = this.age;
                return obj;
            }
    
    
    
    
    
    
            internal void setPersonalInfo(string p1, string p2)
            {
                throw new NotImplementedException();
            }
    
            internal void SetWorkExperience(string p1, string p2)
            {
                throw new NotImplementedException();
            }
        }
        #endregion
    }
    

    适用场景

        初始化信息不发生变化的情况下,需要重复的创建对象。优点是隐藏对象创建细节,大大提高性能。

    深复制和浅复制

    浅复制:如果字段是值类型的,则对该字段进行逐位复制,如果字段是引用类型,则复制引用但不复制引用的对象,因此,原始对象及其副本引用同一对象。

    深复制:是将指向内容复制到给当前对象新分配的缓冲区中的一种复制方式,把引用对象的变量指向复制过的新对象,而不是原有的被引用的对象都复制一遍。

    自己的理解:
      A引用B,现在要复制A(二者区别针对引用类型)
      浅复制: A1引用B
      深复制: A1引用B1
     浅复制不复制引用的对象,之前引用的谁,现在还引用谁
     深复制会开辟空间把引用对象也复制过来

    二、单例模式

        单例模式是设计模式中最简单的模式之一。根本就没有涉及到其他复杂的类,就是在原来的类上加上双重锁或设置静态初始化使得这个类自己控制自己只能有一个实例。

    定义

        单例模式(Singleton):保证一个类仅有一个实例,并提供一个访问它的全局访问点。

    必要性

        对于某些类来说,只有一个实例是很重要的。遇到多线程问题的时候,只能让一个线程工作,其他的等待。比如我们在打印的时候,可能一下选择了好几个打印任务,但是只能有一个正在工作的任务。在创建窗体的时候,如果不对创建窗体的唯一性进行控制,就可以创建多个相同的窗体,重复的对象是对内存资源的一种浪费。

    代码示例(创建窗体)
    amespace 单例模式
    {
        
    
        #region<span style="color:#ff0000;"> 懒汉模式 双重锁定</span>
        class Singleton
        {
            private static Singleton instance;//抽出来成为全局变量
            private static readonly object syncRoot = new object();//程序运行时创建一个静态只读的进程辅助对象
            private Singleton()  //构造方法用private,阻止外界new此类创建实例
            { }
    
            public static Singleton GetINstance()//此方法是获得本类实例的唯一全局访问点
            {
                if (instance == null)// 没有创建实例,有两个进程等着,只能进去一个
                {
                    lock(syncRoot )
                    {
                        if(instance == null)//保证如果有一个实例创建了,另一个就无法创建
                        {
                            instance = new Singleton();
                        }
                    }
                }
                return instance;
            }
        }
        #endregion
    
    
    
    
        #region <span style="color:#ff0000;">饿汉式单例类</span>
        //封装的,阻止发生派生
        public sealed class Singleton
        {
            <span style="color:#ff0000;">//静态初始化是在类被加载的时候就将它实例化
            private static readonly Singleton instance = new Singleton();</span>
            private Singleton() { }
            public static Singleton GetInstance()
            {
                return instance;
            }
        }
        #endregion
    }

    如何实现单例

    第一步:全局访问
            把类变量声明成全局变量,不要在某一事件中声明,这样可以判断类是否被实例化过。
    第二步:实例化控制
      方法一:双重锁定
      这针对的是多线程问题。
    if (instance == null)// 没有创建实例,有两个进程等着,只能进去一个
                {
                    lock(syncRoot )
                    {
                        if(instance == null)//保证如果有一个实例创建了,另一个就无法创建
    第一个if是判断是否已经创建过实例,如果没有,上把锁,只能进去一个线程。第二个if是判断第一线程有没有创建实例,如果创建了第二个线程就不能再创建。
       由于该类是在第一次被引用的时候,才会将自己实例化,所以被称为懒汉式单例类。
       方法二:静态实例化
       这种方法不需要开发人员显示的编写线程安全代码,即可解决多线程环境下不安全的问题。这种静态初始化的方式是在自己被加载时就将自己实例化,所以被称为饿汉式单例类。

    总结

        在实际开发过程中肯定会有好多涉及到多线程的问题,所以单例模式也要掌握熟练。单例模式主要就是解决多线程的安全问题。如果开发过程中遇到只需要一个实例的问题就考虑考虑单例模式,如果对一个类重复调用,内容没有多大改变,跟复制似的就考虑原型模式。
        
    展开全文
  • 原型模式单例模式的破坏 利用反射调用单例类的 clone() 方法,获得单例类的多个实例; public class HungrySingleton implements Cloneable{ private final static HungrySingleton hungrySingleton; static...
        

    原型模式对单例模式的破坏

    • 利用反射调用单例类的 clone() 方法,获得单例类的多个实例;
    public class HungrySingleton implements Cloneable{
    
        private final static HungrySingleton hungrySingleton;
    
        static {
            hungrySingleton = new HungrySingleton();
        }
    
        private HungrySingleton() {}
    
        public static HungrySingleton getInstance() {
            return hungrySingleton;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    
    }
    
    public class Test {
        public static void main(String[] args) throws Exception{
            HungrySingleton hungrySingleton = HungrySingleton.getInstance();
    
            Method method = HungrySingleton.class.getDeclaredMethod("clone");
            method.setAccessible(true);
            HungrySingleton cloneHungrSingleton = (HungrySingleton)method.invoke(hungrySingleton);
    
            System.out.println(hungrySingleton);
            System.out.println(cloneHungrSingleton);
            System.out.println(hungrySingleton == cloneHungrSingleton);
        }
    }
    

    输出:

    designpattern.creational.prototype.singletonattack.HungrySingleton@5b6f7412
    designpattern.creational.prototype.singletonattack.HungrySingleton@27973e9b
    false

    解决方案

    • 在 clone() 方法中直接调用 getInstance() 方法;
    public class HungrySingleton implements Cloneable{
    
        private final static HungrySingleton hungrySingleton;
    
        static {
            hungrySingleton = new HungrySingleton();
        }
    
        private HungrySingleton() {}
    
        public static HungrySingleton getInstance() {
            return hungrySingleton;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return getInstance();
        }
    
    }
    
    public class Test {
        public static void main(String[] args) throws Exception{
            HungrySingleton hungrySingleton = HungrySingleton.getInstance();
    
            Method method = HungrySingleton.class.getDeclaredMethod("clone");
            method.setAccessible(true);
            HungrySingleton cloneHungrSingleton = (HungrySingleton)method.invoke(hungrySingleton);
    
            System.out.println(hungrySingleton);
            System.out.println(cloneHungrSingleton);
            System.out.println(hungrySingleton == cloneHungrSingleton);
        }
    }
    

    输出:

    designpattern.creational.prototype.singletonattack.HungrySingleton@5b6f7412
    designpattern.creational.prototype.singletonattack.HungrySingleton@5b6f7412
    true

    展开全文
  • 前言 上篇文章介绍了简单工厂模式、工厂方法模式以及抽象工厂模式,接下来就继续学习原型模式单例模式:模式1、原型模式: 原型模式之前在Java设计模式的板块也讲过,这里再拿出来讲一下:原型模式属于创建型模式...
  • 原型模式: 该模式用于克隆对象,有2种方式 浅克隆(不复制引用类型)深克隆(将值类型、引用类型均复制) C#中提供了MemberwiseClone()方法用于浅克隆ICloneable接口用于实现深克隆 单例模式 : ...
  • 原型模式 如果想根据现有对象复制出线的对象并进行修改,那么可以考虑原型模式 python 创建对象的7种方法 单例模式 在整个程序运行的过程中,如果某个类只应该有一个实例,可以通过单例模式来保证
  • 原型模式,使用的情景:是想根据现有的对象复制出新的对象并对其修改。 这里的举例,是以平面上的点为类,进行原型模式的演示 class Point: def __init__(self, x, y): self.x = x self.y = y point1 = Point...
  • function Person(){ } Person.prototype = { constructor:Person, name:'学生', age:'18', sleep:function(){ console.log("在睡觉"); } } var p1 = new Person(); p1.job = "打工";...
  • 建造者模式(Builder Pattern) 封装一个产品的构造过程,并允许按步骤构造。 还有一个通俗的定义是:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 简单点说,就是客户类想要创建...
  • 想象不到的简单go单例模式原型模式简介单例模式原型模式 简介 本文主要说一下设计模式之单例模式与原型,后续会有更多的模式和算法以及区块链相关的,如果你是想学习go语言或者是对设计模式或者算法感兴趣亦或是...
  • 设计模式 最近出去面试,发现自己对设计模式上面有点生疏了,也的的确确忘了很多,这边就稍微的巩固一下自己的设计模式.面试官也说到了,你如果都不知道这些设计模式的...懒汉式单例模式 public class LanHan{ //vo...
  • 单例模式 定义 通过单例模式的方法创建的类在当前进程中只有一个实例。 Java中单例模式定义:“一个类有且仅有一个实例,并且自行实例化向整个系统提供。” 简介 单例模式是23中设计模式中的最简单的一种,这一...
  • 单例模式(singleton): 定义: 保证一个类只有一个实例,仅提供一个访问他实例的全局访问点。 适用性: 1.当类只有一个实例,而且客户只能从一个众所周知的访问点访问它时; 2.当这个唯一实例,应该是可以通过...
  • 23种设计模式之单例模式原型模式前言 前言 单例模式(一个类模板,在整个系统执行过程中,只允许产生一个实例)应用广泛,主要 应用在: 配置文件 Ioc容器 日历 工厂本身 单例模式,解决一个并发访问的时候线程...
  • 设计模式之装饰模式、单例模式原型模式、 组合模式 装饰模式Decorator Pattern 23种设计模式之一,又叫装饰者模式。装饰模式是在不必改变原类文件使用继承的情况下,动态地扩展一个对象的功能。它是通过创建一...
  • I . 原型模式 总结 II . 原型模式 浅拷贝 III . 原型模式 深拷贝 IV . 原型模式单例 V . 原型模式 中的 final 关键字 ( 禁止出现 )
  • 创建型模式,是对对象创建过程的各种问题解决方案的总结,包括各种工厂模式(Factory、Abstract Factory)、单例模式(Singleton)、构建器模式(Builder)、原型模式(ProtoType)。 结构型模式,是针对软件设计...
  • 单例模式:  单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时...
  • 单例模式和原型模式

    2021-08-03 20:25:22
    单例模式---只生一个就好,多了没有必要 原型模式---大部分的内容都相似,没有必要一个一个参数去设定,有一个变为多个,不同的去修改就是了!比如说《帝国时代》中的农民!可能有很多,但是它们大部分的参数是相同...
  • 文章目录单例模式应用举例单例模式的特点单例模式的优点缺点java实现单例模式懒汉式单例饿汉式单例测试原型模式原型模式的优缺点java实现原型模式测试工厂模式简单工厂模式优缺点工厂方法模式抽象方法模式java实现...
  • 目录一、创建型 单例模式 原型模式 享元模式二、区别三、new一个对象clone一个对象 一、创建型 单例模式 原型模式 享元模式 单例模式 原型模式 原型模式是通过给出一个原型对象来指明所创建的对象的类型,...
  • 单例模式原型模式、工厂方法模式、抽象工厂模式和建造者模式为代表的创建型模式,它的主要关注点是“怎样创建对象?”,主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度,使用者不需要关注对象...
  • 1.单例模式 单例模式的实现有多种方式 单例模式:一个类创建出来的对象都是同一个 Python的模块其实就是单例的,只会导入一次,如:在模块里定义的全局变量其实就是单例的 使用共享同一个实例的方式来创建单例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,565
精华内容 17,426
关键字:

原型模式和单例模式