设计模式-装饰者模式-代理模式

装饰者模式

什么是装饰者模式：

动态地给一些对象添加一些额外的功能。就增加功能来说装饰者模式比生成子类更加灵活。装饰者模式是一种对象结构型模式。

装饰者模式的优缺点：

1. 装饰者模式与 类继承都是实现功能的扩展，但是装饰者模式比类继承有更多的灵活性。
2. 装饰者模式可以使用具体装饰类的排列组合，这样一来可以很轻易得到不同对象的行为。
3. 由于装饰者模式比类继承更加灵活，这样就意味着装饰者模式比类继承更加容易出错。

装饰者模式的应用举例：

1. 当我们需要为某个对象动态地增加属性和方法时，可以考虑使用装饰者模式。
2. 当对象的属性和方法经常变化的时候，我们可以考虑使用装饰者模式。

package com.lovo;
public interface BreadM {
  /*
  * 面包机
  */
  public String writeBread(String bread);
}
 
 
 
package com.lovo;
/*
 * 面包装饰类
 */
public class BreadDecorator implements BreadM {
  private BreadM breadM;
  public BreadDecorator(BreadM breadM){
     super();
     this.breadM=breadM;
  }
  
  @Override
  public String writeBread(String bread) {
     return breadM.writeBread(bread);
  }
}
 
 
 
package com.lovo;
/*
 * 夹心面包
 */
public class JiaxinBread extends BreadDecorator {
  public JiaxinBread(BreadM breadM) {
     super(breadM);
     // TODO 自动生成的构造函数存根
  }
  @Override
  public String writeBread(String bread) {
     // TODO 自动生成的方法存根
     String breadM=super.writeBread(bread);
     breadM+=("夹心面包");
     return breadM; 
  }
}
 
 
 
package com.lovo;
/*
 * 肉松面包
 */
public class RouBread extends BreadDecorator {
  public RouBread(BreadM breadM) {
     super(breadM);
     // TODO 自动生成的构造函数存根
  }
  @Override
  public String writeBread(String bread) {
     // TODO 自动生成的方法存根
     String breadM=super.writeBread(bread);
     breadM+=("肉松面包");
     return breadM; 
  }
}
 
 
 
package com.lovo;
/*
 * 普通面包
 */
public class SimpleBread implements BreadM {
  public SimpleBread(){
  }
  @Override
  public String writeBread(String bread) {
     String product="面包种类："+bread;
     return product;
  }
}
 
package com.lovo;
public class BreadTest {
  public static void main(String[] args) {
     RouBread breadM= new RouBread(new JiaxinBread(new SimpleBread()) );
     String content = breadM.writeBread("");
     System.out.println(content);
  }
}

代理模式

什么是代理模式

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

什么时候使用代理模式？

（1）授权机制：不同级别的用户对同一对象拥有不同的访问权限，例如对于论坛中不同的访问权限。
（2）某个客户端不能直接操作某个对象但是又必须和这个对象接触。

代理模式的角色及职责

（1）代理接口：用于抽象代理的行为和方法。
（2）被代理角色：它是业务逻辑的具体实现者。
（3）代理角色：它把所有的接口的方法教给具体的被代理对象去实现，而自己仅仅实现一些善后和前置工作。

public interface IPeople {
  //写发言稿
  public void write();
  //发工资
  public void salary();
  //考核绩效
  public void check();
}
 
/*
 * 代理角色：他把所有接口类定义的方法给被代理者去实现，并在处理前后做一些预处理和善后工作。
 */
public class Boss implements IPeople {
  @Override
  public void write() {
     System.out.println("老板写发言稿");
  }
  @Override
  public void salary() {
     System.out.println("老板发工资");
  }
  @Override
  public void check() {
     System.out.println("老板考核绩效");
  }
}

/*
 * 代理角色：业务逻辑的具体实现者
 */
public class Assistant implements IPeople{
  private Boss boss;
  public Assistant(){
  }
  @Override
  public void write() {
     if(null==boss){
       boss=new Boss();
     }
     boss.write();
  }
  @Override
  public void salary() {
     if(null==boss){
       boss=new Boss();
     }
     boss.salary();
  }
  @Override
  public void check() {
     if(null==boss){
       boss=new Boss();
     }
     boss.check();
  }
  public void driveAndDink(){
     System.out.println("我是助理，我帮老板开车和喝酒");
  }
}

public class Test {
  public static void main(String[] args) {
     Assistant assistant=new Assistant();
     assistant.write();
     assistant.check();
     assistant.salary();
     assistant.driveAndDink();
  }
}

代理模式和装饰者模式的区别

装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话 说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模 式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。
我们可以用另外一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。