23种设计模式之结构型

最新推荐文章于 2024-07-17 08:18:37 发布
最新推荐文章于 2024-07-17 08:18:37 发布
阅读量930 收藏 3
点赞数
分类专栏： 23种设计模式 文章标签： 设计模式七种结构型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44241551/article/details/96033649
版权

结构型


关于设计模式介绍 23种设计模式之创建型有讲述
上篇文章讲解了5种创建型模式，这章将讲解7种结构型模式。

七种结构型模式

适配器模式，装饰模式，代理模式，外观模式，桥接模式，组合模式，享元模式。

其中对象的适配器模式是各种模式的起源，看图分析：

1.适配器模式(Adapter)

在这里插入图片描述

概念

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题

主要分为三大类

类的适配器模式，对象的适配器模式，接口的适配器模式。

类的适配器模式

看图分析：
在这里插入图片描述

核心思想：有一个Source类，拥有一个方法，待适配，目标接口是Targetable，通过Adapter类，将Source的功能扩展到Targetable里。

代码演示：
Source:

package com.myy.adapter;

public class Source {

	public void method1() {
		System.out.println("这是最初的method1");
	}
}

Targetable:

package com.myy.adapter;

public interface Targetable {

	//与原类中的方法相同
	public void method1();
	
	//新类的方法
	public void method2();
}

Adapter类继承Source类，实现Targetable接口：

package com.myy.adapter;

public class Adapter extends Source implements Targetable{

	@Override
	public void method2() {
		// TODO Auto-generated method stub
		System.out.println("这是Targetable的method1");
	}

}

测试类AdapterTest：

package com.myy.adapter;

public class AdapterTest {

	public static void main(String[] args) {
		Targetable target = new Adapter();
		target.method1();
		target.method2();
	}
}

运行结果：
在这里插入图片描述

这样Targetable接口的实现类就具有了Source类的功能

对象的适配器模式

基本思路和类的适配器模式相同，只是将Adapter类做修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。看图:
在这里插入图片描述
代码演示:
只要修改Adapter类的源码即可：

package com.myy.adapter;

public class Wrapper  implements Targetable{

	
	private Source source;
	
	
	public Wrapper(Source source) {
		super();
		this.source = source;
	}

	public void method2() {
		System.out.println("这是Targetable的method1");
	}

	public void method1() {
		source.method1();
	}

}

测试：

package com.myy.adapter;

public class AdapterTest {

	public static void main(String[] args) {
		Source source = new Source();
		Targetable target = new Wrapper(source);
		target.method1();
		target.method2();
	}
}

运行结果：
在这里插入图片描述

和第一种一样，只是适配的方法不同而已。

接口的适配器模式

概念
有时我们写一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和改抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。看类图：
在这里插入图片描述
在实际开发中，我们也常会遇到这种接口中定义了太多的方法，以至于有时我们在一些实现类中并不是都需要。

代码演示：
Sourceable ：

package com.myy.adapter;

public interface Sourceable {

	public void method1();
	public void method2();
}

抽象类Wrapper2 ：

package com.myy.adapter;

public abstract class Wrapper2 implements Sourceable{

	public void method1() {}
	public void method2() {}
}

SourceSub1 ：

package com.myy.adapter;

public class SourceSub1 extends Wrapper2{
 public void method1() {
	 System.out.println("这是Sourceable 接口的第一个Sub1");
 }
}

SourceSub2 ：

package com.myy.adapter;

public class SourceSub2 extends Wrapper2{
 public void method2() {
	 System.out.println("这是Sourceable 接口的第二个 Sub2");
 }
}

WrapperTest：

package com.myy.adapter;

public class WrapperTest {
 public static void main(String[] args) {
	  Sourceable source1 = new SourceSub1();
	  Sourceable source2 = new SourceSub2();
	  
	  source1.method1();
	  source1.method2();
	  source2.method1();
	  source2.method2();
}
  
  
}

运行结果：
在这里插入图片描述

三种适配器模式的应用场景

类的适配器模式

当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。

对象的适配器模式

当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。

接口的适配器模式

