顯示具有 Java 標籤的文章。 顯示所有文章
顯示具有 Java 標籤的文章。 顯示所有文章

2011年7月19日 星期二

在Android內實現Callback

寫JavaScript一定對CallBack的使用相當熟悉,但是當你要寫Java或Android
卻發現沒辦法把function當作參數傳給另一個function當CallBack用
因為在Java內並沒有function pointer,所以就有點麻煩
這時候可以用類似Observer的方式來做
簡單來說就是,既然無法丟一個function進去
那你可以把要執行的function放到一個物件內
把物件當參數丟進去就可以了

作法
一.建立公用的Observer Interface
利用Interface將允許使用的method定義出來
例
public interface IObserver{
    public abstract void success(Object data);
    public abstrcat void fail(String msg);
    public abstract void exception(String msg)
}

二.建立要使用的observer Class
把要做的工作在這這Class內實做出來
當然你也可以把這Class建立主(main)程式內,
這樣可以更方便
例
public class MyObserver implements IObserver{
    @override
    public abstract void success(Object data){
        ...
    };
    @override
    public abstrcat void fail(String msg){
        ...
    };
    @override
    public abstract void exception(String msg){
        ...
    }    
}

三.主程式應用
public class myApp{
    ....
    public void run(int status,IObserver observer){
        .....
        if(status==1){
            observer.success(data)
        }else if(status==2){
            observer.fail()
        }else{
            observer.exception("exception");
        }
    };
}

2010年5月18日 星期二

Design Pattern : 21 Proxy

有的物件在初始化時,需要消耗較大的系統效能,也比較花費時間
若要加速整個系統的初始化效能,不至於loading過久
如果可以讓物件在真正被使用時,才被實體化
那就可以加速整個系統的初始化載入
這就是Proxy Pattern所要提供的功能

原本的程式執行流程是,
一開始先初始化物件 real=new Real()
要執行功能時就呼叫物件的method real.method()
若改成利用Proxy Pattern
則是變成,在要執行物件的功能時
才去初始化物件實體,並呼叫其功能
而在這裡,讓功能物件與使用的Proxy繼承自相同的Interface
因為具備有相同的method

這樣你就可以在外部程式很輕鬆的切換並決定是否要使用proxy
或在Prxoy內作一些額外的處理後,再傳遞給真正的執行物件
參與者
1.Printable Interface
定義一個執行物件與Proxy的共通介面
public interface Printable {
    public void print(String msg);
}

2.Printer 真正的功能執行物件
實作介面所定義的必要功能
public class Printer implements Printable {
    @Override
    public void print(String msg) {
        System.out.print("Run Print="+msg);
    }
}

3.PrinterProxy
在Proxy內儲存了一個真正執行物件的實體(real)
而在實作功能上,才去初始化產生出物件
並執行功能
public class PrinterProxy implements Printable {
    private Printer real;
    @Override
    public void print(String msg) {        
        if(real==null){
            real=new Printer();            
        }
        real.print("From Proxy:"+msg);
    }
}

4.Main外部應用程式
可以很簡單的切換使用proxy或物件本體
去執行功能
public static void main(String[] args) {
    PrinterProxy myP=new PrinterProxy();
    //Printer myP=new Printer();
    myP.print("HELLO");
}

2010年5月17日 星期一

Design Pattern : 20 Flyweight

Flyweight的目的在減輕記憶體的使用量,
也就是減少new出新的物件佔據記憶體。

在整個Pattern的運作上,利用一個Factory Pool,
當需要新的物件會先向Factory查詢,
如果在Pool內已經存在,那就直接由pool內取得回傳,
若pool內沒有,才new出新物件,並存到pool內,
讓以後要用的可以取用
如此,所有相同的物件都只會被new出一個實體,
若有需要用到相同的實體,只需取用既有的instance即可

參與者
1.Animal 產生各式物件的Class
使用者要產生animal 實體,若在一般程式上會直接
new Animal,但在這Pattern下,new Animal動作是由
Factory來執行,而非由外部程式來直接產生物件
public class Animal {
    private String name;
    public Animal(String name){
        this.name=name;
        System.out.println(this.name+"--Created\n");
    }
    public void run(){
        System.out.print(this.name+"--run\n");
    }
}

2.Factory 管理所有物件的Factory
利用一個Hashtable當作pool來儲存可攻使用的instance
public class Factory {
    private Hashtable<String, Animal> pool=new Hashtable<String, Animal>();
    private static Factory instance=new Factory();
    public static Factory getInstance(){
        return instance;
    }
    public synchronized Animal getAnimal(String name){
        if(pool.get(name)==null){
            Animal tmpAnimal=new Animal(name);            
            pool.put(name,tmpAnimal);
            return tmpAnimal;
        }else{
            return pool.get(name); 
        }
    }
}

