倘若,有這么一個需求,對于一個數(shù)字,如果是負的,那么需要變成正的相反數(shù),如果是2的倍數(shù),那么就除以2,如果是3的倍數(shù),那么就除以3,可能以后還有其他的需求,比如是5的倍數(shù),就再除以5,或者是6的倍數(shù),那么就加上6,也就是結(jié)果與順序息息相關(guān),那么應該如何來實現(xiàn)呢?
如果寫一個類的方法,按照這個需求來寫if語句,可以,但是,如果有兩套定制的呢?一套需要其中的幾種變化,另外需要另外幾種,那么就需要2個方法,而且其中有很多的重復代碼,這樣行不通的.
其實設計模式說到底,其根本思想就是找到變化并封裝之.這里變化的是處理的方法,那么我們就把它封裝起來.實現(xiàn)的類如下:
package decorater;
public class Integor {
private Integer x;
public Integer getX() {
return x;
}
public void setX(Integer x) {
this.x = x;
}
Integor(Integer x){
this.x = x;
}
}
由于Integer不能修改傳遞的值,所以寫一個類來封裝一個integer
/**
*
*/
package decorater;
public abstract class Decorater {
private Decorater next;
public Decorater setNext(Decorater dcrtr) {
this.next = dcrtr;
return this.next;
}
public void process(Integor x) {
this.executeBefore(x);
if (this.next != null) {
this.next.process(x);
}
this.executeAfter(x);
}
protected abstract void executeBefore(Object x);
protected abstract void executeAfter(Object x);
}
每個實現(xiàn)的類只需要來實現(xiàn)executeBefore和executeAfter方法即可.
注意實現(xiàn)的順序是
decorater1.executeBefore->decorater2.executeBefore->decorater3.executeBefore->decorater3.executeAfter->decorater2.executeAfter->decorater1.executerAfter
package decorater;
public class PositiveDecorater extends Decorater {
@Override
protected void executeAfter(Object x) {
System.out.println("PositiveDecorater end!");
}
@Override
protected void executeBefore(Object x) {
// TODO Auto-generated method stub
System.out.println("starting PositiveDecorater!");
Integor in = (Integor) x;
if (in.getX() < 0)
in.setX(-in.getX());
}
}
package decorater;
public class Devide2Decorater extends Decorater {
@Override
protected void executeAfter(Object x) {
System.out.println("Devide2Decorater end!");
}
@Override
protected void executeBefore(Object x) {
System.out.println("Starting Devide2Decorater!");
Integor in = (Integor) x;
if (in.getX() % 2 == 0) {
in.setX(in.getX() / 2);
}
}
}
package decorater;
public class Devide3Decorater extends Decorater {
@Override
protected void executeAfter(Object x) {
System.out.println("Devide3Decorater end!");
}
@Override
protected void executeBefore(Object x) {
System.out.println("Starting Devide3Decorater!");
Integor in = (Integor) x;
if (in.getX() % 3 == 0) {
in.setX(in.getX() / 3);
}
}
}
/**
*
*/
package decorater;
/**
* @author KONGHE
*
*/
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
Decorater a = new PositiveDecorater();
a.setNext(new Devide2Decorater()).setNext(new Devide3Decorater());
Integor x = new Integor(-18);
a.process(x);
System.out.println(x.getX());
}
}
輸出結(jié)果是:
starting PositiveDecorater!
Starting Devide2Decorater!
Starting Devide3Decorater!
Devide3Decorater end!
Devide2Decorater end!
PositiveDecorater end!
3
其實每種設計模式的核心思想都是一致的,但是沒有必要照本宣科,只要注意其模式的精髓,就可以了,剩下的就是自己去按照實現(xiàn)來設計其中的細節(jié)了.比如我設計這個模式,就是先寫了main函數(shù),把其中的方法寫好,然后去按照這個實現(xiàn)來想去如何實現(xiàn),這樣才更符合解決實際的問題.其實decorater模式有很多種實現(xiàn)方式.比如下面的這種解法,也可:
/**
*
*/
package decorator;
/**
* @author KONGHE
*
*/
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
DecoraterChain a = new DecoraterChain();
a.setNext(new PositiveDecorater()).setNext(new Devide2Decorater()).setNext(new Devide3Decorater());
Integer x = -32;
x = a.process(x);
System.out.println(x);
}
}
/**
*
*/
package decorator;
import java.util.ArrayList;
import java.util.List;
/**
* @author KONGHE
*
*/
public class DecoraterChain {
private List<Decorater> decorater = new ArrayList<Decorater>();
public DecoraterChain setNext(Decorater decrter) {
decorater.add(decrter);
return this;
}
public Integer process(Integer x) {
for (int i = 0; i < this.decorater.size(); i++) {
x = this.decorater.get(i).process(x);
}
return x;
}
}
/**
*
*/
package decorator;
/**
* @author KONGHE
*
*/
public abstract class Decorater {
public abstract Integer process(Integer x);
}
總而言之,模式是為了具體的實際情況而服務的,不要為了一定要去用某種設計模式而委屈自己的需求.
在設計的時候多想想,可能某天你再讀設計模式的書,你會發(fā)現(xiàn),原來我之前寫的代碼,包含了這么多的設計模式啊!