当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper,实现所有方法，我们写别的类的时候，继承抽象类即可.

2.装饰模式(Decorator)

概念

在不改变原来类的情况下，进行扩展。

装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

关系图如下：
在这里插入图片描述
Source类时被装饰类，Decorator类是一个装饰类，可以为Source类动态的添加一些功能，代码如下：
Sourceable ：

package com.myy.Decorator;

public interface Sourceable {
 public void method();
}

Source ：

package com.myy.Decorator;

public class Source implements Sourceable{

	@Override
	public void method() {
		System.out.println("这是最初的method");
	}

}

Decorator ：

package com.myy.Decorator;

public class Decorator implements Sourceable{

	private Sourceable source;
	
	public Decorator(Sourceable source) {
		super();
		this.source = source;
	}

	@Override
	public void method() {
       System.out.println("之前的Decorator");		
       source.method();
       System.out.println("之后的Decorator");		
	}
	

}

测试类DecoratorTest ：

package com.myy.Decorator;

public class DecoratorTest {
  public static void main(String[] args) {
	Sourceable source = new Source();
	Sourceable obj = new Decorator(source);
	obj.method();
}
}

运行结果：
在这里插入图片描述

装饰器模式的应用场景

1.需要扩展一个类的功能
2.动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能柜台增删）
缺点：产生过多相似的对象，不易排除

3.代理模式（Proxy）

概念

其实每个模式名称就表明了该模式的作用，**代理模式就是多一个代理类出来，替原对象进行一些操作。比如我们在租房的时候会去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。

关系图：
在这里插入图片描述
代码演示：
Sourceable ：

package com.myy.proxy;

public interface Sourceable {
	 public void method(); 
}

Sourceable：

package com.myy.proxy;

public class Proxy implements Sourceable{

	private Source source; 
	
    public Proxy(){  
        super();  
        this.source = new Source();  
    }  
    
	public void method() {
		 before();  
	     source.method();  
	     after();  
	}

	private void after() {  
        System.out.println("之后 proxy!");  
    }  
    private void before() {  
        System.out.println("之前 proxy!");  
    }  
}

测试类ProxyTest：

package com.myy.proxy;

public class ProxyTest {
  public static void main(String[] args) {
	  Sourceable source = new Proxy();  
      source.method();  
}
}

运行结果：
在这里插入图片描述

代理模式的应用场景

如果已有方法在使用的时候需要对原有的方法进行改进，此时两种方法：
1.修改原有的方法来适应。这样违反了“对扩展开发，对修改关闭”的原则
2.就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

使用代理模式，可以将功能划分的更加清晰，有助于后期维护。

4.桥接模式(Bridge)

概念

这个模式使用的并不多，但思想确实很普通。就是要分离抽象部分与现实部分。
实现弱关联，即在运行时才产生依赖关系。
降低代码之间的耦合。

生活中桥接模式

就拿汽车在路上行驶的来说。即有小汽车又有公交汽车，它们都不但能在市区中的各路上行驶，也能在高速公路上行驶。这你会发现，对于交通工具(汽车)有不同的类型，然而它们所行驶的环境(路)也在变化，在软件系统中适应两个方面的变化？怎样实现才能应对这种变化？

使用场景

  1. 不希望在抽象和它的实现部分之间有一个固定的绑定关系
  2. 抽象部分以及实现部分都通过子类生成一定的扩充内容
  3. 对一个抽象的实现部分的修改对客户不产生影响

在以下情况应当使用桥接模式

  1. 如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的联系
  2. 设计要求实现化角色的任何改变不应当影响客户端，或者说实现化角色的改变对客户端是完全透明的
  3. 一个构件有多于一个的抽象角色和实现化角色，系统需要它们之间进行动态耦合
  4. 虽然在系统中使用继承是没有问题的，但是由于抽象化角色和具体化角色需要独立变化，设计要求需要独立管理这两种。

代码演示：
抽象道路

package com.myy.bridge;

public abstract interface AbstractRoad {

	     public AbstractCar car=null;
	     
	     public void setCar(AbstractCar car);
	     
	     public abstract void Run();
}

高速公路

package com.myy.bridge;