3.Main外部程式
public class Main {
    public static void main(String[] args) {
        Factory factory=Factory.getInstance();
        factory.getAnimal("man").run();
        factory.getAnimal("dog").run();
        factory.getAnimal("man").run();
        factory.getAnimal("cat").run();
        factory.getAnimal("dog").run();
        factory.getAnimal("dog").run();
    }
}
4輸出結果
由結果可以看出,每種animal都只會被產生一次
man--Created
man--run

dog--Created
dog--run

man--run

cat--Created
cat--run

dog--run

dog--run

2010年5月7日 星期五

Design Pattern : 19 State

如果在開發程式裡,會需要對不同的狀態,有不同的處理方式
可以把各種狀態的處理,各自包裝形成一個獨立的State Class
也就是說,透過State切割,把複雜的處理,切割成各自獨立小的區塊,
每個State很單純的處理該狀態下的執行功能,
以這方式執行,亦可很輕易的擴充程式功能

參與者
1.State 介面
定義出所有State所允許被呼叫的共同function
public interface State {
   public void showMessage(String user);
}

2.DayState 依照State實作出的Class
public class DayState implements State {
    private static DayState instance=new DayState();
    public static DayState getInstance(){
        return instance;
    }
    @Override
    public void showMessage(String user) {        
        System.out.println(user+" : Its Day");
    }
}

3.NightState 依照State實作出的Class
public class NightState implements State {
    private static NightState instance=new NightState();
    public static NightState getInstance(){
        return instance;
    }
    @Override
    public void showMessage(String user) {        
        System.out.println(user+" : its Night");
    }
}

4.MyFrame 使用State的主要程式
包含了setState function作為狀態轉移使用
在這裡要執行的動作,都只需要呼叫state的method即可,不需要
考慮真正的State實體是哪一個,
State的轉換都會透過外部呼叫setState來改變
public class MyFrame {
    private State state;
    public MyFrame(){}
    public void setState(String info){
        if(info=="day"){
            state=DayState.getInstance();
        }else{
            state=NightState.getInstance();
        }
    }
    public void showMessage(String user){
        state.showMessage(user);
    }
}

5.Main 外部程式
MyFrame frame=new MyFrame();
for(int hour=1;hour<=24;hour++){
    if((hour>=8)&&(hour<=18)){
        frame.setState("day");
    }else{
        frame.setState("night");
    }
    frame.showMessage("ozzy");
    try{
        Thread.sleep(1000);
    }catch(InterruptedException e){}
    
}

2010年5月5日 星期三

Android,Flash,Java EventListener比較

在Flash,Java,Android上對於事件的處理
同樣使用Listener,有著類似但有些差異的語法
以下以常用的滑鼠click事件做簡單比較

一.Flash
Flash在對於所有的Event統一使用addEventListner method來做監聽
主要傳入的兩個參數,分別是要監聽的事件類型與要觸發的function


btn:Button=new Button();
addChild(btn);
btn.addEventListner(MouseEvent.CLICK,onClickHandler)
function onClickHandler(e:MouseEvent):void{
    //..do something..
}


二.Java
在Java上要監聽不同的事件,要使用不同的addXXXListener method
例如addActionListener,addWindowListener...
每個不同的addXXXListener method所接收的參數
都是不同的Listner物件instance,
所要執行的動作則是在這Listner物件內 implement
要監聽的動作 handler


Button btn=new Button();
add(btn);
btn.addActionListener(myactionListener);
ActionListener myactionListener=new ActionListener(){
    public void actionPerformed(ActionEvent e) {
        //..do something..
    }
}


三.Android
在Android上同樣是對不同的事件,有不同的setXXXListener
每個setXXXListener所接收參數都是不同的listener物件
與Java的差異是method名稱addXXXListener與setXXXListener
的不同而已
例setOnClickListener ,setOnFocuseChangeListener,
setKeyListener..


Button btn=(Button)findViewById(R.id.mybtnid);
btn.setOnClickListener(myclickListener);
Button.OnClickListener myclickListener=new Button.OnClickListener(){
    public void onClick(View v){
        //..do something..
    }
}


2010年4月30日 星期五

Design Pattern : 18 Memonto

當我們希望在所開發的程式裡,可以提供Redo Undo的功能
可以利用Memonto Pattern達到這個目標
把Memonto物件放在要提供Undo功能的程式中(Subject)

參與者
1.Memonto
Memonto本身利用一個陣列來儲存資料,當要restor資料,再
由陣列倒回來

public class Memonto {
    private Vector<String> memos=new Vector<String>();
    public void save(String value){
        memos.add(value);
    }
    public String restoreLast(){
        memos.removeElementAt(memos.size()-1);
        return result;
    }
}

2.Subject
要使用memo功能的主程式
當主程式執行save功能時,是把資料丟給memo去儲存
當要undo時,再利用memo把資料取回,寫回本應用程式的變數中

