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

    千次阅读 2015-03-03 22:51:57
    结构型设计模式 1、享元模式 2、外观模式 3、组合模式 4、桥梁模式 5、装饰模式 6、代理模式 7、适配器模式

    结构型设计模式


    1、享元模式


    2、外观模式


    3、组合模式


    4、桥梁模式


    5、装饰模式


    6、代理模式


    7、适配器模式

    展开全文
  • 主要介绍了Java结构型设计模式中的适配器模式与桥接模式,结构型设计模式是从程序的结构上解决模块之间的耦合问题,需要的朋友可以参考下
  • 结构型设计模式总结

    2020-08-04 07:50:00
    结构型设计模式总结Intro前面几篇文章已经介绍完了所有的结构型设计模式,来做一个总结结构型设计模式主要总结了一些类或对象组合在一起的经典结构,这些经典的结构可以解决一些特定应用场景的问...

    结构型设计模式总结

    Intro

    前面几篇文章已经介绍完了所有的结构型设计模式,来做一个总结

    结构型设计模式主要总结了一些类或对象组合在一起的经典结构,这些经典的结构可以解决一些特定应用场景的问题。

    结构型模式包括:代理模式、桥接模式、装饰器模式、适配器模式、外观(门面)模式、组合模式、享元模式。

    总结

    适配器模式(Adapter)

    适配一下不兼容的接口,work together

    桥接模式(Bridge)

    将抽象部分与它的实现部分分离,使得它们都可以独立地变化。

    组合模式(Composite)

    将对象组合成树形结构以表示 “部分-整体” 的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性

    装饰模式(Decorator)

    动态地给一个对象添加一些额外的职责和功能

    外观/门面模式(Facade)

    定义一组高层接口让子系统更易用

    享元模式(Flyweight)

    复用对象,减少内存占用

    代理模式(Proxy)

    由代理对象控制对原对象的引用

    More

    可以描述成树形结构的父子关系用组合

    分离抽象和实现独立变化用桥接

    增加额外功能职责用装饰

    控制访问用代理

    复用对象用享元

    封装底层子系统接口用外观、门面

    兼容老系统接口用适配器

    Reference

    展开全文
  • C#设计模式之【结构型设计模式:组合模式】 组合模式(Composite Pattern),又叫部分整体模式,是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象,用来表示部分以及整体层次。这种类型的...

    C#设计模式之【结构型设计模式:组合模式】

    一.组合模式简述

      组合模式(Composite Pattern),又叫部分整体模式,是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象,用来表示部分以及整体层次。这种类型的设计模式属于结构型模式,它创建了对象组的树形结构。
      这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。

      UML图:
    在这里插入图片描述

    二.代码示例

      我们的目标要实现下图的组织架构关系:

    在这里插入图片描述
      分析得知:Composite对象(有子节点)为:LDG科技公司,产品部,业务部,研发部,其余为Leaf对象(没有子节点)

      抽象类代码:

      public abstract  class AbstractDepartment
        {
            /// <summary>
            /// 部门名称
            /// </summary>
            protected string _departmentName;
    
            public AbstractDepartment(string departmentName)
            {
                _departmentName = departmentName;
            }
    
            /// <summary>
            /// 添加子节点的方法
            /// </summary>
            public abstract void AddChildren(AbstractDepartment company);
    
            /// <summary>
            /// 删除子节点的方法
            /// </summary>
            public abstract void RemoveChildren(AbstractDepartment company);
    
            /// <summary>
            /// 获取子节点数据
            /// </summary>
            public abstract List<AbstractDepartment> GetChildren();
    
            /// <summary>
            /// 获取部门名称
            /// </summary>
            public abstract string GetdepartmentName();      
    
        }
    

      Leaf类代码:

        /// <summary>
        /// Leaf类
        /// </summary>
        public class LeafDepartment : AbstractDepartment
        {
            public LeafDepartment(string departmentName)
                : base(departmentName)
            {
    
            }
            public override void AddChildren(AbstractDepartment company)
            {
                throw new Exception("没有子节点,不能AddChild");
            }
    
            public override List<AbstractDepartment> GetChildren()
            {
                return null;
            }
    
            public override void RemoveChildren(AbstractDepartment company)
            {
                throw new Exception("没有子节点,不能RemoveChildren");
            }
    
            public override string GetdepartmentName()
            {
                return this._departmentName;
            }
        }
    

      Composite类代码:

        /// <summary>
        /// Composite类
        /// </summary>
        public class CompositeDepartment : AbstractDepartment
        {
    
             private  List<AbstractDepartment> list = new List<AbstractDepartment>();
    
            public CompositeDepartment(string departmentName) 
                : base(departmentName)
            {
    
            }
    
            public override void AddChildren(AbstractDepartment department)
            {
                list.Add(department);
            }
    
            public override void RemoveChildren(AbstractDepartment department)
            {
                list.Remove(department);
            }
    
            public override List<AbstractDepartment> GetChildren()
            {
    
                return list;
            }
            public override string GetdepartmentName()
            {
                return _departmentName;
            }
        }
    

      运行结果–>递归输出树形结构:

    在这里插入图片描述

      递归代码:

            public static void FindChildren(AbstractDepartment acompositeDepartment,int intA)
            {
                if (acompositeDepartment.GetChildren() == null)
                {
                    //说明没有子节点     
                  
                }
                else
                {
                    //说明有子节点          
                    foreach (var item in acompositeDepartment.GetChildren())
                    {      
                        for (int i = 0; i < intA; i++)
                        {
                            Console.Write("--");
                        }
                        Console.WriteLine($"{item.GetdepartmentName()}");                
                        FindChildren(item,intA+1);
                    }
    
                }
            }
    

    三.总结

    意图: 将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

    主要解决: 它在我们树型结构的问题中,模糊了简单元素和复杂元素的概念,客户程序可以像处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

    何时使用: 1、您想表示对象的部分-整体层次结构(树形结构)。 2、您希望用户忽略组合对象与单个对象的不同,用户将统一地使用组合结构中的所有对象。

    如何解决: 树枝和叶子实现统一接口,树枝内部组合该接口。

    优点: 1、高层模块调用简单。 2、节点自由增加。

    缺点: 在使用组合模式时,其叶子和树枝的声明都是实现类,而不是接口,违反了依赖倒置原则

    使用场景:部分、整体场景,如树形菜单,文件、文件夹的管理。

      
      
      
      
      
      

    展开全文
  • 介绍Java结构型设计模式 本文我们聚焦java中实现结构设计模式,讨论它们是什么以及它们之间的基本差异。 设计模式分类 根据GOF对设计模式的分类,有三种: 创建型模式 结果型模式 行为型模式 简言之,...

    介绍Java结构型设计模式

    本文我们聚焦java中实现结构设计模式,讨论它们是什么以及它们之间的基本差异。

    设计模式分类

    根据GOF对设计模式的分类,有三种:

    1. 创建型模式
    2. 结果型模式
    3. 行为型模式

    简言之,结构模式处理类和对象的组合。它们提供不同方式使用对象组合和继承创建一些抽象。属于结构型模式有代理模式,装饰模式,适配器模式,桥接模式,门面模式享元模式组合模式

    代理模式

    通过该模式,我们创建媒介作为其他资源的接口,如文件、连接。这种辅助方式作为真正组件的代理,隐藏底层的复杂性。

    示例

    假设有一个需要初始化配置的大对象(如JDBC连接或SessionFactory)。这样对象一旦被初始化后,希望后续调用可以重用:

    uml

    下面创建一个简单接口,用于配置该对象:

    public interface ExpensiveObject {
        void process();
    }
    

    然后实现该接口,带有繁重的初始化配置:

    public class ExpensiveObjectImpl implements ExpensiveObject {
     
        public ExpensiveObjectImpl() {
            heavyInitialConfiguration();
        }
         
        @Override
        public void process() {
            LOG.info("processing complete.");
        }
         
        private void heavyInitialConfiguration() {
            LOG.info("Loading initial configuration...");
        }
         
    }
    

    现在利用代理模式根据需要初始化对象:

    public class ExpensiveObjectProxy implements ExpensiveObject {
        private static ExpensiveObject object;
     
        @Override
        public void process() {
            if (object == null) {
                object = new ExpensiveObjectImpl();
            }
            object.process();
        }
    }
    

    无论什么时间客户端调用process方法,它们仅能看到方法调用,而初始化配置总是被隐藏:

    public static void main(String[] args) {
        ExpensiveObject object = new ExpensiveObjectProxy();
        object.process();
        object.process();
    }
    

    注意当调用process方法两次,背后初始化部分仅执行一次,即对象初始化。后续每次调用,该模式会跳过初始化过程,仅调用process方法:

    Loading initial configuration...
    processing complete.
    processing complete.
    

    什么时候使用代理模式

    理解如何使用模式很重要,但理解什么时候使用时关键的。下面讨论什么时候使用代理模式:

    • 当我们想简化复杂或繁重对象时。这时我们可以使用框架对象表示原始对象,其根据需要加载原始对象,也称为懒加载。即所谓虚拟代理。

    • 当原始对象在不同的地址空间中,我们想在本地表示它。可以创建其代理负责执行所有必要的例行操作,如创建和维护连接、编码、解码等。当客户端访问它时,它存在本地地址空间中。这称为远程代理。

    • 当我们想要在原始基础对象上添加一层安全性,以便基于客户机的访问权限提供受控访问时。这称为保护代理。

    关键差异

    • 代理提供与原理对象相同接口,其包括对原始对象的引用,但它不会以任何方式修改数据;与适配器和装饰器模式相反,它们两者分别更改和装饰已有实例的功能。

    • 代理通常在编译时拥有关于实际主题的信息,而装饰器和适配器则在运行时被注入,只知道实际对象的接口。

    装饰模式

    该模式用于增强一个对象的行为。详细内容请看这篇博文。

    关键差异包括下面几点:

    • 虽然代理和装饰器模式有类似的结构,但它们的意图不同。代理模式首要目的是便于使用或控制访问,装饰模式是增加额外的功能。
    • 两者都持有原始对象的引用。
    • 装饰器模式中装饰元素可以递归使用,不限制次数,而其他模式不能。

    适配器模式

    适配器模式用于连接两个不兼容接口,否则两者不能直接连接。适配器使用新的接口包装已经存在的类,这样使其兼容称为我们需要的接口。详细描述可以查看介绍java适配器短文。

    适配器与代理模式的主要差异点为:

    • 虽然代理模式提供了相同的接口,但适配器模式提供了与其客户机兼容的不同接口。
    • 适配器模式在应用组件已经设计好之后使用,因此可以不修改源码进行使用。这与桥接模式相反,其一般在组件设计之前使用。

    桥接模式

    GOF官方定义桥接模式为将抽象与其实现解耦,以便两者能够独立地变化。
    这意味着使用OOP原则创建一个将职责划分为不同抽象类的桥接接口。

    示例

    对于Bridge模式,我们将考虑两个抽象层;一个是几何形状(如三角形和正方形),填充了不同的颜色(我们的第二个抽象层):

    uml img

    首先定义color接口:

    public interface Color {
        String fill();
    }
    

    然后定义接口的实现类:

    public class Blue implements Color {
        @Override
        public String fill() {
            return "Color is Blue";
        }
    }
    

    现在创建抽象Shape类,其包含一个color对象引用(桥接):

    public abstract class Shape {
        protected Color color;
         
        //standard constructors
         
        abstract public String draw();
    }
    

    现在创建Shape的具体实现类,其也利用Color接口的方法:

    public class Square extends Shape {
     
        public Square(Color color) {
            super(color);
        }
     
        @Override
        public String draw() {
            return "Square drawn. " + color.fill();
        }
    }
    

    测试该模式,下面测试代码返回true:

    @Test
    public void whenBridgePatternInvoked_thenConfigSuccess() {
        //a square with red color
        Shape square = new Square(new Red());
      
        assertEquals(square.draw(), "Square drawn. Color is Red");
    }
    

    这里我们使用桥接模式并传入期望的color对象。通过输出信息shape使用期望的color进行绘制:

    Square drawn. Color: Red
    Triangle drawn. Color: Blue
    

    什么时候使用桥接模式

    • 当我们想要父抽象类定义一组基础规则,具体实现类增加额外规则时。
    • 当我们有一个抽象类,它有一个对象引用,并且它有抽象方法,这些方法将在每个具体类中重载。

    关键差异点

    • 桥接模式仅在应用设计之前被实现。
    • 桥接模式允许抽象和实现独立更改,而适配器模式是不兼容类可以连接成为可能。

    总结

    本文我们聚焦结构型模式并对比分析它们之间差异。

    展开全文
  • 结构型设计模式可以分为两种模式: 一、结构型类模式 二、结构型对象模式 结构型设计模式 结构型设计模式着重的是如何组合类和对象以获得更大的结构,该模式有助于多个独立开发的类库协同工作。 (1)...
  • 结构型设计模式:类与类之间的关系
  • 结构型模式(Structural Pattern)描述如何将类或者对象结合在一起形成更大的结构,就像搭积木,可以通过简单积木的组合形成复杂的、功能更为强大的结构。 结构型模式可以分为类结构型模式和对象结构型模式: 类结构...
  • 转载请注明来源: 邓占勇的个人博客 - 《JavaScript设计模式(5)—— 结构型设计模式【1】》 本文链接地址: https://www.dzyong.com/#/ViewArticle/90 设计模式系列博客:JavaScript设计模式系列目录(持续更新中...
  • 结构型设计模式;组合模式(Composite Pattern)将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。组合模式(Composite Pattern)属于结构型模式。结构型...
  • 结构型设计模式;外观模式(Facade Pattern)为子系统中的一组接口提供一个一致的界面, Facade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。外观模式(Facade Pattern)属于结构型模式。结构型模式...
  • 结构型设计模式;适配器模式(Adapter Pattern)将一个类的接口转换成客户希望的另外一个接口。 Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 适配器模式(Adapter Pattern)属于结构型...
  • 结构型设计模式;代理模式(Proxy Pattern)为访问对象提供一个代理对象来实现对被访问者的访问,其实就是在访问对象与被访问对象之间添加一个中介,用来隔离访问者与被访问者的具体实现细节。 代理模式(Proxy ...
  • 结构型设计模式;享元模式(Flyweight Pattern)运用共享技术有效地支持大量细粒度的对象。Flyweight模式即享元模式。 享元模式(Flyweight Pattern)属于结构型模式。结构型模式涉及到如何组合类和对象以获得更大的...
  • 结构型设计模式;装饰器模式(Decorator Pattern)Decorator模式能动态地给一个对象添加一些额外的职责。就增加功能来说, Decorator模式相比生成子类更为灵活。装饰器模式(Decorator Pattern)属于结构型模式,又称为...
  • 结构型设计模式旨在从程序的结构上解决模块与模块间的耦合。它们包括适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式和享元模式。 (二)区别 1)配置器模式、装饰模式、代理模式与外观模式的比较 ...
  • 认识结构型设计模式(通过各设计模式的定义、类图案例设计、简单程序实现、应用场景以及使用案例) 共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中适配器模式主要分为三...
  • 创建型设计模式&结构型设计模式

    热门讨论 2016-02-01 21:34:13
    也看了很多人的总结,有看到“设计模式不是模型,设计模式不是用来严格遵守的,并非一成不变,设计模式最核心的是要素不是设计的结构,而是设计的思想。” 应用设计模式会让程序变得更加灵活,模块之间的耦
  • 结构型设计模式涉及到如何组合类和对象以获得更大的结构;行为型设计模式描述算法和对象间职责的分配。 那么,结构型设计模式到底如何对类和对象进行组合,以获得更大的结构,组合的指引是什么呢?Adapter/Bridge/...
  • 设计模式总览 创建 对对象的创建过程进行封装,抽象了对象的实例化过程 如: 单例模式,工厂模式,建造者模式,原型模式,抽象工厂模式 行为 行为模式是对在不同的对象之间划分责任和算法的抽象化,行为模式...
  • Golf 四人组 定义的设计模式有23种,创建型的5种,结构型的7种,行为的11种; 关于结构型的7种模式如下: 1. 接口Adapter 2. 桥接Birdge 3. 组合Composite 4. 装饰Decorator 5. 外观Fasade 6. FlyWeight享元 7...
  • 设计模式:结构型设计模式(下)

    千次阅读 2019-12-30 21:14:15
    * 装饰模式在不改变原有类结构的情况下向现有对象添加新功能 * 使用一个会变颜色的圆圈来举例 */ public class DecoratingMode { public static void main(String[] args) { Shape circle = new ...
  • 结构型设计模式的理解

    千次阅读 2008-01-30 15:28:00
    结构型设计模式涉及到如何组合类和对象以获得更大的结构;行为型设计模式描述算法和对象间职责的分配。 那么,结构型设计模式到底如何对类和对象进行组合,以获得更大的结构,组合的指引是什么呢?Adapter/Bridge/...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,651
精华内容 9,060
关键字:

结构型设计模式