设计模式之代理、组合、装饰、策略设计模式

拼搏现实的明天。 2023-10-07 21:05 32阅读 0赞

#### 设计模式 ####

*  代理设计模式
 *  组合设计模式
 *  装饰设计模式
 *  策略设计模式

## 代理设计模式 ##

代理的意思通俗地讲，就是代理类帮助被代理类执行操作，同时在代理类中过滤掉部分不合规定的操作

代理模式的优点：

*  List item代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
 *  代理对象可以扩展目标对象的功能；
 *  代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性

缺点：

*  List item代理模式会造成系统设计中类的数量增加
 *  在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
 *  增加了系统的复杂度；

具体实现  
代理模式的结构比较简单，主要是通过定义一个继承抽象主题的代理来包含真实主题，从而实现对真实主题的访问

代理解构的主要角色  
1、 抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。  
2、真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。  
3、代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。**基础是要完成接口，即完成真实对象的引用，然后是完善程序中的问题，具体根据题目中的要求扩展相应的功能**。

代理类

class Proxy implemments reallyInterface{
        
    private reallyproject rp;//被代理对象私有化
    
    //1、通过有参构造传入被代理的实例化对象
    public Proxy (reallyproject rp){
        
    this.rp = rp;
    }
    
    //或者2、在无参构造器里面直接实例化被代理对象
    public Proxy{
        
    this.rp = new reallyproject():
    }}

测试类:先实例化原本的，再实例化代理人，并将第一个传入代理人中

class Text{
        
    public static void main (String[] arge){
        
    //通过有参构造传入被代理的实例化对象
    reallyproject rp =new reallyproject();
    Proxy proxy = new Proxy(rp);}
    }

## 组合设计模式 ##

组合多个对象形成树形结构以表示具有 “整体—部分” 关系的层次结构。组合模式对单个对象（即叶子对象）和组合对象（即容器对象）的使用具有一致性，组合模式又可以称为 “整体—部分”(Part-Whole) 模式，它是一种对象结构型模式。

优点：

*  定义层次 : 清楚地 定义 分层次 的 复杂对象 , 表示 对象 的 全部 或 部分 层次
 *  忽略层次 : 让 客户端 忽略 层次之间的差异 , 方便对 整个层次结构 进行控制
 *  简化客户端代码
 *  符合开闭原则

缺点:

*  限制类型复杂 : 限制类型时 , 比较复杂
 *  使设计变得更加抽象

具体实现:  
Component（抽象构件）：它可以是接口或抽象类，为叶子构件和容器构件对象声明接口，在该角色中可以包含所有子类共有行为的声明和实现。在抽象构件中定义了访问及管理它的子构件的方法，如增加子构件、删除子构件、获取子构件等。

Leaf（叶子构件）：它在组合结构中表示叶子节点对象，叶子节点没有子节点，它实现了在抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过异常等方式进行处理。

Composite（容器构件）：它在组合结构中表示容器节点对象，容器节点包含子节点，其子节点可以是叶子节点，也可以是容器节点，它提供一个集合用于存储子节点，实现了在抽象构件中定义的行为，包括那些访问及管理子构件的方法，在其业务方法中可以递归调用其子节点的业务方法。

组合模式的关键是定义了一个抽象构件类，它既可以代表叶子，又可以代表容器，而客户端针对该抽象构件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处理。同时容器对象与抽象构件类之间还建立一个聚合关联关系，在**容器对象中既可以包含叶子，也可以包含容器**，以此实现递归组合，形成一个树形结构。

public abstract class Component{
        
    public String getName() {
        
            throw new UnsupportedOperationException("不支持获取名称操作");
        }
    
        public void add(Component component) {
        
            throw new UnsupportedOperationException("不支持添加操作");
        }
    
        public void remove(Component component) {
        
            throw new UnsupportedOperationException("不支持删除操作");
        }
    
        public void print() {
        
            throw new UnsupportedOperationException("不支持打印操作");
        }
    
        public String getContent() {
        
            throw new UnsupportedOperationException("不支持获取内容操作");
        }
    }

实现一个文件夹类 Folder，继承 Component，定义一个 List 类型的componentList属性，用来存储该文件夹下的文件和子文件夹，并实现 getName、add、remove、print等方法

public class Folder extends Component{
        
        private String name;
        private List<Component> componentList = new ArrayList<Component>();
        