public class Subject {
    private Memonto memo;
    private String myText;
    public Subject(){
        memo=new Memonto();
    }
    public void save(String value){
        myText=value;
        memo.save(myText);
    }
    public String undo(){
        myText=memo.restoreLast();
        return myText;   
    }
}

3.Main
外部程式,只要呼叫應用程式提供的save跟undo method即可
不用管subject內部memo如何運作

TextField text=new TextField()
Subject subject=new Subject();
儲存
subject.save(text.getText());
Undo
text.setText(subject.undo());


2010年4月28日 星期三

Design Pattern : 17 Observer

在一個程式主體(Generator),如果內部運算後產生一些變化,希望可以把變化的結果,通知外部特定對象,可以把要通知的對象都設定成Observer

在Generator內需要有把observer加入觀察的method(addObserver)
與通知observer的功能(notifyObserver),而在observer內,會需要有一個update的method
可以在接收到Generator的通知後,到Generator內取到結果,這樣當主體程式有所變化,所有設定的observer都會接收到通知,而做適當的訊息處理

參與者
1.Generator
   可以使用Observer的Class
   addObserver:把觀察者加進來的method
   notifyObserver:用來通知所有observer的method
   excute:執行程序,在這類別真正要執行的工作,當工作完成
一定要觸發notifyObserver通知所有的觀察者
   getNumber:這是讓Observer接收到通知後,回來取值得method


public abstract class Generator {
    private Vector<Observer> observers=new Vector<Observer>();   
    private int number;
    public void addObserver(Observer observer){
        observers.add(observer);       
    }
    public void deletObserver(Observer observer){
        observers.remove(observer);
    }
    private void notifyObserver(){
        Iterator<Observer> it=observers.iterator();
        while(it.hasNext()){           
            ((Observer)it.next()).update(this);
        }
    }
    public void excute(){
        Random random=new Random();
        number=random.nextInt(50);
        notifyObserver();
    };
    public int getNumber(){
        return number;
    };
}


2.Observer interface
   Observer可能有很多個,先設定一個所有observer需遵循的統一介面
   update:當obsever被通知,就是被Generator呼叫了這個updtae method
   在這個method內可以利用傳進來的Generator物件,再回去取到變化的值

public interface Observer {
    public abstract void update(Generator gen);
}


3.FirstObserver 實作類別

public class FirstObserver implements Observer {   
    public void update(Generator gen) {
        System.out.println("First:"+gen.getNumber());
    }
}


4.SecondObserver

public class SecondObserver implements Observer {
    public void update(Generator gen) {
        System.out.println("Second:"+gen.getNumber());
    }
}


5.Main外部程式
只要產生Generator,加入關聯的observer後
就可以執行他要做的動作,同時在這動作內也已經
包含了通知observer的功能


Generator gen=new Generator();
gen.addObserver(new FirstObserver());
gen.addObserver(new SecondObserver());
gen.excute();


2010年4月27日 星期二

Design Pattern : 16 Mediator

Mediator的角色,通常都是當作UIComponent的代理人
UIComponent是使用者會直接接觸到的元件
如Button,TextField等,當我們在操作這些UIComponent
UIComponent 只是用來當作View顯示,而不做邏輯處理
也就是說,當接收到使用者的指令,如按鈕,輸入文字..
會把這些事件丟出去,往外通知
UIComponent..只是單純被操作
事件丟出的方式,可以是用dispatchEvent方式廣播
或是通知mediatior來處理
而Mediator的角色,就是主程式與UIComponent間的橋樑

參與者
1.Mediator 介面
createColleagus:利用這method把所有的UIComponent登錄到Mediator上
colleagusChanged:當有登錄的UIComponent狀態改變時都會呼叫這method
通知mediator作處理

public interface Mediator {
    public abstract void createColleagus();
    public abstract void colleagusChanged(Colleagus colleagus);
}

2.Colleagus
所有的UIComponent都implement這介面,讓UIComponent都有可以跟
mediator溝通的共同method
setColleagusEnabled:要改變UComponent不要直接去操作到UIComponent,
而是透過一個public API去操作


public interface Colleagus {
    public abstract void setMediator(Mediator mediator);
    public abstract void setColleagusEnabled(boolean enabled);
}

3.ColleagusTextField 實作的Colleagus
本身是TextField,同時也以自己當作TextListener
textValueChanged:當TextEvent被觸發時會執行這method
在這method中通知mediator

public class ColleagusTextField extends TextField implements Colleagus,TextListener{
    private Mediator mediator;
    public ColleagusTextField(String text,int columns){
        super(text,columns);
    }
    @Override
    public void setColleagusEnabled(boolean enabled) {       
        setEnabled(enabled);
        setBackground(enabled?Color.white:Color.gray);
    }
    @Override
    public void setMediator(Mediator mediator) {       
        this.mediator=mediator;
    }
    @Override
    public void textValueChanged(TextEvent arg0) {       
        this.mediator.colleagusChanged(this);
    }
}

