设计模式学习之（Head First Design Patterns）------装饰模式

saftyfirst — Mon, 18 Sep 2006 12:44:00 GMT

摘要: Decorator The Decorator pattern attaches additional responsibilities to an object dynamically . Decorator provide a flexible alternative to subclass for extending functionality . 装饰模式能进行... 阅读全文

saftyfirst 2006-09-18 20:44 发表评论

设计模式学习之（Head First Design Patterns）------观察者模式

saftyfirst — Tue, 12 Sep 2006 11:56:00 GMT

OBSERVER

      The Observer Pattern defines a one-to-many dependency between object so that when one object changes state ,all
of its dependents are notified and update automatically.
      观察者模式在对象间定义了一个一对多的关系，当一个对象（Subject 主题对象）发生改变时,所有依赖于该对象的对象都会被通知并且自动更新。

      The Observer Pattern provides an object design where subject and observer are loosely coupled:

         1> The only thing the subject knows about an observer is that it implement a certain interface.
         2> We can add new observer at any time.
         3> We never need to modify the subject to add new type of observers.
         4> Changes to either the subject or an observer will not affect other.
以下是测试代码
ProductObservable

/**
* @author Wangzg
* Time: 2006-9-12
* FileName: ProductObservable.java
* PackageName: src.observerPattern
* Description: Observable class
*/
package src.observerPattern;

import java.util.Observable;

public class ProductObservable extends Observable {
    private String name;

    private double weigh;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        setChanged();
        notifyObservers(name);
    }

    public double getWeigh() {
        return weigh;
    }

    public void setWeigh(double weigh) {
        this.weigh = weigh;
        setChanged();
        notifyObservers(new Double(weigh));
    }


}

ProductNameobserver

  /**
  * @author Wangzg
  * Time: 2006-9-12
  * FileName: ProductNameobserver.java
  * PackageName: src.observerPattern
  * Description: Observer class
  */
  package src.observerPattern;

import java.util.Observable;
import java.util.Observer;

public class ProductNameobserver implements Observer {
    private String name = null ;
    /*
     * @author Wangzg
     * Time: 2006-9-12
     * MethodsName:
     * variable in  :
     * variable out :
     * Description:
     */
    public void update(Observable o, Object arg) {
        // TODO Auto-generated method stub
        if ( arg instanceof String){
            name = (String)arg;
            System.out.println("name change to "+name);
        }
        System.out.println("ProductNameobserver nothing happen");
    }

}

ProductWeighObserver

/**
* @author Wangzg
* Time: 2006-9-12
* FileName: ProductWeighObserver.java
* PackageName: src.observerPattern
* Description: Observer class
*/
package src.observerPattern;

import java.util.Observable;
import java.util.Observer;

public class ProductWeighObserver implements Observer {
    private douDoubleble weigh = 0.0;

    /*
     * @author Wangzg Time: 2006-9-12 MethodsName: variable in : variable out :
     * Description:
     */
    public void update(Observable o, Object arg) {
        // TODO Auto-generated method stub
        if ( arg instanceof ProductObservable ){
            weigh = ((Double)arg).doubleValue();
            System.out.println("weigh change to "+weigh);
        }
        System.out.println("ProductWeighObserver nothing happen");
    }

}

saftyfirst 2006-09-12 19:56 发表评论

设计模式学习之（Head First Design Patterns）------策略模式

saftyfirst — Mon, 11 Sep 2006 12:33:00 GMT

STRATEGY

         define a family of algorithms , encapsulats each ones , and make them interchangeable . STRATEGY let the algorithm vary independently from client that use it .

         定义一系列算法并逐个封装为单独的类，并且使之能互相交换。策略模式能使这些各种各样的算法独立的被客户端调用。（呵呵   翻译的可能不标准）

           separating what changes from what stay the same .

           identify the aspects of your application taht vary ang separate them from what stay the same.

           Has-a can be better than Is-a.

saftyfirst 2006-09-11 20:33 发表评论

BlogJava-每个人都会死去，但不是每个人都曾经真正活过-文章分类-设计模式

设计模式学习之（Head First Design Patterns）------装饰模式

设计模式学习之（Head First Design Patterns）------观察者模式

设计模式学习之（Head First Design Patterns）------策略模式