设计模式-----结构型模式

已于 2023-09-08 21:33:01 修改
阅读量604 收藏
点赞数
分类专栏： 设计模式 文章标签： 组合模式 代理模式
于 2021-11-13 20:26:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45309155/article/details/121308898
版权

设计模式结构型包含：适配器模式、桥接模式、组合模式、装饰模式、享元模式、外观模式、代理模式。

关系分类

适配器：

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

比如你的电脑只能支持一个type-c接口，但是你需要一个usb接口，这时候一个转换器就可以解决这个问题，这个转换器充当的角色就是适配器。

public interface ITarget
{
    void Request();
}

public class Adaptee
{
    public void SpecificRequest()
    {
        Console.WriteLine("Adaptee's SpecificRequest");
    }
}

public class Adapter : ITarget
{
    private Adaptee _adaptee;

    public Adapter(Adaptee adaptee)
    {
        _adaptee = adaptee;
    }

    public void Request()
    {
        _adaptee.SpecificRequest();
    }
}

// 使用示例
Adaptee adaptee = new Adaptee();
ITarget target = new Adapter(adaptee);
target.Request();

 桥接模式：

将抽象部分与它的实现部分分离，使他们都可以独立的变化

Abstraction 与Implementor类的聚合就可以看作是桥接的桥了

public interface IImplementor
{
    void OperationImpl();
}

public abstract class Abstraction
{
    protected IImplementor _implementor;

    public Abstraction(IImplementor implementor)
    {
        _implementor = implementor;
    }

    public abstract void Operation();
}

public class ConcreteImplementorA : IImplementor
{
    public void OperationImpl()
    {
        Console.WriteLine("ConcreteImplementorA's OperationImpl");
    }
}

public class ConcreteImplementorB : IImplementor
{
    public void OperationImpl()
    {
        Console.WriteLine("ConcreteImplementorB's OperationImpl");
    }
}

public class RefinedAbstraction : Abstraction
{
    public RefinedAbstraction(IImplementor implementor) : base(implementor)
    {
    }

    public override void Operation()
    {
        _implementor.OperationImpl();
    }
}

// 使用示例
IImplementor implementorA = new ConcreteImplementorA();
Abstraction abstractionA = new RefinedAbstraction(implementorA);
abstractionA.Operation();

IImplementor implementorB = new ConcreteImplementorB();
Abstraction abstractionB = new RefinedAbstraction(implementorB);
abstractionB.Operation();

组合模式：

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

 可以理解为总公司和分公司的关系，具体的抽象类可以就是总公司，抽象类的子类就是分公司。

组合模式的好处：组合模式定了包含基本对象组合对象的的类的层次结构。基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不段的递归下去，客代码中，任何用到基本的对象的地方都可以使用组合对象。

用户不关心到底是处理一个叶子点还是处理一个组合组件，也就用不着为定义组合而写一些选择判断语句

组合模式让客户可以一致的使用组合结构和单个对象。

public abstract class Component
{
    protected string _name;

    public Component(string name)
    {
        _name = name;
    }

    public abstract void Add(Component component);
    public abstract void Remove(Component component);
    public abstract void Display(int depth);
}

public class Leaf : Component
{
    public Leaf(string name) : base(name)
    {
    }

    public override void Add(Component component)
    {
        Console.WriteLine("Cannot add to a leaf");
    }

    public override void Remove(Component component)
    {
        Console.WriteLine("Cannot remove from a leaf");
    }

    public override void Display(int depth)
    {
        Console.WriteLine(new string('-', depth) + _name);
    }
}

public class Composite : Component
{
    private List<Component> _children = new List<Component>();

    public Composite(string name) : base(name)
    {
    }

    public override void Add(Component component)
    {
        _children.Add(component);
    }

    public override void Remove(Component component)
    {
        _children.Remove(component);
    }

    public override void Display(int depth)
    {
        Console.WriteLine(new string('-', depth) + _name);
        foreach (Component component in _children)
        {
            component.Display(depth + 2);
        }
    }
}

// 使用示例
Composite root = new Composite("root");
root.Add(new Leaf("Leaf A"));
root.Add(new Leaf("Leaf B"));

Composite comp = new Composite("Composite X");
comp.Add(new Leaf("Leaf XA"));
comp.Add(new Leaf("Leaf XB"));

root.Add(comp);

root.Add(new Leaf("Leaf C"));

Leaf leaf = new Leaf("Leaf D");
root.Add(leaf);
root.Remove(leaf);

root.Display(1);

装饰模式：

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

public abstract class Component
{
    public abstract void Operation();
}

public class ConcreteComponent : Component
{
    public override void Operation()
    {
        Console.WriteLine("ConcreteComponent's Operation");
    }
}

public abstract class Decorator : Component
{
    protected Component _component;

    public Decorator(Component component)
    {
        _component = component;
    }

    public override void Operation()
    {
        if (_component != null)
        {
            _component.Operation();
        }
    }
}

public class ConcreteDecoratorA : Decorator
{
    public ConcreteDecoratorA(Component component) : base(component)
    {
    }

    public override void Operation()
    {
        base.Operation();
        Console.WriteLine("ConcreteDecoratorA's Operation");
    }
}

public class ConcreteDecoratorB : Decorator
{
    public ConcreteDecoratorB(Component component) : base(component)
    {
    }

    public override void Operation()
    {
        base.Operation();
        Console.WriteLine("ConcreteDecoratorB's Operation");
    }
}