4.LoginFrame 實作的Mediator

public class LoginFrame extends Frame implements Mediator,ActionListener{
    private ColleagusTextField textUser;
    public LoginFrame(String title){
        super(title);
        setBackground(Color.lightGray);
        setLayout(new GridLayout(4,2));       
        createColleagus();
        add(textUser);
        pack();
        setVisible(true);       
    }
    @Override
    public void colleagusChanged(Colleagus c) {
       
    }
    @Override
    public void createColleagus() {
        textUser=new ColleagusTextField("input user name",10);
        textUser.setMediator(this);
        textUser.addTextListener(textUser);   
    }
    @Override
    public void actionPerformed(ActionEvent arg0) {
           
    }
}

5.Main 外部程式

new LoginFrame("Main Frame");


2010年4月20日 星期二

Design Pattern : 15 Facade

當要執行複雜的多物件功能呼叫使用
可以利用Facade提供單一介面,整合這些要做的功能
讓使用者只要透過呼叫Facade所提供的單一介面窗口
就可執行整個複雜的工作內容
例如,希望載入外部資料庫(DataBase),並利用這些載入的資料,
產生網頁(HtmlWriter),這工作
參與者
1.DataBase
  用來載入外部資料的類別

public class Database {
    private Database(){}
    public static Properties getProperties(String dbName){
        String fileName=dbName;
        Properties prop=new Properties();
        prop.load(new FileInputStream(fileName));
        return prop;       
    }
}

2.HtmlWriter
  用來產生網頁檔案的類別

public class HtmlWriter {
    private Writer writer;
    public HtmlWriter(Writer writer){
        this.writer=writer;
    }
    public void title(String title)throws IOException{
        writer.write("<html><head>");   
        writer.write("<title>"+title+"</title");
        writer.write("</head><body>\n");
        writer.write("<h1>"+title+"</h1>\n");
    }
    public void close()throws IOException{
        writer.write("</body></html>");
        writer.close();
    }
 }

3.Facade
用來整合功能的介面

public class Facade {
    private Facade(){}
    public static void makeWelcomePage(String dbFileName,String addr, String outFileName){
        Properties mailProp=Database.getProperties(dbFileName);
        String userName=mailProp.getProperty(addr);               
        HtmlWriter writer=new HtmlWriter(new FileWriter(outFileName));
        writer.title("Welcome "+userName);           
        writer.close();
    }
}

4.Main
外部程式

Facade.makeWelcomePage("d:\\list.txt","xxx@xxx.com","d:\\newPage.htm");

  

2010年4月16日 星期五

Design Pattern : 14 Chain of Responsibility


轉送,當對於一個複雜的問題處理,可以把問題拆解成多個單一的問題處理方法(Support)每個Support,遇到丟進來的問題,會試著去解決
Support.support(trouble)
當無法解決時,就看看是否已經有利用Support.setNext(nextSupport),設定好下一個Support
如果有,就把問題丟給下一個support處理
nextSupport.support(trouble)
這樣的做法,可以讓每個Class可以很單純的處理一個問題,而且可以彈性的串接不同的Command

參與者
1.abstract Support
在Support這主要的Class內定義好程式判斷的流程,也就是support function
決定了判斷邏輯,後面繼承者,只需要把問題處理的部份(resolve)實作即可

public abstract class Support {
  public Support setNext(Support next){
     this.next=next;
     return next;
  }
  public final void support(Trouble trouble){
    if(resolve(trouble)){
        success();
    }else{
        fail();
        if(next!=null){
          next.support(trouble);
        } 
    }
  }
 protected abstract boolean resolve(Trouble trouble);
 private void success(){}
 private void fail(){}
}


2.RealSupport
可以針對各式的解決方法,產生多個不同的support子類別
每個class的都只要針對resolve function實作處理的結果即可

public Class RealSupport01 extends Support{
    protected boolean resolve(Trouble trouble){
              ......
      }
}



public Class RealSupport02 extends Support{
     protected boolean resolve(Trouble trouble){
         ......
     }
}


4.Trouble

public Class Trouble{...} 



5.Main
外部程式,產生各個解決問題的support實體,並利用
setNext設定其解決問題的順序

Support sp1=new RealSupport01();
Support sp2=new RealSupport02();
sp1.setNext(sp2);
sp1.support(new Trouble());


 

2010年4月15日 星期四

Design Pattern : 13 Visitor

如果我們需要對一個複雜系統架構(Acceptor),針對整個系統做一巡訪
並做不同的動作處理,將把這處理器(Visitor)的部份獨立出來成為物件
也就是將資料處理由資料結構中分離出來,就是Visitor Pattern

