Java学习笔记——设计模式之三.装饰模式

函数应该做一件事，做好这件事，只做这一件事。

　　　　　　　　　　　　　　　　　　　　——Clean Code

装饰模式,上代码:

先定义零件类:

 package cn.no3.decorator.template;

 public abstract class Component {

     public abstract void operation();
 }

再定义具体零件类(即被装饰类)继承零件类:

 package cn.no3.decorator.template;

 public class ConcreteComponent extends Component{

     @Override
     public void operation() {
         // TODO Auto-generated method stub
         System.out.println("对一个Object进行装饰：");
     }

 }

然后定义装饰类,继承零件类:

 package cn.no3.decorator.template;

 public class Decorator extends Component {

     protected Component component;

     public void setComponent(Component component) {
         this.component = component;
     }

     @Override
     public void operation() {
         //调用的是传入component的operation方法
         if (component != null) {
             component.operation();
         }

     }

 }

定义装饰类的子类:

 package cn.no3.decorator.template;

 public class ConcreteDecoratorA extends Decorator {

     private String addedField;

     @Override
     public void operation() {
         // TODO Auto-generated method stub
         super.operation();//第一行调用super,则从前往后包装.反之则从后往前包装
         addedField = "新的装饰物A";
         System.out.println("装饰了:"+addedField);
     }
 }

 public class ConcreteDecoratorB extends Decorator {

     @Override
     public void operation() {
         // TODO Auto-generated method stub
         super.operation();
         AddedBehavior();
     }

     private void AddedBehavior() {
         // TODO Auto-generated method stub
         System.out.println("完成装饰，最后照个相");
     }

 }

测试类测试:

 package cn.no3.decorator.template;

 public class _Test {

     public static void main(String[] args) {
         //新建装饰对象
         ConcreteComponent concreteComponent = new ConcreteComponent();
         ConcreteDecoratorA concreteDecoratorA = new ConcreteDecoratorA();
         ConcreteDecoratorB concreteDecoratorB = new ConcreteDecoratorB();
         //逐层包装
         //如果注掉下句,还是先调用A的super,发现没传component,于是A的super什么都不做
         concreteDecoratorA.setComponent(concreteComponent);//A先调用cC,cC方法不再调用super.
         concreteDecoratorB.setComponent(concreteDecoratorA);//B先调用A
         //输出最终结果
         concreteDecoratorB.operation();
     }
 }

把这个例子中的Component类换成接口也是一样的:

举个例子:

需求:

定义一个角色,让他实现IWearable接口,

再定义装备实现IWearable接口

人物装备装备.

上代码:

 package cn.no3.decorator.instance;

 public abstract interface IWearable {

     public abstract void operation();
 }

 package cn.no3.decorator.instance;

 public class Clothes implements IWearable {

     protected IWearable component;

     public void setComponent(IWearable component) {
         this.component = component;
     }

     @Override
     public void operation() {
         if (component != null) {
             component.operation();
         }

     }

 }

 package cn.no3.decorator.instance;

 //即使只有一双鞋也要定义父类,否则无法通过对象的super.operation对装饰进行传递
 public class Shoes implements IWearable {

     protected IWearable component;

     public void setComponent(IWearable component) {
         this.component = component;
     }

     @Override
     public void operation() {
         if (component != null) {
             component.operation();
         }
     }

 }

 package cn.no3.decorator.instance;

 public class Weapons implements IWearable {

     protected IWearable component;

     public void setComponent(IWearable component) {
         this.component = component;
     }

     @Override
     public void operation() {
         if (component != null) {
             component.operation();
         }

     }

 }

他们的子类都是重写父类operation()方法,最先调用(或者最后调用),super.operation();此处省略若干行

 package cn.no3.decorator.instance;

 public class WeaponA extends Weapons {

     @Override
     public void operation() {
         // TODO Auto-generated method stub
         super.operation();
         System.out.println("装备了:霜之哀伤");
     }
 }

角色类

 package cn.no3.decorator.instance;

 public class Character implements IWearable{

     @Override
     public void operation() {
         // TODO Auto-generated method stub
         System.out.println("对一个人物进行装备：");
     }

 }

测试类:

 package cn.no3.decorator.instance;

 public class _Test {

     public static void main(String[] args) {
         //新建装备对象
         Character concreteComponent = new Character();
         ClotheA fantasyKiller = new ClotheA();
         ClotheB bravingArmor = new ClotheB();
         WeaponA frostmourne = new WeaponA();
         WeaponB DoubleRoses = new WeaponB();
         ShoesA shoes = new ShoesA();
         //逐层包装
         fantasyKiller.setComponent(concreteComponent);
         bravingArmor.setComponent(fantasyKiller);
         frostmourne.setComponent(bravingArmor);
         DoubleRoses.setComponent(frostmourne);
         shoes.setComponent(DoubleRoses);//shoes.setComponent(shoes)会陷入死循环
         //输出最终结果
         shoes.operation();
     }
 }

装饰模式是为已有功能动态地添加更多功能的一种方式

装饰模式把每个要装饰的功能放在单独的类中，并让这个类包装它所需要装饰的对象。因此，当需要执行特殊行为时，客户代码就可以在运行时根据需要有选择地、按顺序地使用装饰功能包装对象了。

装饰功能的核心是：把类中的装饰功能从类中搬出去。