public class SpeedWay implements AbstractRoad{

	@Override
	public void setCar(AbstractCar car) {
		// TODO Auto-generated method stub
		car=car;
	}

	@Override
	public void Run() {
		// TODO Auto-generated method stub
		car.Run();
		System.out.println("----行驶在高速公路上-----");
	}

}

市区街道

package com.myy.bridge;

public class Street implements AbstractRoad{

	@Override
	public void setCar(AbstractCar car) {
		// TODO Auto-generated method stub
		car=car;
	}

	@Override
	public void Run() {
		// TODO Auto-generated method stub
		car.Run();
		System.out.println("----行驶在市区街道上---");
	}

}

抽象汽车

package com.myy.bridge;

public abstract interface AbstractCar {
	public abstract void Run();
}

小汽车

package com.myy.bridge;

public class Car implements AbstractCar{

	@Override
	public void Run() {
		// TODO Auto-generated method stub
		System.out.println("---小汽车----");
	}

}

公共汽车：

package com.myy.bridge;

public class Bus implements AbstractCar{

	@Override
	public void Run() {
		// TODO Auto-generated method stub
		System.out.println("----公共汽车----");
	}

}

客户端：

package com.myy.bridge;

public class BridgeTest {
   public static void main(String[] args) {
	AbstractRoad road1 = new SpeedWay();
	
	road1.setCar(new Car());
    
    road1.Run();
    
    AbstractRoad road2=new Street();
    
    road2.setCar(new Bus());
    
    road2.Run();
}
}

桥接模式是一个非常有用的模式，也非常复杂，它很好的符合了开放-封闭原则和优先使用对象，而不是继承这两个面向对象原则。

5.组合模式(Composite)

概念

使对象组合成树形的结构。使用户对单个对象和组合对象的使用具有一致性。

组合模式角色

  • 抽象构件角色(Component)：为组合中的对象声明接口， 在适当的情况下，也可实现所有类共有接口的缺省行为。

  • 树叶构件角色(Leaf)：在组合中表示叶节点对象，没有子节点，实现抽象构件角色声明的接口。

  • 树枝构件角色(Composite)：在组合中表示分支节点对象，有子节点，实现抽象构件角色声明的接口；存储子部件

组合模式场景

  1. 表示对象的 部分-整体 层次结构
  2. 忽略组合对象与单个对象的不同，统一的使用组合结构中的所有对象

组合模式两种实现方式

  • 透明式的组合模式：将管理子构件的方法定义在Component接口中，这样Leaf类就需要处理这些对其意义不大的方法（空实现或抛异常），在接口层次上Leaf和Composite没有区别，即透明性。Component 声明的这些管理子构件的方法对于Leaf来说是不适用的，这样也就带来了一些安全性问题。

  • 安全式的组合模式：将管理子构件的方法定义在Composite中，这样编译时任何从Leaf 中增加或删除对象的尝试都将被发现，但是由于Leaf和Composite有不同的接口（方法），又失去了透明性

代码演示：
安全的组合模式
这种组合模式，叶子节点，也就是单个对象不具有对象的控制功能。仅仅有简单的业务操作。

Component ：

package com.myy.composite;

public interface Component {

	Composite getCmposite();

    void sampleComposite();
}

Leaf ：

package com.myy.composite;

public class Leaf implements Component{

	@Override
	public Composite getCmposite() {
		return null;
	}

	@Override
	public void sampleComposite() {
		// TODO Auto-generated method stub
		 System.out.println("Leaf operation");
	}

}

Composite ：

package com.myy.composite;

import java.util.ArrayList;
import java.util.List;

public class Composite implements Component{

	 List<Component> list = new ArrayList<Component>();
	 
	@Override
	public Composite getCmposite() {
		// TODO Auto-generated method stub
		return this;
	}

	@Override
	public void sampleComposite() {
		// TODO Auto-generated method stub
		System.out.println("Composite operation");
        for (Component com : list) {
            com.sampleComposite();
        }
		
	}

	   public void add(Component component) {
	        list.add(component);
	    }

	    public void remove(Component component) {
	        list.remove(component);
	    }
}

