结构型模式一、装饰模式以及享元模式、代理模式、外观模式、组合模式

最新推荐文章于 2022-01-25 21:19:40 发布
最新推荐文章于 2022-01-25 21:19:40 发布
阅读量209 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38367817/article/details/104928612
版权

文章目录

装饰模式

在这里插入图片描述

把原本的对象传进来，增加新的功能。而不是通过子类的方式，也可以装饰套装饰。

装饰模式又叫做包装模式，通常一种对客户端透明的方式来扩展对象的功能，是继承关系的一个替换方案。

动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。

主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

装饰模式的结构

在这里插入图片描述

装饰模式的角色和职责

在这里插入图片描述

非装饰模式，通过子类添加功能

interface Car
{
    public void show();
}

class RunCar implements Car
{
    @Override
    public void show() {
        this.run();
    }
    public void run()
    {
        System.out.println("可以跑");
    }
}

class SwimCar implements Car{
    @Override
    public void show() {
        this.run();
        this.swim();
    }
    public void run()
    {
        System.out.println("可以跑");
    }

    public void swim()
    {
        System.out.println("可以游");
    }

}

class FlyCar implements Car
{
    public void fly()
    {
        System.out.println("可以飞");
    }
    @Override
    public void show() {
        this.run();
        this.fly();
    }
    public void run()
    {
        System.out.println("可以跑");
    }
}

public class MainClass
{
    public static void main(String[] args) {
        Car car = new FlyCar();
        car.show();
    }
}

输出

可以跑
可以飞

通过装饰模式

interface Car
{
    public abstract void show();
    public abstract void run();
}

class RunCar implements Car{
    @Override
    public void show()
    {
        this.run();
    }
    public void run()
    {
        System.out.println("可以跑");
    }
}

abstract class CarDecorator implements Car
{
    private Car car;

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    public CarDecorator(Car car) {
        this.car = car;
    }

    public abstract void show();
}

class FlyCarDecorator extends CarDecorator
{

    public FlyCarDecorator(Car car) {
        super(car);
    }

    @Override
    public void show() {
        this.getCar().show();
        this.fly();
    }

    @Override
    public void run() {

    }


    public void fly()
    {
        System.out.println("可以飞");
    }
}

class SwimCarDecorator extends CarDecorator
{


    public SwimCarDecorator(Car car) {
        super(car);
    }

    @Override
    public void show()
    {
        this.getCar().show();
        this.swim();
    }

    public void swim()
    {
        System.out.println("可以游");
    }

    @Override
    public void run()
    {

    }
}
public class MainClass
{
    public static void main(String[] args) {
        Car car = new RunCar();
        CarDecorator carDecorator = new FlyCarDecorator(car);
        car = new SwimCarDecorator(carDecorator);
        car.show();

    }
}

输出

可以跑
可以飞
可以游

如果想要又可以跑，又可以游，只需要在跑的外面装饰游，或者游的外面装饰跑。而不需要创建新的类。

享元模式

结构型模式的一种，它通过与其他对象共享数据来减小内存占用。

享元模式的结构

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

代码

//享元角色
class MyCharacter
{
    private char myChar;

    public MyCharacter(char myChar) {
        this.myChar = myChar;
    }

    public void disPlay()
    {
        System.out.println(myChar);
    }
}

//享元工厂角色
class MyCharacterFactory
{
    private Map<Character,MyCharacter> pool;

    public MyCharacterFactory() {
        this.pool = new HashMap<Character, MyCharacter>();
    }

    public MyCharacter getMyCharacter(Character character)
    {
        MyCharacter myChar = pool.get(character);
        if(myChar == null)
        {
            myChar = new MyCharacter(character);
            pool.put(character,myChar);
        }
        return myChar;
    }

}

