精华内容
下载资源
问答
  • 目录一、创建型 单例模式 原型模式 享元模式二、区别三、new一个对象clone一个对象 一、创建型 单例模式 原型模式 享元模式 单例模式 原型模式 原型模式是通过给出一个原型对象来指明所创建的对象的类型,...

    一、创建型 单例模式 原型模式 享元模式

    1. 单例模式

    2. 原型模式

      1. 原型模式是通过给出一个原型对象来指明所创建的对象的类型,然后使用自身实现的克隆接口来复制这个原型对象,该模式就是用这种方式来创建出更多同类型的对象。
      2. 使用这种方式创建新的对象的话,就无需再通过 new 实例化来创建对象了。这是因为 Object 类的 clone 方法是一个本地方法,它可以直接操作内存中的二进制流,所以性能相对 new 实例化来说,更佳。
      3. 通过 clone 方法复制的对象才是真正的对象复制,clone 方法赋值的对象完全是一个独立的对象。 注意深拷贝和浅拷贝
      4. 一些重复创建对象的场景下,我们就可以使用原型模式来提高对象的创建性能。例如, 循环体内创建对象时,我们就可以考虑用 clone 的方式来实现。
      5. 在不得已需要重复创建大量同一对象时,我们可以使用原型模式,通过 clone 方法复制对象,这种方式比用 new 和序列化创建对象的效率要高;
    3. 享元模式

      1. 享元模式是运用共享技术有效地最大限度地复用细粒度对象的一种模式。该模式中,以对象的信息状态划分,可以分为内部数据和外部数据。内部数据是对象可以共享出来的信息,这些信息不会随着系统的运行而改变;外部数据则是在不同运行时被标记了不同的值。
      2. 享元模式一般可以分为三个角色,分别为 Flyweight(抽象享元类)、ConcreteFlyweight(具体享元类)和 FlyweightFactory(享元工厂类)。抽象享元类通常是一个接口或抽象类,向外界提供享元对象的内部数据或外部数据;具体享元类是指具体实现内部数据共享的类;享元工厂类则是主要用于创建和管理享元对象的工厂类。
      3. 例如 Java 的 String 字符串,在一些字符串常量中,会共享常量池中字符串对象,从而减少重复创建相同值对象,占用内存空间。
       String s1 = "hello";
       String s2 = "hello";
       System.out.println(s1==s2);//true
      
      
      1. 线程池就是享元模式的一种实现
      2. 将商品存储在应用服务的缓存中,那么每当用户获取商品信息时,则不需要每次都从 redis 缓存或者数据库中获取商品信息,并在内存中重复创建商品信息了。
      3. 在创建对象时,如果我们可以共用对象的内部数据,那么通过享元模式共享相同的内部数据的对象,就可以减少对象的创建,实现系统调优。

    二、区别

    1. 单例模式是针对某个类的单例,享元模式可以针对一个类的不同表现形式的单例,享元模式是单例模式的超集。
    2. 享元模式可以再次创建对象 也可以取缓存对象,单例模式则是严格控制单个进程中只有一个实例对象,享元模式可以通过自己实现对外部的单例 也可以在需要的使用创建更多的对象
    3. .

    三、new一个对象和clone一个对象

    1. 一个对象通过new创建的过程为:
      1、在内存中开辟一块空间;
      2、在开辟的内存空间中创建对象;
      3、调用对象的构造函数进行初始化对象。

    2. 而一个对象通过clone创建的过程为:
      1、根据原对象内存大小开辟一块内存空间;
      2、复制已有对象,克隆对象中所有属性值。

    3. 相对new来说,clone少了调用构造函数。如果构造函数中存在大量属性初始化或大对象,则使用clone的复制对象的方式性能会好一些。

    展开全文
  • 原型模式

    2018-03-26 21:10:00
    并且通过拷贝这些原型创建新的对象说明:通过clone方法来拷贝原对象,值的注意的是,拷贝后的对象与原对象并不是同一个对象,这个可以通过equal方法来验证,这点也可以说是与享元模式区别吧,在生活中,细胞分裂这...


    1. 定义:
      1. 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象
    2. 说明:
      1. 通过clone方法来拷贝原对象,值的注意的是,拷贝后的对象与原对象并不是同一个对象,这个可以通过equal方法来验证,这点也可以说是与享元模式的区别吧,在生活中,细胞分裂这个可以说是原型模式的一种具体表现吧,或者复印的卷子等等,clone也分为浅拷贝和深拷贝,kotlin中的Any类中是没有clone方法的,所以这例子都是用java来编写。
    3. 类图:

    1. 使用场景(http://www.runoob.com/design-pattern/prototype-pattern.html
      1. 类初始化需要消化非常多的资源,这个资源包括数据、硬件资源等(资源优化)。
      2. 性能和安全要求的场景。
      3. 通过 new 产生一个对象需要非常繁琐的数据准备或访问权限,则可以使用原型模式。
      4. 一个对象需要提供给其他对象访问,而且各个调用者可能都需要修改其值时,可以考虑使用原型模式拷贝多个对象供调用者使用。
      5. 在实际项目中,原型模式很少单独出现,一般是和工厂方法模式一起出现,通过 clone 的方法创建一个对象,然后由工厂方法提供给调用者。在工厂出来的对象可以看成是一样的,
    2. 浅拷贝和深拷贝:
      1. 浅拷贝:对值类型的成员变量进行值的复制,对引用类型的成员变量只复制引用,不复制引用的对象------>意思就是复制的引用还是直接指向了原来的引用类型的成员变量,所以修改了该引用,还是会影响到原对象
        1. 浅拷贝适用于 对象只包含原始数据域或者不可变对象域的时候,提高效率
      2. 深拷贝:对值类型的成员变量进行值的复制,对引用类型的成员变量也进行引用对象的复制
        1.  引用类型的成员变量继承Cloneable(例如ArrayList),可以在Clone方法中直接让其执行成员变量的clone的方法
        2. 相反(例如Int[]),则需要使用序列化来实现深拷贝
          1. 在Java语言里深度克隆一个对象。经常能够先使对象实现Serializable接口,然后把对象(实际上仅仅是对象的拷贝)写到一个流里(序列化),再从流里读回来(反序列化),便能够重建对象。
          2.  这样做的前提就是对象以及对象内部全部引用到的对象都是可序列化的。否则。就须要细致考察那些不可序列化的对象可否设成transient,从而将之排除在复制过程之外。
      3. 有一些对象。比方线程(Thread)对象或Socket对象。是不能简单复制或共享的。
    3. 疑问:
      1. 图解设计模式(菜鸟教程)中的例子不太明白使用原型模式的意义,实例化后放入到map中,取出来的是拷贝后的对象,这样操作的目的是什么
    4. 注意事项:
      1. final 类型修饰的成员变量不能进行深拷贝
      2. 单例模式与原型模式是冲突的
      3. Object中的clone()方法是线程不同步的.在需要线程安全的场景,需要做好同步工作.
      4. 原型模式中的 原型 与 clone实例通过 equals 和 ==比较返回值都是 false
      5. 尽量使用深拷贝类防止错误的发生,对于只有值域类型的对象使用浅拷贝
      6. 原型模式中对象的拷贝是二进制流的拷贝,并不会执行构造函数,因此要在构造函数中做一些额外操作的对象需要注意此问题
      7. kotlin中的Any类中是没有clone方法的
    5. 参考
      1. https://blog.csdn.net/wbwjx/article/details/52151581
      2. http://www.runoob.com/design-pattern/prototype-pattern.html
      3. 图解设计模式
    6. 代码:https://github.com/wk1995/DesignPattern
    展开全文
  • 享元模式(Flyweight Pattern):主要用于减少创建对象的数量,以减少内存占用提高性能。这种类型的设计模式属于结构型模式,它减少对象数量,从而改善所需要的对象结构的方式。 享元模式尝试重用现有的同类对象,...

    享元模式

    享元模式(Flyweight Pattern):主要用于减少创建对象的数量,以减少内存占用和提高性能。这种类型的设计模式属于结构型模式,它减少对象数量,从而改善所需要的对象结构的方式。
    享元模式尝试重用现有的同类对象,如果未找到匹配的对象,则创建新的对象。

    根据实际开发经验来理解享元模式其本质就是对象缓存池。通过缓存池复用来减少动态创建对象的数量以及次数。(后续代码重构的时候会记录实际用例,这里不再介绍缓存池的实例)

    几种“共享”设计模式的区别

    • 原型模式:使用原型实例指定创建对象的种类,然后通过拷贝这些原型来创建新的对象。通过深浅拷贝来实现复用以节约资源开销,倾向于复用。
    • 单例模式:保证一个类有且仅有一个实例,并提供一个全局的访问点。单例模式只有一个实例,全局访问,注重的是一种数据共享。
    • 享元模式:运用共享技术(缓存池)有效地支持大量细粒度的对象,更倾向于共享使用
    展开全文
  • 作者公众号:一角钱技术(org_yijiaoqian)前言23种设计模式速记单例(singleton)模式工厂方法(factory method)模式抽象工厂(abstract factory)模式建造者/构建器(builder)模式原型(prototype)模式享元(flyweight)模式...
    722cffb2ee70c202d75df9797c7ead53.png

    作者公众号:一角钱技术(org_yijiaoqian)

    前言

    • 23种设计模式速记
    • 单例(singleton)模式
    • 工厂方法(factory method)模式
    • 抽象工厂(abstract factory)模式
    • 建造者/构建器(builder)模式
    • 原型(prototype)模式
    • 享元(flyweight)模式
    • 外观(facade)模式
    • 适配器(adapter)模式
    • 装饰(decorator)模式
    • 观察者(observer)模式
    • 策略(strategy)模式
    • 持续更新中......

    23种设计模式快速记忆的请看上面第一篇,本篇和大家一起来学习桥接模式相关内容。

    80abce1d5389fe824b1c579294e9c136.png

    模式定义

    将抽象与实现分离,使它们可以独立变化。它是用组合关系代替继承关系来实现,从而降低了抽象和实现这两个可变维度的耦合度。

    189f996a084e4e5d28574e616f3bd4a3.png

    模式实现如下:

    package com.niuh.designpattern.bridge.v1;/** * 桥接模式 */public class BridgePattern {    public static void main(String[] args) {        Implementor imple=new ConcreteImplementorA();        Abstraction abs=new RefinedAbstraction(imple);        abs.Operation();    }}//实现化角色interface Implementor {    void OperationImpl();}//具体实现化角色class ConcreteImplementorA implements Implementor {    public void OperationImpl() {        System.out.println("具体实现化(Concrete Implementor)角色被访问");    }}//抽象化角色abstract class Abstraction {    protected Implementor imple;    protected Abstraction(Implementor imple) {        this.imple = imple;    }    public abstract void Operation();}//扩展抽象化角色class RefinedAbstraction extends Abstraction {    protected RefinedAbstraction(Implementor imple) {        super(imple);    }    public void Operation() {        System.out.println("扩展抽象化(Refined Abstraction)角色被访问");        imple.OperationImpl();    }}

    输出结果如下

    扩展抽象化(Refined Abstraction)角色被访问具体实现化(Concrete Implementor)角色被访问

    解决的问题

    在有多种可能会变化的情况下,用继承会造成类爆炸问题,扩展起来不灵活。

    模式组成

    可以将抽象化部分与实现化部分分开,取消二者的继承关系,改用组合关系。

    2720cbedaa4a06def7548dca7c1cf5a3.png

    实例说明

    实例概况

    某公司开发了一个财务管理系统,其中有个报表生成器的工具模块,客户可以指定任意一种报表类型,如基本报表,往来报表,资金报表,资产报表等,并且可以指定不同 的报表样式,如饼图,柱状图等。系统设计人员针对这个报表生成器的结构设计了如下图所示的类图。

    e64d4ba7a1e08a4736d3e4250f774c99.png

    后来在客户使用过程中,客户又希望增加一个新的报表和新的线形图,开发人员这个时候发现维护起来非常麻烦,设计人员经过仔细分析,发现存在严重的问题,因为新增加一个报表或者图,需要增加很多子类。所以,系统分析师最终对这个模块根据面向对象的设计原则对上面的方案进行了重构,重构后的图如下所示。

    b24d92bbf78dfb6844bf66e8cf10a067.png

    在本重构方案中,将报表和图形设计成两个继承结构,两者都可以独立变化,编程的时候可以只针对抽象类编码,而在运行的时候再将具体的图形子类对象注入到具体的 报表类中。这样的话,系统就具有良好的可扩展性和可维护性,并且满足了面向对象设计原则的开闭原则。

    使用步骤

    步骤1:定义实现化角色,报表接口

    interface IReport {    void operationImpl();}

    步骤2:定义具体实现化角色(基本报表、往来报表、资金报表)

    class BasicReport implements IReport {    @Override    public void operationImpl() {        System.out.println("基本报表被访问.");    }}class IntercourseReport implements IReport {    @Override    public void operationImpl() {        System.out.println("往来报表被访问.");    }}class CapitalReport implements IReport {    @Override    public void operationImpl() {        System.out.println("资金报表被访问.");    }}

    步骤3:定义抽象化角色,图形

    abstract class AbstractionGraph {    protected IReport iReport;    public AbstractionGraph(IReport iReport) {        this.iReport = iReport;    }    abstract void operation();}

    步骤4:定义扩展抽象化角色(柱状图、饼图)

    class Barchart extends AbstractionGraph {    public Barchart(IReport iReport) {        super(iReport);    }    @Override    void operation() {        System.out.println("柱状图被访问.");        iReport.operationImpl();    }}class Piechart extends AbstractionGraph {    public Piechart(IReport iReport) {        super(iReport);    }    @Override    void operation() {        System.out.println("饼图被访问.");        iReport.operationImpl();    }}

    步骤5:测试

    public class BridgePattern {    public static void main(String[] args) {        //实现化和抽象化分离        // 基本报表        IReport basicReport = new BasicReport();        // 往来报表        IReport intercourseReport = new IntercourseReport();        // 资金报表        IReport capitalReport = new CapitalReport();        // 基本报表使用柱状图        AbstractionGraph barchart = new Barchart(basicReport);        barchart.operation();        // 基本报表使用饼图        AbstractionGraph piechart = new Piechart(basicReport);        piechart.operation();    }}

    输出结果

    柱状图被访问.基本报表被访问.饼图被访问.基本报表被访问.

    优点

    桥接模式遵循了里氏替换原则和依赖倒置原则,最终实现了开闭原则,对修改关闭,对扩展开放。这里将桥接模式的优缺点总结如下。

    桥接(Bridge)模式的优点:

    • 抽象与实现分离,扩展能力强
    • 符合开闭原则
    • 符合合成复用原则
    • 其实现细节对客户透明

    缺点

    由于聚合关系建立在抽象层,要求开发者针对抽象化进行设计与编程,能正确地识别出系统中两个独立变化的维度,这增加了系统的理解与设计难度。

    应用场景

    当一个类内部具备两种或多种变化维度时,使用桥接模式可以解耦这些变化的维度,使高层代码架构稳定。

    桥接模式通常适用于以下场景:

    1. 当一个类存在两个独立变化的维度,且这两个维度都需要进行扩展时;
    2. 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时;
    3. 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。

    桥接模式的一个常见使用场景就是替换继承。我们知道,继承拥有很多优点,比如,抽象、封装、多态等,父类封装共性,子类实现特性。继承可以很好的实现代码复用(封装)的功能,但这也是继承的一大缺点。

    因为父类拥有的方法,子类也会继承得到,无论子类需不需要,这说明继承具备强侵入性(父类代码侵入子类),同时会导致子类臃肿。因此,在设计模式中,有一个原则为优先使用组合/聚合,而不是继承。

    桥接模式模式的扩展

    在软件开发中,有时桥接(Bridge)模式可与适配器模式联合使用。当桥接(Bridge)模式的实现化角色的接口与现有类的接口不一致时,可以在二者中间定义一个适配器将二者连接起来,其结构图如下:

    e0441e24b0bbf94691367b3deb11f664.png

    源码中的应用

    JDBC驱动程序......
    0a9963ade07f58131bd05a5127d7c1ae.png

    DriverManager类

    DriverManager作为一个抽象化角色,聚合了实现化角色Connection,只不过与标准的桥梁模式不一样的是,DriverManager类下面没有子类。

    //  Worker method called by the public getConnection() methods.private static Connection getConnection( String url, java.util.Properties info, Class> caller) throws SQLException {        /*         * When callerCl is null, we should check the application's         * (which is invoking this class indirectly)         * classloader, so that the JDBC driver class outside rt.jar         * can be loaded from here.         */        ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;        synchronized(DriverManager.class) {            // synchronize loading of the correct classloader.            if (callerCL == null) {                callerCL = Thread.currentThread().getContextClassLoader();            }        }        if(url == null) {            throw new SQLException("The url cannot be null", "08001");        }        println("DriverManager.getConnection("" + url + "")");        // Walk through the loaded registeredDrivers attempting to make a connection.        // Remember the first exception that gets raised so we can reraise it.        SQLException reason = null;        for(DriverInfo aDriver : registeredDrivers) {            // If the caller does not have permission to load the driver then            // skip it.            if(isDriverAllowed(aDriver.driver, callerCL)) {                try {                    println("    trying " + aDriver.driver.getClass().getName());                    Connection con = aDriver.driver.connect(url, info);                    if (con != null) {                        // Success!                        println("getConnection returning " + aDriver.driver.getClass().getName());                        return (con);                    }                } catch (SQLException ex) {                    if (reason == null) {                        reason = ex;                    }                }            } else {                println("    skipping: " + aDriver.getClass().getName());            }        }        // if we got here nobody could connect.        if (reason != null)    {            println("getConnection failed: " + reason);            throw reason;        }        println("getConnection: no suitable driver found for "+ url);        throw new SQLException("No suitable driver found for "+ url, "08001");}

    PS:以上代码提交在 Github

    https://github.com/Niuh-Study/niuh-designpatterns.git

    文章持续更新,可以公众号搜一搜「 一角钱技术 」第一时间阅读, 本文 GitHub org_hejianhui/JavaStudy 已经收录,欢迎 Star。

    展开全文
  • 作者公众号:一角钱技术(org_yijiaoqian)前言23种设计模式速记单例(singleton)模式工厂方法(factory method)模式抽象工厂(abstract factory)模式建造者/构建器(builder)模式原型(prototype)模式享元(flyweight)模式...
  • 前言23种设计模式速记单例(singleton)模式工厂方法(factory method)模式抽象工厂(abstract factory)模式建造者/构建器(builder)模式原型(prototype)模式享元(flyweight)模式持续更新中......23种设计模式快速记忆的...
  • 作者公众号:一角钱技术(org_yijiaoqian)前言23种设计模式速记单例(singleton)模式工厂方法(factory method)模式抽象工厂(abstract factory)模式建造者/构建器(builder)模式原型(prototype)模式享元(flyweight)模式...
  • 点赞再看,养成习惯,公众号搜...前言23种设计模式速记单例(singleton)模式工厂方法(factory method)模式抽象工厂(abstract factory)模式建造者/构建器(builder)模式 原型(prototype)模式享元(flyweight...
  • 作者公众号:一角钱技术(org_yijiaoqian)前言23种设计模式速记单例(singleton)模式工厂方法(factory method)模式抽象工厂(abstract factory)模式建造者/构建器(builder)模式原型(prototype)模式享元(flyweight)模式...
  • 模式

    2020-06-12 10:23:34
    享元模式和原型模式区别原型模式为了快速创建对象,而享原模式是为了对象的复用 UML 实现代码 public class FlyweightPatternDemo { public static void main(String[] args) { Shape circle = ...
  • 设计模式分类和区别

    2013-10-30 23:37:55
    结构型模式:适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。 行为型模式:模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略...
  • 对比维度说明设计原则:设计模式(总纲)创建型:单例模式 简单工厂模式 工厂方法模式 抽象工厂模式 建造者模式 原型模式结构型:代理模式 适配器模式 装饰器模式 桥接模式 组合模式 享元模式 外观模式行为型: ...
  • 设计模式知识点前面说了操作系统...结构型:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘...
  • 迭代器模式,解释器模式,备忘录模式,适配器设计模式,享元模式,装饰者模式,Android源码设计模式分析,单例模式1,单例模式2,简单工厂模式,抽象工厂模式,工厂方法模式,Builder模式1,Builder模式2,外观模式...
  • Java设计模式 基本概念 代码分析 饿汉模式 懒汉模式 1在getInstance方法上加同步 2双重检查锁定 ...结构型模式:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式; 行为型模式
  • 208面试题 设计模式

    2020-11-18 09:36:49
    适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式(共十一种): 策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录 模式、状态模式、访问者...
  • JavaScript设计模式

    2018-08-31 02:47:41
    13.8实现享元模式的一般步骤 13.9享元模式之利 13.10享元模式之弊 13.11小结 第14章代理模式 14.1代理的结构 14.1.1代理如何控制对本体的访问 14.1.2虚拟代理、远程代理保护代理 14.1.3代理模式与装饰者模式的比较...
  • 研磨设计模式.part3

    2012-02-10 14:06:23
    20.2.1 使用享元模式来解决问题 20.2.2 享元模式的结构说明 20.2.3 享元模式示例代码 20.2.4 使用享元模式重写示例 20.3 模式讲解 20.3.1 认识享元模式 20.3.2 不需要共享的享元实现 20.3.3 对享元对象的管理 20.3...
  • 研磨设计模式.part1

    2012-02-10 14:05:01
    20.2.1 使用享元模式来解决问题 20.2.2 享元模式的结构说明 20.2.3 享元模式示例代码 20.2.4 使用享元模式重写示例 20.3 模式讲解 20.3.1 认识享元模式 20.3.2 不需要共享的享元实现 20.3.3 对享元对象的管理 20.3...
  • 研磨设计模式.part2

    2012-02-10 14:02:38
    20.2.1 使用享元模式来解决问题 20.2.2 享元模式的结构说明 20.2.3 享元模式示例代码 20.2.4 使用享元模式重写示例 20.3 模式讲解 20.3.1 认识享元模式 20.3.2 不需要共享的享元实现 20.3.3 对享元对象的管理 20.3...
  • 研磨设计模式.part4

    2012-02-10 13:57:47
    20.2.1 使用享元模式来解决问题 20.2.2 享元模式的结构说明 20.2.3 享元模式示例代码 20.2.4 使用享元模式重写示例 20.3 模式讲解 20.3.1 认识享元模式 20.3.2 不需要共享的享元实现 20.3.3 对享元对象的管理 20.3...
  • 第22章 对象共享,避免创建多对象——享元模式 22.1 享元模式介绍 22.2 享元模式定义 22.3 享元模式的使用场景 22.4 享元模式的UML类图 22.5 享元模式的简单示例 22.6 Android源码中的享元模式 22.7 深度拓展...
  • 第20章 享元模式(Flyweight) 第21章 解释器模式(Interpreter) 第22章 装饰模式(Decorator) 第23章 职责链模式(Chain of Responsibility) 第24章 桥接模式(Bridge) 第25章 访问者模式(Visitor) 附录A常见...
  • 第20章 享元模式(Flyweight) 第21章 解释器模式(Interpreter) 第22章 装饰模式(Decorator) 第23章 职责链模式(Chain of Responsibility) 第24章 桥接模式(Bridge) 第25章 访问者模式(Visitor) 附录A常见...
  • 第20章 享元模式(Flyweight) 第21章 解释器模式(Interpreter) 第22章 装饰模式(Decorator) 第23章 职责链模式(Chain of Responsibility) 第24章 桥接模式(Bridge) 第25章 访问者模式(Visitor) 附录A常见...
  • 第20章 享元模式(Flyweight) 第21章 解释器模式(Interpreter) 第22章 装饰模式(Decorator) 第23章 职责链模式(Chain of Responsibility) 第24章 桥接模式(Bridge) 第25章 访问者模式(Visitor) 附录A常见...
  • 二十三种设计模式【PDF版】

    热门讨论 2011-05-30 14:13:49
    正因为这点不同,导致建筑的管理模式和软件的管理模式就有很多不同, 有些人认识不到这点,就产生了可以大量使用"软件 蓝领"的想法,因为他羡慕建筑中"民工"的低成本. 要知道软件还有一个与建筑截然相反的责任和用途,那...
  • 享元模式 外观模式 桥接模式 第二部分 JavaSE(Java基础) Java基础知识 Java中的内存泄漏 String源码分析 Java集合框架 ArrayList源码剖析 LinkedList源码剖析 Vector源码剖析 HashMap源码剖析 HashTable源码...
  • 本教程共分为5个部分,第一部分是C语言提高部分,第二部分为C++基础部分,第三部分为C++进阶部分,第四部分为C、C++及数据结构基础部分,第五部分为C_C++与设计模式基础,内容非常详细. 第一部分 C语言提高部分目录...

空空如也

空空如也

1 2
收藏数 32
精华内容 12
关键字:

原型模式和享元模式区别