例如,你有一個檔案架構系統,你希望把整個檔案目錄架構整個列印出來
我們需要有一個print_Visitor是負責來做把檔案列印出來的工作,
只要把這print_Visitor丟到一個複雜架構(acceptor)內,就會達到這目的

如果我們希望在這檔案架構內,希望可以把所有圖檔都可以產生一個縮圖
這時候,你可以產生另一個thumb_Visitor,用來負責產生縮圖的工作
只要把這thumb_Visitor丟到架構內,就會達到目的

對於一個複雜架構的系統(Acceptor),丟進去不同功能的Visitor
就可以對整個系統做不同功能的事

實作Visitor Pattern會用到一個比較複雜的遞迴(Double dispatch)
一般遞迴是自己呼叫自己,在這裡面是Acceptor與Visitor的彼此呼叫遞迴


參與者
1.Acceptor
Acceptor內需要定義一個accept method,這method只是都固定用來
把自己當作參數,呼叫啟動visitor的巡訪動作

public Class Acceptor {
     public void accept(Visitor v){
   v.visit(this)
     };
     .....
}

2.Visitor
程式的運作核心是在Visitor的visit function

public Class Visitor{
 public void visit(Acceptor entry){ 
  Iterator it=entry.iterator()
  while(it.hasNext()){
   Acceptor en=it.next();
   en.accept(this);
  }
 }
}

3.Main
外部程式

Acceptor rootdir=new Acceptor("root");
rootdir.accept(new Visitor());
4.在Visitor實作迴圈上

private String currentdir=""
public void visit(Directory dir){
 String savedir=currentdir+"/"+dir.getName()
 Iterator it=dir.iterator();
 while(it.hasNext()){
  Entry entry=(Entry)it.next();
  entry.accept(this)
 }
 currentdir=savedir;
}

在這範例內,先以一個currentdir儲存目前所在的目錄名稱
savedir會是下一層的entry所在的目錄名稱
所以在while迴圈內,利用it.next()取到的entry是與目前entry同層級的物件
entry.accept(this)裡 的this內的currentdir與現在所在的相同
while迴圈處裡完,也就是同層級的都處裡完了

currentdir=savedir是設定好,下一層級所在的目錄
下一個層級的this取到currentdir就會是目前層級得savedir

2010年3月26日 星期五

Design Pattern : 12 Decorator


把裝飾物件與主要內容物件當成相同的物件,也就是給予相同的API
可以在程式內用相同的方式操作,就可以用來組合出有彈性並複雜的結果
這就是Decorator

把裝飾與實際內容物當作相同的方式處裡
範例,要讓輸出字串可以彈性的增加外觀修飾的裝飾
把輸出物拆解成主要內容與裝飾內容,裝飾內容可能也多種的變化


參與者
1.Display (abstract)
提供一個主要內容與裝飾物都要依循的標準操作方法(API)


public abstract class Display {
    public abstract int getColumns();
    public abstract int getRows();
    public abstract String getRowText(int row);
    public final void show(){
        for(...){
            System.out.println(getRowText(i));
        }
    }
}


2.StringDisplay 主內容顯示類別
真正的主要內容顯示class,在實作抽象method時,具體的執行工作內容


public class StringDisplay extends Display {
    private String string;
    public StringDisplay(String string){
        this.string=string;
    }
    public int getColumns() { 
        return string.getBytes().length;
    }
    public int getRows() { 
        return 1;
    }
    public String getRowText(int row) { 
        if(row==0){
            return string;
        }else{
            return null;
        } 
    }
}


3.Border(abstract)
修飾抽象類別,還是繼承了主要Display類別,但是導入了一個display物件
來作為內部method委讓操作使用


public abstract class Border extends Display {
    protected Display display;  
    public Border(Display display){
        this.display=display;
    }
}


4.SlideBorder
在實作抽象method內,利用委讓操作display物件取得主要內容
再添加上裝飾的內容後,將最後結果輸出


public class SlideBorder extends Border {
    private char borderChar;
    public SlideBorder(Display display,char borderChar){
        super(display);
        this.borderChar=borderChar;
    }
    public int getColumns() {
        return 1+display.getColumns()+1;
    }
    public int getRows() {
        return display.getRows();
    }
    public String getRowText(int row) {
        return borderChar+display.getRowText(row)+borderChar;
    }
}


5.Main外部程式
可任意包裝產生所要的結果


Display b1=new StringDisplay("hello ozzy");
b1.show();
Display b2=new SlideBorder(new StringDisplay("hello sun"),'*');
b2.show();



2010年3月25日 星期四

Design Pattern : 11 Composit





當我們遇到有容器(container)與內容(content)需要作遞迴處理
例如要對一個目錄下所有的檔案與目錄都作處理
因為目錄(container)與檔案(content)都可以被裝到目錄下
這時候,可以把兩者都當作是"目錄進入點"(entry)來看
這時候容器與內容就都是屬於同一類的東西