public class MainClass
{
    public static void main(String[] args)
    {
//        MyCharacter myCharacter = new MyCharacter('a');
//        MyCharacter myCharacter1 = new MyCharacter('b');
//        MyCharacter myCharacter2 = new MyCharacter('a');
//        MyCharacter myCharacter3 = new MyCharacter('d');
//
//        myCharacter.disPlay();
//        myCharacter1.disPlay();
//        myCharacter2.disPlay();
//        myCharacter3.disPlay();
//        System.out.println(myCharacter==myCharacter2);//false

        MyCharacterFactory myCharacterFactory = new MyCharacterFactory();
        MyCharacter myCharacter = myCharacterFactory.getMyCharacter('a');
        MyCharacter myCharacter1 = myCharacterFactory.getMyCharacter('b');
        MyCharacter myCharacter2 = myCharacterFactory.getMyCharacter('a');
        MyCharacter myCharacter3 = myCharacterFactory.getMyCharacter('b');
        myCharacter.disPlay();
        myCharacter1.disPlay();
        myCharacter2.disPlay();
        myCharacter3.disPlay();
        System.out.println(myCharacter==myCharacter2); //true
        System.out.println(myCharacter1==myCharacter3); //true



    }
}

代理模式

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。

介绍

  • 意图：为其他对象提供一种代理以控制对这个对象的访问。

  • 主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

  • 何时使用：想在访问一个类时做一些控制。

  • 如何解决：增加中间层。

  • 关键代码：实现与被代理类组合。

实现

我们将创建一个 Image 接口和实现了 Image 接口的实体类。ProxyImage 是一个代理类，减少 RealImage 对象加载的内存占用。

ProxyPatternDemo，我们的演示类使用 ProxyImage 来获取要加载的 Image 对象，并按照需求进行显示。

在这里插入图片描述

interface Image {
   void display();
}

class RealImage implements Image 
{
 
   private String fileName;
 
   public RealImage(String fileName){
      this.fileName = fileName;
      loadFromDisk(fileName);
   }
 
   @Override
   public void display() {
      System.out.println("Displaying " + fileName);
   }
 
   private void loadFromDisk(String fileName){
      System.out.println("Loading " + fileName);
   }
}

class ProxyImage implements Image{
 
   private RealImage realImage;
   private String fileName;
 
   public ProxyImage(String fileName){
      this.fileName = fileName;
   }
 
   @Override
   public void display() {
      if(realImage == null){
         realImage = new RealImage(fileName);
      }
      realImage.display();
   }
}


public class ProxyPatternDemo {
   
   public static void main(String[] args) {
      Image image = new ProxyImage("test_10mb.jpg");
 
      // 图像将从磁盘加载
      image.display(); 
      System.out.println("");
      // 图像不需要从磁盘加载
      image.display();  
   }
}

执行程序，输出结果：

Loading test_10mb.jpg
Displaying test_10mb.jpg

Displaying test_10mb.jpg

外观模式

外观模式（Facade Pattern）隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。

介绍

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

  • 主要解决：降低访问复杂系统的内部子系统时的复杂度，简化客户端与之的接口。

  • 何时使用： 1、客户端不需要知道系统内部的复杂联系，整个系统只需提供一个"接待员"即可。 2、定义系统的入口。

  • 如何解决：客户端不与系统耦合，外观类与系统耦合。

  • 关键代码：在客户端和复杂系统之间再加一层，这一层将调用顺序、依赖关系等处理好。

  • 应用实例： 1、去医院看病，可能要去挂号、门诊、划价、取药，让患者或患者家属觉得很复杂，如果有提供接待人员，只让接待人员来处理，就很方便。 2、JAVA 的三层开发模式。

  • 优点： 1、减少系统相互依赖。 2、提高灵活性。 3、提高了安全性。

  • 缺点：不符合开闭原则，如果要改东西很麻烦，继承重写都不合适。

外观模式结构

在这里插入图片描述

代码

class SystemA
{
    public void doSomething()
    {
        System.out.println("实现A系统功能");
    }
}