CompositeTest ：

package com.myy.composite;

public class CompositeTest {
	public static void main(String[] args) {

        Component leaf1 = new Leaf();
        Component leaf2 = new Leaf();
        Component composite = new Composite();
        composite.getCmposite().add(leaf1);
        composite.getCmposite().add(leaf2);
        composite.getCmposite().sampleComposite();

    }
}

运行结果：
在这里插入图片描述

透明组合模式
这种组合模式，叶子节点与组合对象具有相同的方法，外表看来毫无差异。不过叶子节点的处理方法默认为空。忽略叶子节点，与组合对象的差异性。
Component：

package com.myy.composite;

public interface Component {

	Composite getCmposite();

    void sampleComposite();
    
    public void add(Component component) ;
    
    public void remove(Component component);
}

Leaf：

package com.myy.composite;

public class Leaf implements Component{

	@Override
	public Composite getCmposite() {
		return null;
	}

	@Override
	public void sampleComposite() {
		// TODO Auto-generated method stub
		 System.out.println("Leaf operation");
	}

	@Override
	public void add(Component component) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void remove(Component component) {
		// TODO Auto-generated method stub
		
	}

}

Composite：

package com.myy.composite;

import java.util.ArrayList;
import java.util.List;

public class Composite implements Component{

	 List<Component> list = new ArrayList<Component>();
	 
	@Override
	public Composite getCmposite() {
		// TODO Auto-generated method stub
		return this;
	}

	@Override
	public void sampleComposite() {
		// TODO Auto-generated method stub
		System.out.println("Composite operation");
        for (Component com : list) {
            com.sampleComposite();
        }
		
	}

	   public void add(Component component) {
	        list.add(component);
	    }

	    public void remove(Component component) {
	        list.remove(component);
	    }
}

CompositeTest：

package com.myy.composite;

public class CompositeTest {
	public static void main(String[] args) {

        Component leaf1 = new Leaf();
        Component leaf2 = new Leaf();
        Component composite = new Composite();
        composite.getCmposite().add(leaf1);
        composite.getCmposite().add(leaf2);
        composite.getCmposite().sampleComposite();

    }
}

运行结果：
在这里插入图片描述

6.外观模式(Facade)

概念

它隐藏了系统的复杂性，并向客户提供了一个可以访问系统的接口。这种类型的设计模式属于结果型模式。为子系统中的一组接口提供了一个统一的访问接口，这个接口使得子系统更容易被访问或者使用

意图

外观模式主要是为了为一组接口提供一个一致的界面。从而使得复杂的子系统与用户端分离解耦。

有点类似家庭常用的一键开关，只要按一个键，台灯卧室客厅的灯都亮了。虽然他们各有各自的开关，但是对外用一个来控制。

应用场景

  1. 为复杂系统提供简单的接口
  2. 客户程序与抽象类的实现部分分离
  3. 构建层次系统时，用作入口

优点

  1. 由于Facade类封装了各个模块交互的过程，如果今后内部模块调用关系发生了改变，只需要修改Facade实现就可以了
  2. Facade实现是可以被多个客户端调用的

在这里插入图片描述
ModuleA：

package com.myy.facade;

public class ModuleA {
	 public void testFuncA() {
	        System.out.println("This is Function From 改变了");
	    }
}

ModuleB：

package com.myy.facade;

public class ModuleB {
	 public void testFuncB() {
	        System.out.println("This is Function From ModuleB");
	    }
}

Facade：

package com.myy.facade;

public class Facade {
	   private ModuleA moduleA = null;
	    private ModuleB moduleB = null;
	    private static Facade mFacade = null;
	    
	    private Facade(){
	        moduleA = new ModuleA();
	        moduleB = new ModuleB();
	    } 
	    
	    public static Facade getInstance() {
	        if(mFacade == null) {
	            mFacade = new Facade();
	        }
	        return mFacade;
	    }
	    public void testOperation() {
	        moduleA.testFuncA();
	        moduleB.testFuncB();
	    }
}

FacadeTest ：

package com.myy.facade;