// 使用示例
Component component = new ConcreteComponent();
Decorator decoratorA = new ConcreteDecoratorA(component);
Decorator decoratorB = new ConcreteDecoratorB(decoratorA);

decoratorB.Operation();

 外观模式：

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

public class SubsystemA
{
    public void OperationA()
    {
        Console.WriteLine("SubsystemA's OperationA");
    }
}

public class SubsystemB
{
    public void OperationB()
    {
        Console.WriteLine("SubsystemB's OperationB");
    }
}

public class SubsystemC
{
    public void OperationC()
    {
        Console.WriteLine("SubsystemC's OperationC");
    }
}

public class Facade
{
    private SubsystemA _subsystemA;
    private SubsystemB _subsystemB;
    private SubsystemC _subsystemC;

    public Facade()
    {
        _subsystemA = new SubsystemA();
        _subsystemB = new SubsystemB();
        _subsystemC = new SubsystemC();
    }

    public void Operation()
    {
        _subsystemA.OperationA();
        _subsystemB.OperationB();
        _subsystemC.OperationC();
    }
}

// 使用示例
Facade facade = new Facade();
facade.Operation();

 享元模式：

为运用共享技术有效的支持大量细粒度的对象

如果一个应用程序使用了大量的对象，而大量的这些对象造成了很大的存储开销时就应该考虑使用；还有就是对象的大多数状态可以外部状态，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元模式。

public abstract class Flyweight
{
    public abstract void Operation(int extrinsicState);
}

public class ConcreteFlyweight : Flyweight
{
    public override void Operation(int extrinsicState)
    {
        Console.WriteLine("ConcreteFlyweight's Operation with extrinsic state: " + extrinsicState);
    }
}

public class UnsharedConcreteFlyweight : Flyweight
{
    public override void Operation(int extrinsicState)
    {
        Console.WriteLine("UnsharedConcreteFlyweight's Operation with extrinsic state: " + extrinsicState);
    }
}

public class FlyweightFactory
{
    private Dictionary<string, Flyweight> _flyweights = new Dictionary<string, Flyweight>();

    public Flyweight GetFlyweight(string key)
    {
        if (!_flyweights.ContainsKey(key))
        {
            _flyweights[key] = new ConcreteFlyweight();
        }
        return _flyweights[key];
    }
}

// 使用示例
FlyweightFactory factory = new FlyweightFactory();
Flyweight flyweight1 = factory.GetFlyweight("key1");
flyweight1.Operation(1);

Flyweight flyweight2 = factory.GetFlyweight("key2");
flyweight2.Operation(2);

Flyweight unsharedFlyweight = new UnsharedConcreteFlyweight();
unsharedFlyweight.Operation(3);

代理模式：

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

public interface ISubject
{
    void Request();
}

public class RealSubject : ISubject
{
    public void Request()
    {
        Console.WriteLine("RealSubject's Request");
    }
}

public class Proxy : ISubject
{
    private RealSubject _realSubject;

    public void Request()
    {
        if (_realSubject == null)
        {
            _realSubject = new RealSubject();
        }

        _realSubject.Request();
    }
}

// 使用示例
Proxy proxy = new Proxy();
proxy.Request();

总结

结构型模式是面向对象设计模式的一类，它关注的是如何将类或对象组合在一起形成更大的结构，以实现更灵活、可复用和可维护的系统架构。结构型模式通过定义类之间的关系和组合方式，帮助我们构建具有可扩展性和低耦合度的系统。

以下是对结构型模式的一篇总结：

结构型模式是面向对象设计模式中的一类，它关注的是对象之间的组合和结构形成，以实现更灵活、可复用和可维护的系统架构。结构型模式通过定义类之间的关系和组合方式，以及对象的接口和交互方式，帮助我们构建具有高内聚、低耦合的系统。

结构型模式的主要目标是通过组合和排列已有的对象或类来创建更大的结构，而不需要修改其原有的代码。这种方式可以降低系统的复杂度、提高模块化和可维护性。

结构型模式常用的几个模式包括：

  1. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户端所期望的接口，使得原本因接口不兼容而不能一起工作的类可以协同工作。

  2. 桥接模式（Bridge Pattern）：将抽象部分与实现部分解耦，使它们可以独立变化。通过桥接模式，我们可以避免在多个维度上的扩展造成类爆炸的问题。

  3. 组合模式（Composite Pattern）：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

  4. 装饰器模式（Decorator Pattern）：动态地给一个对象添加额外的职责，即装饰功能，同时又不改变其原有的结构和功能。

  5. 外观模式（Facade Pattern）：为子系统中的一组接口提供一个统一的接口，以简化子系统的使用。

  6. 享元模式（Flyweight Pattern）：通过共享对象来有效地支持大量细粒度的对象，从而节省内存和提高性能。

  7. 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对这个对象的访问。代理模式可以在不改变原始对象的情况下，增加额外的处理逻辑。

结构型模式的使用可以提高系统的可维护性、可扩展性和重用性，降低了类与类之间的耦合度，使得系统更加灵活和易于拓展。然而，在使用结构型模式时需要权衡设计的复杂度和系统的性能，避免过度使用和滥用模式带来的负面影响。

综上所述，结构型模式是一类重要的设计模式，通过定义类之间的关系和组合方式，帮助我们构建具有可扩展性和低耦合度的系统。熟练运用结构型模式能够提高系统的可维护性和可扩展性，使得系统更加灵活和易于拓展。但在使用时需要根据实际情况进行权衡，避免过度使用和滥用模式。

谷艳爽faye
关注
专栏目录
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

谷艳爽faye

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值