精华内容
下载资源
问答
  • 设计模式结构型模式

    千次阅读 2011-11-05 00:32:20
    下面说一下结构型模式:结构型模式是描述如何将类对象结合在一起,形成一个更大的结构,结构模式描述两种不同的东西:类与类的实例。故可以分为类结构模式和对象结构模式。 在GoF设计模式中,结构型模式有:  1....

           下面说一下结构型模式:结构型模式是描述如何将类对象结合在一起,形成一个更大的结构,结构模式描述两种不同的东西:类与类的实例。故可以分为类结构模式和对象结构模式。

    在GoF设计模式中,结构型模式有:

          1.适配器模式 Adapter

          2.桥接模式 Bridge

          3.组合模式 Composite

          4.装饰模式 Decorator

          5.外观模式 Facade

          6.享元模式 Flyweight

          7.代理模式 Proxy  

    具体来说:

    适配器模式Adapter

          适配器模式是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

          两个成熟的类需要通信,但是接口不同,由于开闭原则,我们不能去修改这两个类的接口,所以就需要一个适配器来完成衔接过程。

          变压器就是很好的适配器模式的例子。用电设备所需要的电压是9V,但是电线上的电压却是220V的,我们不能去更改它们的电压输入或输出,所以我们用到了变压器。变压器是220V的输入,9V的输出。这样就可以将200V的电压变为9V的电压,用变压器将用电设备连接到了电线上工作了。

           上面两幅图中,都是Client端需要Request这个方法,但是Adaptee没有这个方法,所以就需要提供一个中间件/包装类(Wrapper)Adapter类来衔接。不同的是第一幅图Adapter继承自Adaptee,而第二幅图是在Adapter类中包装了一个Adaptee的实例。这就决定了第一幅图讲的是“类的结构模式”,而第二幅图则是“对象的结构模式”。

    桥接模式 Bridge

          桥接模式将抽象部分与它的实现部分分离,是它们都可以独立地变化。它很好的支持了开闭原则和组合锯和复用原则。实现系统可能有多角度分类,每一种分类都有可能变化,那么就把这些多角度分离出来让他们独立变化,减少他们之间的耦合。

          2个相互耦合的系列,每个系列都有各自的产品变动。将这2个系列抽象成2个角色类,将各自的变化封装到对象的角色类中,然后再将2个角色类之间用组合的关系表示,这样就大大简化了使用类继承的复杂性,逻辑变得清晰了,易于扩展和维护。

          桥接模式封装了变化,完成了解耦,实现了弱耦合

    组合模式 Composite

          组合模式将对象组合成树形结构以表示部分-整体的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性。就像“放羊娃的故事”一样(放羊—赚钱—娶妻---生娃—放羊…)。

          廊坊师范学院=14个二级学院+院长、副院长;每一个二级学院=多个专业+二级学院院长、副院长;每一个专业有学生+班委。大学院可以增删二级学院和副院长,二级学院的结构跟大学院几乎一样,所以也可以增删专业和副院长。虽然结构复杂,但是操作简单,只需要进行简单的递归调用即可。

    装饰模式 Decorator

           装饰模式动态地给一个对象添加一些额外的职责,就增加功能来说,它比生成子类更灵活。也可以这样说,装饰模式把复杂类中的核心职责和装饰功能区分开了,这样既简化了复杂类,有去除了相关类中重复的装饰逻辑。装饰模式没有通过继承原有类来扩展功能,但却达到了一样的目的,而且比继承更加灵活,所以可以说装饰模式是继承关系的一种替代方案。

           孙悟空有72变,每一变都可以给他带来一个附加功能,变成鱼可以在水下呼吸,变成鸟可以在天上飞翔。这就是典型的装饰模式。

           装饰模式解耦了核心和装饰功能,锁业也是强调了松耦合 

    外观模式 Facade

           外观模式为子系统中的一组接口提供了同意的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

           外观模式中,客户对各个具体的子系统是不了解的,所以对这些子系统进行了封装,对外只提供了用户所明白的单一而简单的接口,用户直接使用这个接口就可以完成操作,而不用去理睬具体的过程,而且子系统的变化不会影响到用户,这样就做到了信息隐蔽。

           这就相当于新生接待员。新生对入学流程不清楚,但是接待员学长可是明白的。学生跟着接待员就可以把各个手续办理完毕了。

     

    享元模式 Flyweight

          享元模式为运用共享技术有效的支持大量细粒度的对象。因为它可以通过共享大幅度地减少单个实例的数目,避免了大量非常相似类的开销。.

          享元模式是一个类别的多个对象共享这个类别的一个对象,而不是各自再实例化各自的对象。这样就达到了节省内存的目的。 

     代理模式 Proxy

          为其他对象提供一种代理,并由代理对象控制对原对象的引用,以间接控制对原对象的访问。

    我们想上外国的网站,但是国家给限制了,所以我们就需要一个可以登录到外国网站的ip,通过连接到这个ip,再通过这个ip去访问外国网站。

     

    代理模式与外观模式的区别

    代理的客户对象无法直接访问目标对象,代理对象提供对单独目标对象的访问控制,而外观模式的客户对象可以直接访问子系统中的各个对象,但通常由外观对象提供对子系统个元件功能的简化的共同层次的调用接口。

     

    代理模式与适配器的区别

             二者都属于一种衔接性质的功能。代理对象和被代理对象的接口是同一个,但是客户没法直接访问被代理者,只能通过代理对象去完成被代理对象的访问。而适配器模式是将多个子系统封装起来,提供一个统一的外部接口,客户只需要使用这个外部接口即可访问对象的子系统了。

            

    外观跟适配器的区别

             二者都是对显存系统的封装。外观模式定义了一个新的接口,而适配器则是复用了一个原有的接口;适配器是用来适配对象的,而外观则是用来适配整个子系统的。

     

    展开全文
  • 设计模式之外观模式(结构型)

    千次阅读 2019-03-01 00:08:17
    文章目录一、模式定义二、模式角色...,外观模式也称门户模式,是一种对象结构设计模式。 二、模式角色 从模式定义可以知道,外观模式应该包含如下角色: Frcade:外观角色 SubSystem:子系统角色 Client:客户...

    一、模式定义

    外观模式:外观模式就是提供一个统一的接口,用来访问子系统的一群接口。外观模式定义了一个高层接口,让子系统更容易使用。,外观模式也称门面模式,是一种对象结构型设计模式。

    在这里插入图片描述

    二、模式角色

    从模式定义可以知道,外观模式应该包含如下角色:

    • Frcade:外观角色
    • SubSystem:子系统角色
    • Client:客户端角色

    经典例子:

    public class Facade
    {
        private SubSystemA obj1 = new SubSystemA();
        private SubSystemB obj2 = new SubSystemB();
        private SubSystemC obj3 = new SubSystemC();
        public void method()
        {
            obj1.method();
            obj2.method();
            obj3.method();
        }
    } 
    
    

    三、模式简单分析

    外观模式为客户端类提供了便捷,客户端类不需要关注子系统的设计,直接提供外观类访问就好

    外观模式符合“迪米特法则”,引入一个单一简单的接口,给客户端调用,从而降低了客户端和子系统的耦合度

    不过外观模式也有一些缺点,每一种设计模式都是有缺点和优点的,需要根据复杂的业务场景进行选用。假如没引用一个抽象的外观类的话,一旦业务改变就需要进行外观类和客户端类代码的调整了

    在这里插入图片描述

    对于一些很复杂的业务系统来说,有时候可以设计多个外观类进行系统解耦

    四、简单例子实践

    JDBC数据库操作的例子,本例子来自《设计模式》一书

    import java.sql.*;
    
    public class JDBCFacade {
        
        private Connection conn=null;
        private Statement statement=null;
    
        public void open(String driver,String jdbcUrl,String userName,String userPwd) {
            try {
                Class.forName(driver).newInstance();
                conn = DriverManager.getConnection(jdbcUrl,userName,userPwd);
                statement = conn.createStatement();
            } 
            catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public int executeUpdate(String sql) {
            try {
                return statement.executeUpdate(sql);
            } 
            catch (SQLException e) {
                e.printStackTrace();
                return -1;
            }
        }
    
        public ResultSet executeQuery(String sql) {
            try {
                return statement.executeQuery(sql);
            } catch (SQLException e) {
                e.printStackTrace();
                return null;
            }
        }
    
        public void close() {
            try {
                conn.close();
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    

    五、模式应用

    外观模式适用于复杂的系统,可以用于系统解耦。下面简单列举一下外观模式的一些应用场景

    • JavaEE框架里的Session就是用了外观模式

    • 学JSP的JDBC数据库操作也是经常用外观模式的

    展开全文
  • 以下设计模式中,哪一项不属于结构性模式? A 适配器模式 B 代理模式 C 命令模式 D 装饰模式 正确答案 : C知识点创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型...

    美团2016校园招聘 研发工程师(一)
    以下设计模式中,哪一项不属于结构性模式?
    A 适配器模式
    B 代理模式
    C 命令模式
    D 装饰模式

    正确答案 : C


    知识点

    创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

    结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

    行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

    这里写图片描述

    展开全文
  • 设计模式(二)结构型模式

    千次阅读 2018-08-04 20:58:08
    下面列出了所有的设计模式。需要掌握的设计模式我单独列出来了,当然能掌握的越多越好。 总体来说设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 ...

    Java 中一般认为有23 种设计模式,我们不需要所有的都会,但是其中常用的几种设计模式应该去掌握。
    下面列出了所有的设计模式。需要掌握的设计模式我单独列出来了,当然能掌握的越多越好。
    总体来说设计模式分为三大类:
    创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
    结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
    行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

    总结:每一种设计模式,代码去理解实现方式,根据结构图记忆理解。本文没有给出具体代码,可以在码云下载代码使用,本文适合不断翻看理解这些设计模式
    码云代码:https://gitee.com/huopusa/arithmetic.git

    六、适配器模式 adapter

    分类
    类适配器、对象适配器、接口适配器
    UML图
    这里写图片描述
    适配器模式应用场景
    类适配器与对象适配器的使用场景一致,仅仅是实现手段稍有区别,二者主要用于如下场景
    (1)想要使用一个已经存在的类,但是它却不符合现有的接口规范,导致无法直接去访问,这时创建一个适配器就能间接去访问这个类中的方法。
    (2)我们有一个类,想将其设计为可重用的类(可被多处访问),我们可以创建适配器来将这个类来适配其他没有提供合适接口的类。
    接口适配器使用场景:
    1)想要使用接口中的某个或某些方法,但是接口中有太多方法,我们要使用时必须实现接口并实现其中的所有方法,可以使用抽象类来实现接口,并不对方法进行实现(仅置空),然后我们再继承这个抽象类来通过重写想用的方法的方式来实现。这个抽象类就是适配器。
    参照博文:
    https://blog.csdn.net/yujin753/article/details/46287643
    http://www.cnblogs.com/V1haoge/p/6479118.html

    七、装饰器模式 decorator

    https://www.cnblogs.com/jzb-blog/p/6717349.html

    Component为统一接口这里写图片描述,也是装饰类和被装饰类的基本类型。
    ConcreteComponent为具体实现类,也是被装饰类,他本身是个具有一些功能的完整的类。
    Decorator是装饰类,实现了Component接口的同时还在内部维护了一个ConcreteComponent的实例,并可以通过构造函数初始化。而Decorator本身,通常采用默认实现,他的存在仅仅是一个声明:我要生产出一些用于装饰的子类了。而其子类才是赋有具体装饰效果的装饰产品类。
    ConcreteDecorator是具体的装饰产品类,每一种装饰产品都具有特定的装饰效果。可以通过构造器声明装饰哪种类型的ConcreteComponent,从而对其进行装饰。
    优点:
    装饰器模式是一种用于代替继承的技术,无需通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系,更加灵活,同时避免类型体系的快速膨胀。
    代码:

    public interface ICar {
        void move();
    }
    //ConcreteComponent 具体构件角色(真实对象)
    class Car implements ICar {
    
        @Override
        public void move() {
            System.out.println("陆地上跑!");
        }
    
    }
    class SuperCar implements ICar {
        private ICar car;
        public SuperCar(ICar car) {
            this.car = car;
        }
        @Override
        public void move() {
            car.move();
        }
    }
    //ConcreteDecorator具体装饰角色
    class FlyCar extends SuperCar {
        public FlyCar(ICar car) {
            super(car);
        }
        public void fly() {
            System.out.println("天上飞");
        }
        @Override
        public void move() {
            super.move();
            fly();
        }
    }
    //ConcreteDecorator具体装饰角色
    class WaterCar extends SuperCar {
        public WaterCar(ICar car) {
            super(car);
        }
        public void swim() {
            System.out.println("水里游");
        }
        @Override
        public void move() {
            super.move();
            swim();
        }
    }
    //ConcreteDecorator具体装饰角色
    class AICar extends SuperCar {
        public AICar(ICar car) {
            super(car);
        }
        public void autoMove() {
            System.out.println("自动跑");
        }
        @Override
        public void move() {
            super.move();
            autoMove();
        }

    测试客户端:

    public class Client {
        public static void main(String[] args) {
            ICar car = new Car();
            car.move();
    
            System.out.println("------------增加新的功能:飞行");
            ICar flycar = new FlyCar(car);
            flycar.move();
    
            System.out.println("------------增加新的功能:水里游");
            ICar waterCar = new WaterCar(car);
            waterCar.move();
    
            System.out.println("------------增加两个新的功能,飞行,水里游");
            ICar waterCar2 = new WaterCar(flycar);
            waterCar2.move();
    
            System.out.println("------------累加3个新的功能,飞行,水里游,自动驾驶");
            ICar superCar = new AICar(waterCar2);
            superCar.move();
        }
    }

    运行结果:这里写图片描述

    八、代理模式 proxy

    特点:
    1、 执行者、 被代理人
    2、 对于被代理人来说, 这件事情是一定要做的, 但是我自己又不想做或者没有时间做, 找代理。
    3、 需要获取到被代理的人个人资料。
    4、关心过程
    例子:
    租房中介: 中介和你
    火车票黄牛: 黄牛和你
    媒人: 媒婆和你
    明星经纪人: 经纪人和明星 刘德华要开演唱会(长沙) 、 准备工作和善后工作

    AOP中使用场景
    事务代理(声明式事务, 哪个方法需要加事务, 哪个方法不需要加事务)
    日志监听
    假如我们定义了一个service 方法
    开启一个事务(open) 代理来做
    事务的执行 执行我们的service方法
    监听到是否有异常, 可能需要根据异常的类型来决定这个事务是否要回滚还是继续提交 代理来做
    (commit/rollback) 代理来做
    事务要关闭(close) 代理来做

    参照
    https://blog.csdn.net/qq_33214833/article/details/70230891
    注:代理模式应用比较广泛,使代码开发更加灵活

    九、外观模式 Facade (门面模式)

    概念:
    外观模式(Facade),他隐藏了系统的复杂性,并向客户端提供了一个可以访问系统的接口。这种类型的设计模式属于结构性模式。为子系统中的一组接口提供了一个统一的访问接口,这个接口使得子系统更容易被访问或者使用。
    uml图
    这里写图片描述
     简单来说,该模式就是把一些复杂的流程封装成一个接口供给外部用户更简单的使用。这个模式中,设计到3个角色。
      1).门面角色:外观模式的核心。它被客户角色调用,它熟悉子系统的功能。内部根据客户角色的需求预定了几种功能的组合。
      2).子系统角色:实现了子系统的功能。它对客户角色和Facade时未知的。它内部可以有系统内的相互交互,也可以由供外界调用的接口。
      3).客户角色:通过调用Facede来完成要实现的功能
    注:因门面模式Spring+接口调用应用太广泛,没有写具体代码
    十、桥接模式 bridge
    https://www.cnblogs.com/lixiuyu/p/5923160.html

    1.桥接模式的优点
    (1)实现了抽象和实现部分的分离
    桥接模式分离了抽象部分和实现部分,从而极大的提供了系统的灵活性,让抽象部分和实现部分独立开来,分别定义接口,这有助于系统进行分层设计,从而产生更好的结构化系统。对于系统的高层部分,只需要知道抽象部分和实现部分的接口就可以了。
    (2)更好的可扩展性
    由于桥接模式把抽象部分和实现部分分离了,从而分别定义接口,这就使得抽象部分和实现部分可以分别独立扩展,而不会相互影响,大大的提供了系统的可扩展性。
    (3)可动态的切换实现
    由于桥接模式实现了抽象和实现的分离,所以在实现桥接模式时,就可以实现动态的选择和使用具体的实现。
    (4)实现细节对客户端透明,可以对用户隐藏实现细节。
    2.桥接模式的缺点
    (1)桥接模式的引入增加了系统的理解和设计难度,由于聚合关联关系建立在抽象层,要求开发者针对抽象进行设计和编程。
    (2)桥接模式要求正确识别出系统中两个独立变化的维度,因此其使用范围有一定的局限性。
    3.桥接模式的使用场景
    (1)如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性,避免在两个层次之间建立静态的继承联系,通过桥接模式可以使它们在抽象层建立一个关联关系。
    (2)抽象化角色和实现化角色可以以继承的方式独立扩展而互不影响,在程序运行时可以动态将一个抽象化子类的对象和一个实现化子类的对象进行组合,即系统需要对抽象化角色和实现化角色进行动态耦合。
    (3)一个类存在两个独立变化的维度,且这两个维度都需要进行扩展。
    (4)虽然在系统中使用继承是没有问题的,但是由于抽象化角色和具体化角色需要独立变化,设计要求需要独立管理这两者。
    (5)对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统,桥接模式尤为适用
    代码

    /**
     * 定义接口--被实现者
     */
    public interface Implementor {
        public void operation();
    }
    /**
     * 实现者A
     */
    public class ConcreateImplementorA implements Implementor {
        @Override
        public void operation() {
            System.out.println("这个是ConcreateImplementorA的operation方法");
        }
    }
    /**
     * 实现者B
     */
    public class ConcreateImplementorB implements Implementor {
        @Override
        public void operation() {
            System.out.println("这个是ConcreateImplementorB的operation方法");
        }
    }
    /**
     *  桥接类
     */
    public abstract class Abstraction {
        private Implementor implementor;
        public Implementor getImplementor() {
            return implementor;
        }
        public void setImplementor(Implementor implementor){
            this.implementor = implementor;
        }
        // 引用接口
        protected void operation(){
            implementor.operation();
        }
    }
    /**
     * 桥接实现类
     */
    public class RefinedAbstraction extends Abstraction {
        @Override
        protected void operation() {
            super.operation();
        }
    }
    /**
     * client 调用测试
     */
    public class BridgeTest {
        public static void main(String[] args) {
            Abstraction abstraction = new RefinedAbstraction();
    
            //调用第一个实现类
            abstraction.setImplementor(new ConcreateImplementorA());
            abstraction.operation();
    
            //调用第二个实现类
            abstraction.setImplementor(new ConcreateImplementorB());
            abstraction.operation();
        }
    }

    十一、组合模式 Composite

    1、UML结构
    这里写图片描述

    实例图这里写图片描述

    2、角色组成
    抽象构件角色(component):是组合中的对象声明接口,在适当的情况下,实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。这个接口可 以用来管理所有的子对象。(可选)在递归结构中定义一个接口,用于访问一个父部件,并在合适的情况下实现它。
    树叶构件角色(Leaf):在组合树中表示叶节点对象,叶节点没有子节点。并在组合中定义图元对象的行为。
    树枝构件角色(Composite):定义有子部件的那些部件的行为。存储子部件。在Component接口中实现与子部件有关的操作。
    客户角色(Client):通过component接口操纵组合部件的对象。

    3、组合模式的优缺点
    优点:
    组合模式使得客户端代码可以一致地处理对象和对象容器,无需关系处理的单个对象,还是组合的对象容器。
    将”客户代码与复杂的对象容器结构“解耦。
    可以更容易地往组合对象中加入新的构件。
    缺点: 使得设计更加复杂。客户端需要花更多时间理清类之间的层次关系。(这个是几乎所有设计模式所面临的问题)。
    注意的问题:
    有时候系统需要遍历一个树枝结构的子构件很多次,这时候可以考虑把遍历子构件的结构存储在父构件里面作为缓存。
    客户端尽量不要直接调用树叶类中的方法(在我上面实现就是这样的,创建的是一个树枝的具体对象;),而是借用其父类(Graphics)的多态性完成调用,这样可以增加代码的复用性。
    4、组合模式的使用场景
    在以下情况下应该考虑使用组合模式:
    当想表达对象的部分-整体的层次结构时。
    希望用户忽略组合对象与单个对象的不同,用户将统一地使用组合结构中的所有对象时。
    参考:https://www.cnblogs.com/snaildev/p/7647190.html

    十二、享元模式 Flyweight Pattern

    http://www.cnblogs.com/java-my-life/archive/2012/04/26/2468499.html
    享元模式:以共享的方式高效的支持大量的细粒度对象。通过复用内存中已存在的对象,降低系统创建对象实例的性能消耗。
    java的 String 类型就是享元模式
    这里写图片描述
    单纯享元模式所涉及到的角色如下:
      ●  抽象享元(Flyweight)角色 :给出一个抽象接口,以规定出所有具体享元角色需要实现的方法。
      ●  具体享元(ConcreteFlyweight)角色:实现抽象享元角色所规定出的接口。如果有内蕴状态的话,必须负责为内蕴状态提供存储空间。
      ●  享元工厂(FlyweightFactory)角色 :本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候,享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了,享元工厂角色就应当提供这个已有的享元对象;如果系统中没有一个适当的享元对象的话,享元工厂角色就应当创建一个合适的享元对象。
    复合享元角色所涉及到的角色如下:
      ●  抽象享元(Flyweight)角色 :给出一个抽象接口,以规定出所有具体享元角色需要实现的方法。
      ●  具体享元(ConcreteFlyweight)角色:实现抽象享元角色所规定出的接口。如果有内蕴状态的话,必须负责为内蕴状态提供存储空间。
      ●  复合享元(ConcreteCompositeFlyweight)角色 :复合享元角色所代表的对象是不可以共享的,但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称作不可共享的享元对象。
      ●  享元工厂(FlyweightFactory)角色 :本角 色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候,享元工厂角色会检查系统中是否已经有 一个符合要求的享元对象。如果已经有了,享元工厂角色就应当提供这个已有的享元对象;如果系统中没有一个适当的享元对象的话,享元工厂角色就应当创建一个 合适的享元对象。
    享元模式的优缺点
      享元模式的优点在于它大幅度地降低内存中对象的数量。但是,它做到这一点所付出的代价也是很高的:
      ●  享元模式使得系统更加复杂。为了使对象可以共享,需要将一些状态外部化,这使得程序的逻辑复杂化。
      ●  享元模式将享元对象的状态外部化,而读取外部状态使得运行时间稍微变长。

    享元模式实例
    其实在Java中就存在这种类型的实例:String。
    Java中将String类定义为final(不可改变的),JVM中字符串一般保存在字符串常量池中,这个字符串常量池在jdk 6.0以前是位于常量池中,位于永久代,而在JDK 7.0中,JVM将其从永久代拿出来放置于堆中。
      我们使用如下代码定义的两个字符串指向的其实是同一个字符串常量池中的字符串值。

    String s1 = "abc";
    String s2 = "abc";

    如果我们以s1==s2进行比较的话所得结果为:true,因为s1和s2保存的是字符串常量池中的同一个字符串地址。这就类似于我们今天所讲述的享元模式,字符串一旦定义之后就可以被共享使用,因为他们是不可改变的,同时被多处调用也不会存在任何隐患。
    享元模式使用的场景:
        当我们项目中创建很多对象,而且这些对象存在许多相同模块,这时,我们可以将这些相同的模块提取出来采用享元模式生成单一对象,再使用这个对象与之前的诸多对象进行配合使用,这样无疑会节省很多空间。

    参照例子(更加形象的例子):https://www.cnblogs.com/V1haoge/p/6542449.html

    展开全文
  • 常用设计模式总结

    万次阅读 多人点赞 2019-07-31 19:13:12
    设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结,是可复用面向对象软件的基础。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 ...
  • 设计模式——结构型模型

    千次阅读 2019-04-23 18:23:33
    1. 装饰者模式(Decorator) 2. 代理模式(Proxy) 3. 组合模式(Composite) 4. 桥接模式(Bridge) 5. 适配器模式(Adapter) 6. 蝇量模式(Flyweight) 7. 外观模式(Facade)
  • 设计模式之享元模式(结构型)

    千次阅读 2019-01-05 23:34:49
    按照Gof模式分类,享元模式属于对象结构型模式。 模式解释 可以共享的内容称为内部状态(Intrinsic State),需要外部环境设置的不能共享的内容称为外部状态(Extrinsic State)。享元模式需要创建一个享元工...
  • 这种类型的设计模式属于结构型模式,它创建了对象组的树形结构。这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。我们通过下面的实例来演示组合模式的用法。实例演示了一个组织中员工的层次...
  • 这种类型的设计模式属于结构型模式,它结合了两个独立接口的功能。这种模式涉及到一个单一的类,该类负责加入独立的或不兼容的接口功能。举个真实的例子,读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入...
  • javascript设计模式之装饰器模式 js的设计模式分为创建型模式,结构型模式和行为模式结构模式描述了 如何组合对象以提供新的功能。装饰器模式是一种常见的结构型模式,我们可以以一个基础对象为基础,来给它加上若干...
  • 这种类型的设计模式属于结构型模式,它通过提供抽象化和实现化之间的桥接结构,来实现二者的解耦。这种模式涉及到一个作为桥接的接口,使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。...
  • 桥接模式是一种很实用的结构设计模式,如果软件系统中某个类存在多个独立变化的维度,通过该模式可以将这多个维度分离出来,使他们可以独立扩展,让系统更加符合“单一职责原则”。与多层继承方案不同,它将多个...
  • 这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。我们通过下面的实例来演示装饰器模式的用法。...
  • 博主在大三的时候有上过...总体来说设计模式分为三大类:创建型模式、结构型模式和行为型模式。博主的上一篇文章已经提到过创建型模式,此外该文章还有设计模式概况和设计模式的六大原则。设计模式的六大原则是设计模式
  • 设计模式总结之结构型模式

    千次阅读 热门讨论 2014-05-24 17:28:39
    设计模式中,结构设计模式分为:
  • Java设计模式_(结构型)_适配器模式

    万次阅读 2017-09-21 15:54:39
    引用百科 在计算机编程中,适配器模式(有时候也称包装样式或者包装)将一个类的接口适配成用户所期待的。一个适配允许通常因为接口不兼容而不能在一起工作的类工作在一起,做法是将类自己的接口包裹在一个已存在的...
  • 结构模式包括7种:适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式、代理模式。本文主要介绍适配器模式和桥接模式。一、适配器模式(Adapter) 适配器模式其实很简单,就像手机充电器一样,手机需要5V...
  • 在GOF《设计模式》中,对结构设计模式进行了分析和七种具体模式的整理,通过学习、实践和思考之后,我发现似乎可以对结构型模式进行更深入的概括,下面把我的理解描述如下,希望各位同样对设计模式感兴趣的朋友...
  • MVC设计模式和三层结构(适合初学者)

    千次阅读 多人点赞 2019-05-06 22:27:50
    我们经常把MVC模式和三层架构联系在一起,一旦让你谈谈MVC设计模式,不可避免的总是会说到三层架构,这对于一些高手和大佬来说并没有什么问题,但是对于一些新手,想要学习MVC设计模式的小白来说,有时候就不太友好...
  • 数据结构&设计模式

    千次阅读 2020-06-23 10:46:34
    动态代理有几种实现? java的动态代理技术的实现主要有两种方式: 1.JDK原生动态代理 2.CGLIB动态代理 JDK原生动态代理是Java原生支持的,...常见的数据结构有哪些? 问题回答: 一共八大数据结构分类 1.数组 2.队列
  • 设计模式

    千次阅读 多人点赞 2019-07-22 09:33:22
    设计模式简介 设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过...
  • 我们接着讨论设计模式,上篇文章我讲完了5种创建型模式,这章开始,我将讲下7种结构型模式:适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源,我们...
  • 设计模式 | 适配器模式及典型应用

    万次阅读 多人点赞 2018-09-20 01:37:29
    适配器模式既可以作为类结构模式,也可以作为对象结构模式。 在适配器模式中,我们通过增加一个新的适配器类来解决接口不兼容的问题,使得原本没有任何关系的类可以协同工作。 根据适配器类与适配者类的关系不同...
  • https://www.nowcoder.com/questionTerminal/84f67b12ab674010a1530df559c97e20?toCommentId=134868
  • 博主在大三的时候有上过...总体来说设计模式分为三大类:创建型模式、结构型模式和行为型模式。博主的上一篇文章已经提到过创建型模式,此外该文章还有设计模式概况和设计模式的六大原则。设计模式的六大原则是设计模式
  • 使用设计模式改善程序结构(一)

    千次阅读 2007-11-02 16:24:00
    但是,如果想要真正使设计模式发挥最大作用,仅仅知道设计模式是什么,以及它是如何实现的是很不够的,因为那样就不能使你对于设计模式有真正的理解,也就不能够在自己的设计中正确、恰当的使用设计模式。...
  • 设计模式(九)外观模式Facade(结构型)

    万次阅读 多人点赞 2012-05-04 16:59:54
    设计模式--外观模式Facade(结构型): 1. 概述  外观模式,我们通过外观的包装,使应用程序只能看到外观对象,而不会看到具体的细节对象,这样无疑会降低应用程序的复杂度,并且提高了程序的可维护性。 例子...
  • JAVA设计模式初探之装饰者模式

    万次阅读 多人点赞 2014-04-01 09:07:37
    设计初衷:通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 446,421
精华内容 178,568
关键字:

下面设计模式属于结构模式