public class FacadeTest {
	 public static void main(String arg[]) {
	        Facade.getInstance().testOperation();
	    }
}

运行结果：
在这里插入图片描述

7.享元模式(Flyweight)

享元的目的是为了减少不会要额内存消耗，将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独的对象，以此来降低内存的消耗。

代码演示：
FlyWeight ：

package com.myy.flyweight;

import java.util.HashMap;
import java.util.Map;

public class FlyWeight {

    static class MyString {
        private String myChar;
 
        public MyString(String myChar) {
            this.myChar = myChar;
        }
 
 
        public void display() {
            System.out.println(myChar);
        }
    }
 
    static class MyCharacterFactory {
 
        private Map<String, MyString> pool;
 
        public MyCharacterFactory() {
            pool = new HashMap();
        }
 
        public MyString getMyCharacte(String strig) {
            MyString myString = pool.get(strig);
            if (myString == null) {
                myString = new MyString(strig);
                pool.put(strig, myString);
            }
            return myString;
        }
    }
 
    public static void main(String[] args) {
        MyCharacterFactory myCharacterFactory = new MyCharacterFactory();
        MyString a = myCharacterFactory.getMyCharacte("a");
        MyString b = myCharacterFactory.getMyCharacte("b");
        MyString a1 = myCharacterFactory.getMyCharacte("a");
        MyString d = myCharacterFactory.getMyCharacte("d");
 
        if (a == a1) {
            System.out.println("true");
        }
 
    }
	
}

运行结果：
在这里插入图片描述
【本章先论述结构型，只供参考。如有错误，欢迎留言。】