這時候針對entry上定義一個"進入點"所需要的功能
而容器與內容都只是entry的子類別,在遞迴程序的操作上
只要使用屬於entry的method即可,而不用管是容器或是內容

參與者
1.Entry(abstract)
實際執行顯示的是printList(String prefix)
這部份在子類別內實作
而留給外部呼叫的只有printList()



public abstract class Entry {
    public abstract String getName();
    public abstract int getSize();
    public void printList(){
        priinList("");
    }
    protected abstract void printList(String prefix);
}

2.File
把Entry內設定的3個abstract method 實作出來


public class File extends Entry {
    private String name;
    private int size;
    public File(String name,int size){
        this.name=name;
        this.size=size;
    } 
    public String getName() { 
        return this.name;
    }
    public int getSize() { 
        return this.size;
    }
    protected void printList(String prefix) { 
        System.out.println(prefix+"/"+this);
    }
}

3.Directory
在屬於container的class內使用iterator來迴圈執行entry所提供的method


public class Directory extends Entry {
    private String name;
    private Vector directory=new Vector();
    public Directory(String name){
        this.name=name;
    }
    public String getName() {  
        return this.name;
    }
    public int getSize() { 
        int size=0;
        Iterator it=directory.iterator();
        while(it.hasNext()){
            Entry entry=(Entry)it.next();
            size+=entry.getSize();
        }
        return size;
    }
    protected void printList(String prefix) {
        //把自己列印出來,並叫其子node執行entry的列印指令
        System.out.println(prefix+"/"+this);
        Iterator it=directory.iterator();
        while(it.hasNext()){
            Entry entry=(Entry)it.next();
            entry.printList(prefix+"/"+name);
        }
    }
    public Entry add(Entry entry){
        directory.add(entry);
        return this;
    }
}

4.Main 外部程式


Directory root=new Directory("root");
Directory folder1=new Directory("folder1");
File file1=new File("file01",100);
File file2=new File("file02",200);
root.add(folder1);
folder1.add(file1);
folder1.add(file2);
root.printList(); 



2010年3月15日 星期一

Design Pattern : 09 Bridge

通常產生子類別,會有兩種型態
1.extends繼承:
以繼承方式來產生子類別的目的,是在子類別新增功能
屬於功能性的擴增
2.implement實作:
父類別只是一個抽象類別(abstract)或介面(interface)
實作後的子類別,與父類別的功能是相同的,但每個功能可以有不同的展現
屬於實作部分的擴增

如果在做程式設計,希望可以把實作與功能部分完全分離,
如範例中,Display屬於功能性父類別,DisplayImp屬於實作父類別
如果想要新增功能,就擴充在Display的子類別內
如果想要改變輸出型態,如輸出文字變輸出html,
則新增DisplayImp的子類別

Bridge Pattern就是在功能類別(Display)內放一個變數(impl)存放實作類別(DisplayImp)的實體
讓功能類別(Display)內的method都是在操作實作類別(DisplayImp)的功能
把分離的實作擴充與功能擴充部分串起來,就是Bridge Pattern
參與者
1.Display(功能父類別)
在Display功能父類別內,利用一個變數impl儲存實作類別的instance
所有在功能類別內的操作,內部真正都執行的都是impl在執行

public class Display {
    private DisplayImp impl;
    public Display(DisplayImp impl){
        this.impl=impl;
    }
    public void open(){
        impl.rawOpen();
    }
} 

2.abstract DisplayImp(實作的父類別)
實作父類別,定義了所要實作類別所需要的method名稱,再交由子類別去實作出來

public abstract class DisplayImp {
    public abstract void rawOpen();
    public abstract void rawPrint();
    public abstract void rawClose();
}

3.CountDisplay(擴充了功能父類別Display)
要新增加功能,就加在這功能擴充的子類別上

public class CountDisplay extends Display {
    public CountDisplay(DisplayImp impl){
        super(impl);
    }
    public void multiOutPut(int num){
    this.open();
    this.print();
    this.print();
    this.close();
    }
}

4.StringDisplayImp(真正實作可以執行的實作類別)

public class StringDisplayImp extends DisplayImp {
    private String string;
    public StringDisplayImp(String string){
        this.string=string;
    }
    public void rawOpen(){
        System.out.println("---Is Open-------");
    };
    .....
}

5.Main外部程式

Display d1=new Display(new StringDisplayImp("OZ D1"));
CountDisplay d2=new CountDisplay(new StringDisplayImp("OZ D2"));
d1.output();
d2.output();
d2.multiOutPut(3);//執行功能擴充後,新增的method



ps:
當以繼承方式產生子類別,子類別並不會繼承父類別的建構子
如果父類別建構子有接受參數執行項目
那在繼承後,子類別在建構子內,並須執行super(xx)

2010年3月12日 星期五