class SystemB
{
    public void doSomething()
    {
        System.out.println("实现B系统功能");
    }
}

class SystemC
{
    public void doSomething()
    {
        System.out.println("实现C系统功能");
    }
}

class Facade
{
    private SystemA systemA;
    private SystemB systemB;
    private SystemC systemC;
    public Facade()
    {
        systemA = new SystemA();
        systemB = new SystemB();
        systemC = new SystemC();
    }

    public void doSomethingA()
    {
        systemA.doSomething();
    }
    public void doSomethingB()
    {
        systemB.doSomething();
    }
    public void doSomethingC()
    {
        systemC.doSomething();
    }

}

public class MainClass
{
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.doSomethingA();
    }
}

组合模式

通过递归手段来构造树形的对象结构，并可以通过一个对象来访问整个树。

组合模式依据树形结构来组合对象，用来表示部分以及整体层次

组合模式结构

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


/**
 * 文件和目录的父类
 */
interface IFile
{
    //显示文件或者文件夹的名称
    public void display();

    //添加
    public boolean add(IFile file);

    //移除
    public boolean remove(IFile file);

    //获得子节点
    public List<IFile> getChild();

}

/**
 * 目录
 */
class Folder implements IFile
{
    String name;
    private List<IFile> children;


    public Folder(String name) {
        this.name = name;
        children = new ArrayList<>();
    }

    @Override
    public void display() {
        System.out.println(name);
    }

    @Override
    public boolean add(IFile file) {
        return children.add(file);
    }

    @Override
    public boolean remove(IFile file) {
        return children.remove(file);
    }

    @Override
    public List<IFile> getChild() {
        return  children;
    }
}


//文件，相当于叶子节点
class File implements IFile
{
    private String name;
    public File(String name)
    {
        this.name = name;
    }

    @Override
    public void display() {
        System.out.println(name);
    }

    @Override
    public boolean add(IFile file) {
        return false;
    }

    @Override
    public boolean remove(IFile file) {
        return false;
    }

    @Override
    public List<IFile> getChild() {
        return null;
    }
}