小媛末末
关注
专栏目录
设计模式之结构型模式（5种）
weixin_64987028的博客
04-18 6266
目录 结构型模式（Structural Pattern） 一、适配器模式 二、桥接模式（Bridge） 结构型模式（Structural Pattern）:怎么构造一个对象（行为、属性） 适配器模式 Adapter Pattern 桥接模式 Bridge Pattern 组合模式 Composite Pattern 装饰模式 Decorator Pattern 外观模式 Façade Pattern 享元模式 Flyweight ...
精讲23种设计模式
07-26
通过本书，我们将总结和讲解了23种设计模式，涵盖了创建型、结构型、行为型三大类设计模式。 一、创建型设计模式 创建型设计模式关注的是对象的创建过程，目的在于将对象的创建过程与其表示分离，以便于提高代码的...
三十种架构设计模式（下）.pdf
07-18
三十种架构设计模式（下）
GoF的23种设计模式之结构型模式的特点和分类
weixin_34273046的博客
06-05 1075
结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。 由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。 结构型模式分为以下 7 种： 代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访...
大模型应用的6种架构设计模式，你知道几种？
最新发布
musicml的博客
07-17 743
▼最近直播超级多，预约保你有收获架构设计模式已成为程序员的重要技能。然而，当我们转向大模型应用领域，情况可能会有所不同。面对新兴技术，比如：生成式 AI，我们尚缺乏成熟的设计模式来支撑这些解决方案。根据多年的架构设计经验，我在这里整理总结了一些针对大模型应用的设计方法和架构模式，试图应对和解决大模型应用实现中的一些挑战，比如：成本问题、延迟问题以及生成的幻觉等问题。—1—路由分发架构模式当用户输...
设计模式之结构型模式
yangzhiyong77
11-05 352
下面说一下结构型模式：结构型模式是描述如何将类对象结合在一起，形成一个更大的结构，结构模式描述两种不同的东西：类与类的实例。故可以分为类结构模式和对象结构模式。 在GoF设计模式中，结构型模式有： 1.适配器模式 Adapter 2.桥接模式 Bridge 3.组合模式 Composite 4.装饰模式 Decorator 5.外观模式 Facade 6.享元模式 Flyweigh...
设计模式、架构、框架
idealPC的专栏
01-31 255
一、设计模式 1.1概念：一套被反复使用、易理解、保证代码可靠性的代码设计经验的总结；与编程语言无关的成熟的编程思想。 1.2六大设计原则：单一职责、开闭、接口隔离、依赖倒置、里氏替换、迪米特 1.2.1单一职责原则：一个类只负责一件事。如UIView事件传递、响应；CALayer动画视图显示。 1.2.2开闭原则：对修改关闭，对扩展开放。对类的成员变量定义避免反复改；对类的数据结构定义好后提供接口（包括子类继承） 1.2.3接口隔离原则：用多个专门协议且协议中方法尽量少，避免一个臃肿庞大的协议。
架构中的设计模式
爱琴孩的博客
10-07 486
这个问题我问过的面试者不下于数十次，回答五花八门，在我看来，模式就是经验，设计模式就是设计经验，有了这些经验，我们就能在特定情况下使用特定的设计、组合设计，这样可以大大节省我们的设计时间，提高工作效率。作为一个工作10年以上的老码农，经历的系统架构设计也算不少，接下来，我会把工作中用到的一些架构方面的设计模式分享给大家，望大家少走弯路。
23种设计模式精讲总结
01-14
23种设计模式总结，分别对应三种大的类型：创建型模式、结构型模式、行为型模式。包含其定义和类图。 速记口诀如下： 创建型：单抽元建厂 结构型：外侨（桥）组元戴（代）配饰 行为型：责令解放（访），观摩（模）对...
java 23种设计模式.zip
11-19
设计模式主要分为三大类： 1.创建型模式：工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式。 2.结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。 4.行为型模式：...
架构设计模式
任玉
03-14 3009
架构模式是一个通用的、可重用的解决方案，用于在给定上下文中的软件体系结构中经常出现的问题。架构模式与软件设计模式类似，但具有更广泛的范围。 通常互联网提到的架构无非下面几种 1、微服务架构 2、面向服务（SOA）架构 3、REST风格架构 4、CRQS架构 5、事件驱动架构 具体详细的有这么10种 10种： 分层模式 客户端-服务器模式 主从设备模式 管道-过滤器模式 代理模式 点对点模式 事件总线模式 模型-视图-控制器模式（也称为MVC模式） 黑板模式 解释器模式
结构型模式
姚明锋的博客
10-26 1209
结构型模式可以描述两种不同的东西：类与类的实例（即对象）。根据这一点，结构型模式可以分为类结构模式和对象结构型模式。类结构型模式关心类的组合，由多个类可以组合成一个更大的系统，在类结构型模式中一般只存在继承和实现的关系；而对象结构型模式关心类与对象的组合，通过关联关系使得在一个类中定义另外一个类的实例对象，然后通过该对象调用其方法。 ...
设计模式-结构型
qq_20846769的博客
11-21 756
概述 结构型模型是指如何将类或者对象按照某种布局组成更大的结构。 分为类型结构型和对象结构型，前者是通过继承机制来组织接口和类， 后者是通过组合或者聚合来组合对象。 结构型模型有7种： 代理模式：为放个对象一个代理以控制对该对象的访问，从而达到限制、增强或者修改对象的某些属性。常用的有在访问某个具体功能前先校验安全性，某个操作之后记录日志等。 适配器模式：比如充电器就是一个适配器将220V电压转换成5V 桥接模式：将抽象和实现分开，使得他们可以独立变化。它是用组合关系来代替继承关系，从而降低了抽象和组合
结构型模式（一）
03-30 724
6、adapter  适配器 别名wrapper ，将一些接口不统一的类包装成统一的接口     target req()     adaptee other_req()          |_______________|                      |            adapter req()->other_req() ta
设计模式-结构型模式
www.yiye.tech
06-11 479
适配器模式（Adapter Pattern） 桥接模式（Bridge Pattern） 过滤器模式（Filter、Criteria Pattern） 组合模式（Composite Pattern） 装饰器模式（Decorator Pattern） 外观模式（Facade Pattern） 享元模式（Flyweight Pattern） 代理模式（Proxy Pattern） 适...
理解23种设计模式：结构图与核心意图解析
"23种设计模式结构图包含创建型、结构型和行为型模式的详细解释和示意图。" 设计模式是软件工程中的一种最佳实践，它为解决常见问题提供了可重用的解决方案。以下是这23种设计模式的详细说明： 1. **创建型模式**...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值