Design Pattern : 07 Builder


當我們想要建構出一個比較複雜的結果
或是想對相同內容提供不同的輸出樣式,就可以使用Builder Pattern

其流程是
1.先產生一個Builder類別,在Builder內
提供各種基本method
2.再產生一個組合程式用的Director類別
在Director內組合各式的builder 功能,來產生一個比較複雜的結果
外部程式只要操作Director就可以得到想要的結果
3.如果要讓同樣的內容可以產生不同格式的輸出
可以繼承Builder產生各式的Builder類別,來產生不同形式的輸出樣式

參與者
1.Builder
抽象類別,規範了要提供給Director操作的的各項method


class abstract Builder{
    public abstract makeTitle(String _title);
    public abstract makeBody(String _body);
    public abstract makeLine();
    public abstract Object getResult();
}

2.TextBuilder
繼承自Builder,並把相關method都實作出來


class abstract TextBuilder extends Builder{
    private StringBuffer buffer=new StringBuffer()
    public makeTitle(String _title){
        buffer.append(_title)
    };
    public makeBody(String _body){..};
    public makeLine(){..};
    public Object getResult(){
        return buffer.toString();
    };
}

3.Director
實體類別,在內部操作並組合各種Builder的method產生所要的結果
在Director只操作Builder類別的method,不可操作builder的子類別專屬method


class Director{
    private Builder builder;
    public Director(Builder builder){
        this.builder=builder;
    }
    public void setData(String _title,String _body){
        builder.makeLine();
        builder.makeTitle(_title);
        builder.makeBody(_body);
        builder.makeLine();
    }
    public void show(){
        System.out.println(builder.getResult().toString());
    }
}

4.Main外部程式


Director director=new Director(new TextBuilder());
director.setData("title","body");
director.show();

2010年3月10日 星期三

Design Pattern : 06 Prototype


通常我們產生一個instance 通常都會是利用new Class方式
來產生想要的instnace,但如果要產生的物件是一個比較麻煩的東西
譬如說,在畫布上隨手畫出的物件,想要產生多個instance,
這時候,就需要用clone的方式,針對既存的物件原形複製出來

把一個物件class當作原型,丟到manager內當作一個參考
當使用者需要一個instnace時,manager就依照這個原型
複製出一個相同物件出來,傳給需求單位

Prototype Patterng的結構是包含
1.一個Manager Class
2.一個Product 抽象類別:
定義了要在Manager內被呼叫的method
Product內包括了一個createClone()的method
可以對自身複製出一個instance傳出去,至於實作部分就留給其繼承者實作出來即可
3.多個繼承自Product的class(在這範例是StringBox)

其運作流程為
1.利用Manager註冊Product
2.利用Manager產生Product instance
3.操作Product instance
參與者
1.Manager
本身為標準class,非abstract
但裡面method呼叫的是以抽象類別(Product)所訂的method來執行
在這裡面包含了產生product instance的運算邏輯


public class Manager {
    private Hashtable table=new Hashtable();
    public void register(String name,Product p){
        table.put(name,p); 
    }
    public Product create(String protoname){
    Product p=(Product)table.get(protoname);
        return p.createClone();
    }
}


先使用register把Product與設定要產生這product的字串註冊到這manager內
以後就可以利用註冊的字串用create來取得該product 的instance

2.Product(framework)
規範了在Managaer內會被呼叫的method名稱
public abstract class Product implements Cloneable {
public abstract Product createClone();
public abstract void show(String s);
}
在Java內,Product一定要先implements Cloneable


