裝飾者模式

裝飾者模式

1、定義

裝飾者模式：動態的給對象添加一些額外的屬性或者行爲(方法)，無需修改本來的對象，直接添加就行，相比於繼承，裝飾者模式更加的靈活。

UML圖：

Component是一個基類，被裝飾類ConcreateComponent和裝飾類Decorator都是繼承這個基類。

2、實例運用

需求：一我的出門，根據不一樣的時候穿不一樣的衣服，現有短T，衛衣，夾克。

由於在此需求中，沒有基類的抽象類。所以人即表明基類的抽象類Component也表明具體的被裝飾者類ConcreteComponent。

 

第一步：建立被裝飾類Person

package com.golf.decoration;
​
public class Person {
   private String name;
   public Person(){
​
   }
​
   public Person(String name) {
       this.name = name;
   }
​
   public void show(){
       System.out.println("裝扮的是："+name);
   }
}
​

第二步：建立抽象的裝飾類Cloth

package com.golf.decoration;
​
//裝飾類(接口)
public class Cloth extends Person {
   private Person component;
​
   //裝飾
   public void decorate(Person component){
       this.component = component;
   }
    
   public void show(){   //調用被修飾類Person的show方法
       if(component != null)
             component.show();
   }
}
​

第三步：建立各個具體的裝飾類

Tshirt類

package com.golf.decoration;
​
//具體的修飾類
public class Tshirt extends Cloth {
   @Override
   public void show() {     //Tshirt類特有的信息
       System.out.println("Tshirt");
       super.show();
   }
}
​

Jacket類

package com.golf.decoration;
​
//具體的裝飾類
public class Jacket extends Cloth{
   @Override
   public void show() {
       System.out.println("夾克");
       super.show();
   }
}
​

Hoodie類

package com.golf.decoration;
​
//具體的裝飾類
public class Hoodie extends Cloth {
   @Override
   public void show() {
       System.out.println("衛衣");
       super.show();
   }
}
​

第四步：建立客戶端進行調用

package com.golf.decoration;
​
​
public class Client {
   public static void main(String[] args) {
       Person person = new Person("吳彥祖"); //建立被修飾類
   //   person.show();
       Hoodie hoodie = new Hoodie();
       Jacket jacket = new Jacket();
       hoodie.decorate(person);
       jacket.decorate(hoodie);
       jacket.show();
​
   }
}
​

第二個實例：

賣蛋糕，蛋糕原價66元，假若加奶油須要加10元，假若加蠟燭加16元

第一步：建立被修飾類和修飾類的基類

package com.golf.decoration2;
​
//建立被修飾類和修飾類的基類
public abstract class Sweet {
   private String name;
    
   //修飾的方法
   public String getDescription(){   //讓繼承的被修飾類的方法可以繼承
       return name;
   }
    
   //修飾的方法
   public abstract double cost(); //讓繼承的被修飾類的方法可以繼承
}
​

 

第二步：建立被修飾類

package com.golf.decoration2;
​
//建立被修飾類 concreteComponent
public class Cake extends Sweet {
​
   @Override
   public String getDescription() { //寫入被修飾類的特性
         return "蛋糕";
   }
​
   @Override
   public double cost() {   //寫入被修飾類的特性
       return 66;
   }
}
​

第二步：建立修飾類的基類

package com.golf.decoration2;
​
//建立修飾類
public abstract class Decoration extends Sweet{
   @Override
   public abstract String getDescription(); //建立抽象方法的裝飾 便於具體的裝飾方法使用
​
   @Override
   public abstract double cost();
}
​

第三步：建立具體的修飾類

package com.golf.decoration2;
​
//建立修飾類
public class Candle extends Decoration {
   private Sweet sweet;
    
   public Candle(Sweet sweet){ //經過構造方法選擇修飾那個類
     this.sweet = sweet;
   }
    
   @Override
   public String getDescription() {
       return sweet.getDescription()+"蠟燭";
   }
​
   @Override
   public double cost() {
       return sweet.cost()+16;
   }
}
​

package com.golf.decoration2;
​
//建立修飾類
public class Cream extends Decoration {
   private Sweet sweet; //對於修飾類建立基類，以此知道修飾的是哪一個類
   public Cream(Sweet sweet){
       this.sweet = sweet;
   }
   @Override
   public String getDescription() {
       return sweet.getDescription()+"奶油";
   }
​
   @Override
   public double cost() {
       return sweet.cost()+10;
   }
}
​

第四步：客戶端

package com.golf.decoration2;
​
public class Client {
   public static void main(String[] args) {
       Cake cake = new Cake();
       String name = cake.getDescription();
       double cost = cake.cost();
       System.out.print(name);
       System.out.println(cost);
       Cream cream = new Cream(cake);
       Candle candle = new Candle(cream);
       Candle candle1 = new Candle(new Cream(new Cake())); //是否是很像IO流中建立時的樣子，IO流就是用來裝飾者模式
       System.out.println(candle1.cost());
       System.out.println(cream.getDescription()+cream.cost());
       System.out.println(candle.getDescription()+candle.cost());
   }
}
​