        ...
    
         public void print() {
        
            System.out.println(this.getName());
            for (Component component : this.componentList) {
        
                component.print();
            }
        }

文件类 File，继承Component父类，实现 getName、print、getContent等方法

public class File extends Component {
        
        private String name;
        private String content;
        ...
      }
    }

## 装饰设计模式 ##

装饰模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。  
这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

应用场景：  
1、扩展一个类的功能。  
2、动态增加功能，动态撤销。  
![uml图][uml]

具体的代码实现：  
1.抽象组件（Component）：抽象组件是一个抽象类。抽象组件定义了“被装饰者”需要进行“装饰”的方法；  
抽象定义相关方法：

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

\`2.具体组件（ConcreteComponent）：具体组件是抽象组件的一个子类，具体组件的实例称之为被装饰者；

class ConcreteComponent extend Component
    {
        
        public override void Operation()
        {
        
            Console.WriteLine("基本功能实现");
        }
    }

3.装饰（Decorator）:装饰也是抽象组件的一个子类，但但装饰还包含一个抽象组件声明的变量以保存“被装饰者”的引用。装饰可以是抽象类也可以是一个非抽象类，**如果是非抽象类，那么该类的实例就是“装饰者”**；

class Decorator extent Component
    {
        
        //维持一个对抽象构件对象的引用(既私有化处理)
        private readonly Component _Component; 
        //注入一个抽象构件类型的对象
        public Decorator(Component component)
        {
        
            _Component = component;
        }
        public override void Operation()
        {
        
            _Component.Operation();  //调用原有业务方法
        }
    }

4.具体装饰（ConcreteDecorator）：具体装饰是装饰的一个子类，具体装饰的实例称作装饰者。

class ConcreteDecorator extent Decorator 
    {
        
        public ConcreteDecorator(Component component) : base(component)
        {
        
    	}
    	public override void Operation() 
        {
        
    		base.Operation();  //调用原有业务方法
    		AddedBehavior();  //调用新增业务方法
    	}
        //新增业务方法
    	public void AddedBehavior() 
        {
        	
            Console.WriteLine("功能扩展实现");
        }
    }

## 策略设计模式 ##

策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01yTGlhcjE3_size_16_color_FFFFFF_t_70_pic_center][]  
代码实现：  
策略模式涉及三个角色  
**环境(Context)角色**：持有一个Strategy的引用。

public class Content {
        
    //持有一个接口的引用
        private Strategy strategy;
    //构造通过构造方法直接引入策略接口Strategy
        public Content(Strategy strategy){
        
            this.strategy=strategy;
        }
        /**
         * 策略方法
         */
        public void contextInterface(){
        
     //看起来类似接口调用，当然他不是啦
            strategy.strategyInterface();
        }
    }

有多个环境还需要，将环境大类抽象出来，不同环境继承接口进行实现  
eg:

abstract class Car{
        
        protected BrakeBehavior brakeBehavior;
        Car(BrakeBehavior brakeBehavior){
        
            this.brakeBehavior=brakeBehavior;
        }
        public abstract void brake();
    }
    class ShortWheelCar extends Car{
        
        ShortWheelCar(BrakeBehavior brakeBehavior) {
        
            super(brakeBehavior);
        }
        @Override
        public void brake() {
        
            brakeBehavior.stop();
        }
    }
    
    class LongWheelCar extends Car{
        
        LongWheelCar(BrakeBehavior brakeBehavior) {
        
            super(brakeBehavior);
        }
        @Override
        public void brake() {
        
            brakeBehavior.stop();
        }
    }

**抽象策略(Strategy)角色**：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

//策略接口
    public interface Strategy {
        
     //策略方法
        void strategyInterface();
    }

**具体策略(ConcreteStrategy)角色**：包装了相关的具体算法或行为，都实现接口，根据不同的情况进行处理

public class ConcreateStrategyA implements Strategy {
        
     
        @Override
        public void strategyInterface() {
        
            //do plan 1
        }
    }
     
    public class ConcreateStrategyB implements Strategy {
        
        @Override
        public void strategyInterface() {
        
            //do plan 2
        }
    }

[uml]: https://img-blog.csdnimg.cn/3afce27d2bfe414a8fde4a00b3331441.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01yTGlhcjE3_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20190212163800450.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01yTGlhcjE3,size_16,color_FFFFFF,t_70#pic_center