createClone()就是clone自己產生instance的地方,這部分留給繼承者實作
3.StringBox
public class StringBox extends Product {
    public Product createClone(){
        Product p=null;
        try{
            p=(Product)clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        return p;
    }
}


4.Main(外部應用程式)


Manager manager=new Manager();//產生manager
manager.register("my-",(Product)new StringBox('-'));//註冊product到manager上
Product p=manager.create("my-");//利用manager產生product instance
p.show("hello world");//操作product

2010年3月9日 星期二

Design Pattern : 05 Singleton


當在整個程式裡,我們對於某個clas
只需要存在一個instance時,例如整個程式的設定檔
整個通用的css class,這時可使用Singleton Pattern達到這個目的
參與者
1.Singleton
只能透過 class的 static method getInstance來取得instance
不能在外部使用new 來產生instance,所以將建構子設定為private


public class Singleton{
    private static Singleton _singleton=new Singleton('myid')
    private String myid;//這是instance的var
    private static String myVer="Sample";//這是static var
    private Singleton(String myid){
        this.myid=myid;
        showID();
    }
    private void showID(){
        System.out.println(this.myid)
    }
    public static Singleton getInstance(){
        System.out.println(myVer);
        return _singleton();
    }
}

2.Main 外部主程式


Singleton.getInstance();


PS:在static method內,只能夠呼叫使用staic variable或method
建構子是屬於instance method,可以呼叫使用static或instance method
在使用Vector來儲存物件,記得要宣告內存的類型
Vector myv=new Vector();

2010年3月8日 星期一

Design Pattern : 04 Factory

要建立一個可以用來產生product 的factory class
想要做到,不管什麼product都可以套用相同的產生流程
也就是說一個factory可以用來產生不同的product
這時候就可以用Factory Pattern

定義好抽象的Factory類別與Product類別當框架Framework
在Factory定義實體method產生Product物件
在外部程式要利用Factory產生Product

都是利用上層Framework設定好抽象的factory與product
所提供的public method

但真正內部運作的是分別繼承自factory與product的realFactory
與realProduct

如果要產生不同的product,就可以分別產生不同的realFactory與
realProduct
在不變動外部Main程式狀況下 即可直接使用
參與者
1.Factory (屬framwork)
在Factory class內是用到了Templete Pattern,
提供外部呼叫使用的public method(create),是一個實體的method
而在這public method內呼叫執行的是一些抽象method
這些method就必須要被繼承的子類別實作出來


public abstract classFactory{
    public Product create(){
        Product p =createProduct();
        registProduct(p);
        return p;
    }
    protected abstract Product createProduct();
    protected abstract void registProduct(Product p);
}

2.RealFactory (instance)
繼承自Factory後,把factory內定一的抽象method都實作出來

public class RealFactory extends Factory{
    protected Product createProduct(){
        return RealProduct();  
    };
    protected abstract void registProduct(Product p){
        .....
    };
}

3.Product (屬framework)
只定義public 抽象method,來規範外界要操作使用product的方法

public abstract class Product{
    public abstract void use();
}

4.RealProcuct(instance)
真正的產品class,繼承自Product,並把Product內定義的
抽象method 實作

public class RealProduct{
    public void use(){
        .....
    }
}

5.Main(外部主程式)
產生一個實體的Factory,雖然是new RealFactory()
但類別宣告,還是宣告在其上層的Factory
利用產生的factory來產生product
真正產生的是realProduct物件
但類別還是宣告在其上層的Product class


Factory factory=new RealFactory();
Product product=factory.creat()
product.use();



ps:在Product的子類別,不提供public的建構子,目的是在於
強制規範product只能經由factory去產生,而不能自行使用
new product()產生出來

2010年3月5日 星期五

Design Pattern : 03 Template


在父類別定義好大綱(也就是運算邏輯),
子類別只要實作method 就可以讓多個class共用相同的運算邏輯
參與者
1.Template 父類別
Template必須為abstract class,不能用interface宣告
因為在template內,負責主要邏輯運算的method 必須要是一個
final method



public abstract class Template{
    public abstract void open();
    public final void display(){
        open();
        open();
        open();
    }
}

sample裡的display method包含了運算邏輯,是一個實體的method,但
在裡面呼叫執行的是抽象 method,這部分的method一定要在子類別內被實做
2.MyDisplay 子類別
子類別繼承Template,並把abstract 部分實作出來



public class MyDisplay{
    public void open(){
        .....
    }
}  

3.Main主程式



Template a=new MyDisplay();
a.display();

主程式執行時,會用到的是包含運算邏輯的method

Abstract class與Interface的差別
1.只要class內有method宣告為abstract,則class就必須宣告為abstract
Interface內所有的method都必須是abstract
也就是說在abstract class內,還可包含有非abstract的method
如果是extend abstract method ,只要 實作abstract method即可
對於非abstract method可直接使用,若要改寫則要override


2.只要是abstract class就不能被直接new 出instance


3.Class一次只可以繼承(extends )一個父class
但可以實作(implement)多個class
亦可同時extends 與implement

2010年3月4日 星期四

Design Pattern : 02 Adapter


當在開發Class時,在功能上可以利用舊的Class功能
這時候這個新的Class,就可以用Adapter方式去包裝
也就是說
在Adapter內定義新的method,但method內實際是在執行舊Class的method
使用者只知道他呼叫的是Adapter的method,不需知道其內部是如何運作
Adapter的做法,分別可以用繼承或委讓方式來實做
參與者
1.Old Class
原有已經開發好的Class
譬如 原本已有一個print() method
2.Adapter1
使用繼承方式來包裝Old Clas所產生新的Class


class Adapter1 extend Old{
    function Adapter1(){}
    function show(){print()}
}

3.Adapter2
在Class內包含了一個Old Class的instnace,用委讓的方式
來執行真正要做的事


class Adapter2{
    var old:Old
    function Adapter2(){
        old=new Old();
    }
    function show(){
        old.print()
    }
}

4.Main
主要應用程式


//var adapter:Adapter1=new Adapter1('hello');
var adapter:Adapter2=new Adapter2('hello');
adapter.show();