public class MainClass
{
    public static void main(String[] args)
    {
        //C盘
        Folder rootFolder = new Folder("C:");

        //beifeng目录
        Folder beifengFolder = new Folder("beifeng");

        //文件
        File file = new File("beifeng.txt");
        rootFolder.add(beifengFolder);
        rootFolder.add(file);
        displayTree(rootFolder);
    }
    public static void displayTree(IFile rootFolder)
    {
        //显示自身名称
        rootFolder.display();
        //获得子树
        List<IFile> child = rootFolder.getChild();

        for(IFile file:child)
        {
            if(file instanceof File)
                file.display();
            else
                displayTree(file);
        }

    }
}
钢铁-程序猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
桥接、组合、装饰模式
Phoneix的博客
10-06 914
桥接模式： 将抽象部分与其显示部分分离，使他们都可以独立地变化。 和中继器模式: 中继模式，就是利用无线路由器之间的无线连接功能，将无线信号从一个中继点传递到下一个中继点，实现信号的增强，并形成新的无线覆盖区域，最终达到延伸无线网络的覆盖范围的目的。 事实上，只要有两台支持中继功能的无线路由器，即可拓展网络覆盖范围。 中继和桥接功能对于无线用户的实际使用基...
设计模式（三）：结构型模式之代理模式、适配器模式、桥接模式、装饰器模式、外观模式、享元模式和组合模式
HX_2021
11-05 443
设计模式之结构型模式 一、概述 结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。 由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。 结构型模式分为以下7种： 代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。 适配器（Adapter）模式：将一个类的接
java设计模式（结构）--组合模式&装饰器模式
乐点的博客
02-17 1823
一、组合模式 用途：将对象组合成树形结构以表示 “部分——整体” 的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。 案例：在中文中，一句话是由词语组成的，而词语又由字组成；在英文中，句子由单词组成，而单词又由一个个字母组成。每个对象都可定义的它之前的或之后的内容。比如一个中文句子总是以句号结尾，一个英文单词之前通常是有空格的。这种结构可以形成了递归嵌套的结构，句子是...
设计模式之结构型模式（适配器、外观、组合、桥接、装饰、代理、享元模式）
5ingwings(SiHao)的博客
01-07 6816
设计模式之结构型模式 结构型模式： 如何将类与类或者对象与对象或者类与对象结合在一起形成更大的结构 因此可以分为： 类结构型模式：由多个类可以组合成一个更大的系统，在类结构型模式中一般只存在继承关系和实现关系 对象结构型模式： 关心类与对象的组合，通过关联关系使得在一个类中定义另一个类的实例对象，然后通过该对象调用其方法 并且符合合成复用原则，减少继承关系的使用 因此大部分结构...
设计模式：（四）装饰器、组合、外观、享元模式
余笙的博客
03-22 754
一、装饰器模式 1、概述 定义：装饰器（Decorator）模式指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。比继承更有弹性，体现了开闭原则。 2、装饰器模式的主要角色 抽象构件（Component）：是一个接口或者抽象类，是定义我们最核心的对象，也可以说是最原始的对象，比如饮料。 具体构件（ConcreteComponent）：实现抽象构件，可以单独用，也可通过装饰角色将其进行装饰，比如咖啡。 抽象装饰（Decorator）：一般是一个抽
装饰者模式和享元模式
weixin_33796177的博客
05-08 66
装饰者模式，英文名：Decorator。 装饰者基本概念：装饰者可以用于修改现有的系统，希望在系统中为对象添加额外的功能，而不需要修改对象的底层代码来添加额外的功能。 举个简单的例子： function vehicle(type){ this.vehicleType = type || "car"; this.model = "default"; } var testInst...
【设计模式】装饰模式、模板方法模式、观察者模式、组合模式、桥接模式
人生苦短，我用Python
03-31 1618
1、装饰模式： 动态的给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。 优点：可以为已有对象动态的添加更多功能的一种方式。当系统需要新功能的时候，我们为了遵守开放-封闭的原则和单一职责原则，不能在一个类中反复增加功能，而新功能仅仅是满足某些特定情况下才会发生的特殊行为，所以把装饰模式放在单独的类中，并让这个类包装它所要装饰的对象，当客户端需要运行哪个功能就可以动态的选
结构型设计模式（7种）
05-18
结构型设计模式是软件设计中的一种重要思想，它主要关注如何组织类和对象来形成更大的结构，同时保持代码的灵活性、可复用性和可维护性。在Java等面向对象编程语言中，结构型设计模式扮演着至关重要的角色。以下是7...
23种设计模式,创建型模式共5种,结构型模式7种,行为型模式11种
12-22
设计模式分为三大类：创建型模式、结构型模式和行为型模式。 **创建型模式**关注的是对象的创建。共有五种创建型模式： 1. **工厂方法模式**：它定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法...
Java设计模式之结构型模式源码以及文档
08-01
结构型模式可以分为七种：适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式和代理模式。这些模式在不同的场景下有着各自的用途，它们可以帮助我们构建出灵活、可扩展的系统。 适配器模式允许两个不...
常用的数据结构，算法，设计模式的积累
最新发布
05-24
设计模式分为三类：创建型模式（如单例、工厂方法、抽象工厂），结构型模式（如适配器、装饰器、代理、桥接、组合、外观、享元）和行为型模式（如策略、模板方法、观察者、迭代器、责任链、命令、备忘录、解释器）。...
结构型模式部分知识
05-30
在软件设计领域，结构型模式是面向对象设计中的一种重要思想，它主要关注如何组织类和对象，以形成更复杂的结构，同时保持代码的清晰性和可维护性。本资料是关于高等软件工程中的7大结构型模式的PPT总结，包含了大量...
java设计模式之——外观模式、组合模式、装饰模式、享元模式（结构型）
weixin_39768264的博客
10-11 1695
一、外观模式 定义：为子系统中一组接口提供一致的界面，此模式定义了一个高层接口，该接口使得子系统更加容易使用。 使用场景：一、在软件设计初级阶段，应该有意识的将软件两个层分开，比如经典的三层架构，降低了耦合。二、开发阶段，层与层之间的耦合愈来愈复杂，增加外观（facade）可以提供一个简单的接口，降低依赖。三、在维护大型系统时，系统难以扩展和维...
（九）装饰模式&享元模式&外观模式&桥接模式
qq_42193011的博客
09-04 172
装饰模式 1、 装饰模式介绍 结构型设计模式之一，使用一种对客户端透明的方式来动态地扩展对象的功能，同时它也是继承关系的一种替代方式，就好像在人的基础上再加上一层衣服的意思，装饰物也许不同，但是装饰的对象本质是不变的。装饰模式定义就是动态给一个对象添加一些额外的职责，就增加功能来说，装饰对象比生成子类要灵活 2、 装饰模式的使用场景 需要透明且动态地拓展类的功能时 3、 Andriod源码中的...
组合模式、装饰者
LawssssCat的博客
11-12 242
- 参数 -XX:+, 表示开启option选项 -XX:-, 表示关闭option选项 -XX:=, 表示将option选项的值设置为value -XX:+TraceClassLoading 用于追踪类的加载信息并打印出来 -Xms 设置堆的最小空间大小 -Xmx 设置堆的最大空间大小 ...
装饰者模式与组合模式
攻城老湿的博客
06-27 251
装饰者模式与组合模式 参考教程：https://www.bilibili.com/video/BV1G4411c7N4 代码实现 Github：https://github.com/yaokuku123/pattern 装饰者模式 案例 星巴克咖啡订单项目(咖啡馆)： 咖啡种类/单品咖啡：Espresso(意大利浓咖啡)、ShortBlack、LongBlack(美式 咖啡)、Deca...
设计之禅——装饰者模式详解（与代理模式的区别以及与其他模式的组合）
夜勿语的博客
11-26 2455
前言 相信很多初学者都对JavaAPI中的IO包感到头大，其中的类非常多，看着看着就晕了，笔者也是一样。不过，IO包的设计其实就是使用了装饰者模式，了解了这个模式再去看IO包就会发现很清晰了。 定义 Coding Common WithFactory IO包中的装饰者 与代理模式的区别 总结 ...
结构型模式，适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。...
weixin_34407348的博客
09-25 146
确定你需要使用哪种设计模式,是根据你 的目的和需求决定的....在看下面的設計模式時,你會發現許多的設計模式實現過程都是一樣的. 所以你使用的是什麼設計模式,取決於你的實現需求. 只有弄明白這點.才不會混亂   适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源，我们看下面的图： 关键词:Adapter ,Decorator,...
Leetcode-设计模式-构建型模式
weixin_38367817的博客
01-25 6084
设计模式 工厂模式 1、简单工厂模式（让一个工厂创建所有对象） 工厂模式缺点： 让一个工厂类承担构建所有对象的职责，一是如果需要生产的产品过多，此模式会导致工厂类过于庞大，承担过多的职责，变成超级类。违背了单一职责原则。 二是当要生产新的产品时，必须在工厂类中添加新的分支。而开闭原则告诉我们：类应该对修改封闭。我们希望在添加新功能时，只需增加新的类，而不是修改既有的类，所以这就违背了开闭原则。 public class FruitFactory { public Fruit create(Str
代理、适配器、桥接、外观、装饰 - 结构型模式与代理模式探究
总共有7种结构型模式，分别是代理模式、适配器模式、装饰者模式、桥接模式、外观模式、组合模式和享元模式。 代理模式是结构型模式中的一种，它是为某个对象提供一个代理以控制对该对象的访问。在代理模式中，访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值