BlogJava-andy's blog-文章分类-设计模式

Singleton

zhoumin — Thu, 30 Mar 2006 09:15:00 GMT

一：
某些情况下一个类只能有一个实例，如thread pool,caches,objects that handle preferences and registry settings,objects used for logging,对这些情况下如果产生多于一个的实例会导致不正常的行为和浪费资源。

public class Singleton {
    private volatile static Singleton singleton;

    // 设为private，外界不能通过new的方法来获得一个实例。
    private Singleton() {
    }

    // synchronized如果加在方法定义处，开销相对较大
    public static Singleton getInstance() {
        if (singleton == null) {
            //必须处理多线程带来的问题，如果thread1执行到上一步，同时thread2也执行到上一步，
            //都判断出singleton==null 就会得到两个实例。
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    public void display() {
        System.out.println("singleton");
    }
}

zhoumin 2006-03-30 17:15 发表评论

Iterator

zhoumin — Thu, 30 Mar 2006 08:33:00 GMT

一：
聚集的方式有多种(Vector,ArrayList,Queue,HashSet,Array)等，对存取删对象的方式各不相同，为了统一接口，使用Iterator模式，客户端和具体Collection中间增加一层Iterator。

public class ArrayIterator implements Iterator {
     private Object[] arr;
     private int index = 0 ;
     public ArrayIterator(Object[] arr) {
         this .arr = arr;
    }
     public boolean hasNext() {

         return index < arr.length ? true : false ;
    }
     public Object next() {

         return arr[index ++ ];
    }
}

这样数组也有了Iterator接口，客户端不用管是用数组存的对象还是List，都用Iterator的方法统一处理。

The Iterator Pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

zhoumin 2006-03-30 16:33 发表评论

Template

zhoumin — Thu, 30 Mar 2006 07:56:00 GMT

一：
准备饮料的方法：

public class Coffee(){
public void prepareRecipe(){
  boilWater();
  brewCoffeeGrinds();
  pourInCup();
  addSugarAndMilk();
}
  //..
}
public class Tea(){
public void prepareRecipe(){
  boilWater();
  steepTeaBag();
  pourInCup();
  addLemon();
  //..

}
}

可以发现，这两个类中prepareRecipe()方法，部分代码是一样的，所以把这个方法提到基类中，其中boilWater()和pourInCup()方法所有子类都是一样的，可以在基类实现，其它两个方法为abstract，又具体子类来实现。

The Template Pattern defines the skeleton of an alogrithm in a method,deffering some steps to subclass.
Template Pattern lets subclass redefine certain steps of an alogrithm without changing the alogrithm's structure.

zhoumin 2006-03-30 15:56 发表评论

Proxy

zhoumin — Thu, 30 Mar 2006 07:34:00 GMT

一：
     某些情况下客户不想或不能直接引用一个对象，而代理对象可以在客户端和目标对象之间起中介作用
    1：远程(remote)代理：访问不同在一个JVM的类的方法。
    2：虚拟(virtual)代理：根据需要创建一个资源消耗较大的对象，使得此对象只在真正需要时才创建
                                        (如加载图片)
    3：智能引用(smart reference)代理：当一个对象被引用时，提供一些额外的操作，比如将此对象调用的
                                                               次数记录下来。
    4：保护(protection)代理：控制一个对象的访问（权限控制）。

// 查询代理类
public class SearcherProxy implements Searcher {
     private Searcher searcher;
     public SearcherProxy()
     {
        searcher = new RealSearcher(); // 真正的查询类
    }
     public String doSearch(String userId, String searchType) {
         if (checkAccess(userId))
         {
            String result = searcher.doSearch( null ,searchType);
            logUsage(userId);
             return result;
        }
         else return null ;
    }
     // 检查权限
     private boolean checkAccess(String userId)
     {
        AccessValidater validater = new AccessValidater();
         return validater.validateUser(userId);
    }
     // 记录使用情况
     private void logUsage(String userId)
     {
        UserLogger logger = new UserLogger();
        logger.setUserId(userId);
        logger.save();
    }
}

// 客户端使用
     public static void main(String[] args)
     {
        Searcher searcher = new SearcherProxy();
        System.out.println(searcher.doSearch( " admin " , " haha " ));
    }

zhoumin 2006-03-30 15:34 发表评论

Facade

zhoumin — Thu, 30 Mar 2006 03:56:00 GMT

一：
一个看dvd的例子：通常做法：先调节灯光，调节屏幕，调节投影仪，调节功放，然后才是开DVD.

light.dim(10);

screen.down();

projector.on();
projector.setInput(dvd);

amp.on();
amp.setVolume(5);

dvd.on();
dvd.playMovie();

这其实是一个比较普通的完整需求，这确涉及到五六个类，如果直接给这样的接口给client，十分不方便，我们应该根据需求，把细节包装起来，直接提供一个showMovie（包装以上实现）的方法给客户端。

The Facade Pattern provides a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.

when:
1.为一个复杂子系统提供一个简单接口
（1:用一个方法包装不同类的多个方法。2:把一个逻辑模块类接口集中到一个类）
2.子系统的独立性，将一个子系统与它的客户端以及其它子系统分开，可提高子系统的独立性和可移植性
3. 层次化结构，简化层与层直接的依赖关系。

zhoumin 2006-03-30 11:56 发表评论

Adapter

zhoumin — Thu, 30 Mar 2006 03:29:00 GMT

一：
现实生活例子：插座是三相的如果电器插头是两相的，那么需要一个adapter把三相的插座转成两相。

//Enumeration到Iterator的Adapter
public class EnumerationIterator implements Iterator {
    private Enumeration enumeration;
    public EnumerationIterator(Enumeration enumeration)
    {
        this.enumeration=enumeration;
    }
    public boolean hasNext() {
        return enumeration.hasMoreElements();
    }

    public Object next() {
        return enumeration.nextElement();
    }
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

    /**
     * 客户端代码
     */
    public static void main(String[] args) {
        Vector vect=new Vector();
        vect.add("v1");
        vect.add("v2");
        display(new EnumerationIterator(vect.elements()));
        List list1=new ArrayList();
        list1.add("L1");
        list1.add("L2");
        display(list1.iterator());
    }
    public static void display(Iterator iter)
    {
        while (iter.hasNext())
        {
            System.out.println(iter.next());
        }
    }

     The Adapter Pattern converts the interface of a class into another interface the client expect.Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.
   和Decorator模式不同，decorator对类包装后是增加它的功能，而Adapter是改变接口形式以适用client需要

   应用实例：WINE在Linux环境下运行Windows程序。
                       JDBC/ODBC桥。

zhoumin 2006-03-30 11:29 发表评论

Factory

zhoumin — Tue, 28 Mar 2006 08:28:00 GMT

一：case context:
一个Pizza管理系统

public Pizza orderPizza(String type) {
         Pizza pizza;
          if (type.equals( " cheese " )) pizza = new CheesePizza();
          else if (type.euals( " veggie " )) pizza = new VeggiePizza();
         pizza.bake();
         pizza.box();
          return pizza();
      }

问题：红色字体部分可能会modification(增加新的或删除旧的)，所以必须把这部分包装起来成一个独立的类。

二：SimpleFactory模式

   public class SimplePizzaFactory {
        pubic Pizza createPizza(String type) {
              Pizza pizza;
               if (type.equals( " cheese " )) pizza = new CheesePizza();
               else if (type.euals( " veggie " )) pizza = new VeggiePizza();
               return pizza;
         }
    }

    优点：因为是一个独立的类，所以可以共享，一处修改即可，不需修改客户端。
    缺点：对"close-opening"原则支持不够，如有新产品加入还是要改Factory中的代码。
    实例：DateFormat类：

Date date = DateFormat.getDateInstance(DateFormat.DEFAULT,Locale.FRENCH);

三：Factory Method模式
        当构建对象部分需求发生变化，如现在pizza分为美国和意大利两种口味。
        解决办法：1:一个抽象创建基类，abstract Product create();
                            2:具体类来实现create方法
                            3:抽象产品基类。
                            4:具体产品类。

// 具体工厂实现
public class UsPizzaFactory extends PizzaFactory {
   public Pizza createPizza(String type) {
     Pizza pizza;
      if (type.equals( " cheese " )) pizza = new UsCheesePizza();
      else if (type.equals( " veggie " )) pizza = new UsVeggiePizza();
      return pizza;
  }
}

The Factory Method Pattern defines an interface for creation an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.

四：Abstract Factory
     抽象工厂模式和工厂方法模式的主要区别是，工厂方法模式针对的是一个产品等级结构，而抽象工厂方法对应多个产品等级结构。

实例：创建分属不同操作系统的视窗构件。

zhoumin 2006-03-28 16:28 发表评论

Decorator

zhoumin — Tue, 28 Mar 2006 00:26:00 GMT

一：case context：咖啡店产品管理系统
        饮料基类abstract Beverage{cost();}, 两种饮料子类HouseBlend，Decaf都实现了cost()方法。每种饮料有自己的价钱，如果加牛奶糖等condiments按份算钱。

二：目前实现：
      基类增加milk，sweet等属性，增加hasMilk，hasSweet等方法，cost()实现时根据hasMilk()等判断计算。
      问题：1：condiments价格变化必须改变已有代码。
                  2：增加新的condiments必须修改基类。
                  3：把所有condiments都作为基类的属性不合适，因为不是每个子类必须的，比如某些可能不适合Tea等饮料。
                  4：如果顾客需要多份condiments没办法计算。

三：
     Design principal(open-close principal): Classes should be open for extension,but close for modification.
     The Decorator pattern :attaches additional responsibilities to a object dynamically.Decorator provide a flexible alternative to subclassing for extending functionality.
      现实方法：
      public abstract CondimentDecorator extends Beverage{}

     public Mocha extends CondifmentDecorator{
         private Beverage beverage;
         public Mocha(Beverage beverage){
             this.beverage=beverage;
         }
        public float cost(){
           return beverage.cost()+0.9;
        }
       public String getDescription(){
          reuturn beverage.getDescription+" Mocha";
       }
    }
   //--client test
    Beverage beverage=new HouseBlend();
    beverage=new Mocha(beverage);
    beverage=new Mocha(beverage);
    beverage=new Milk(beverage);
    System.out.println(beverage.getDescription()+beverage.cost());
     说明：
    1:decorators继承被包装的类的基类，不是为了代码重用，而是为了有一个相同的基类，这样包装一次之后其基类还是被包装类的基类，所以可以继续包装。
    2:decorator有一个被包装类属性，这样decorator在被包装类取得信息后在做处理。

四：when
     1:当需要扩展一个类的功能，或给一个类增加新的behavior；
     2:需要动态给一个对象增加功能，这些功能可以再动态的撤销。
     3:需要增加有一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变得不现实。

五：现实使用
     1:java I/O 类：abstract component－》InputStream，abstract decorator－》FilterInputStream,
                             decorator－》BufferInputStream，LineNumberInputStream
     2:文本过滤系统

zhoumin 2006-03-28 08:26 发表评论

Observer

zhoumin — Mon, 27 Mar 2006 11:17:00 GMT

一：case context：
     有一个气象信息类WeatherData，属性包括temperature，humidity等，现有两种显示WeatherData数据的类WeatherDataDisplay1和WeatherDataDisplay2，当WeatherData的信息改变时，这两个显示的类中的数据也改变，维护性方面，可能会有第三种显示方法，某个显示类可以申请不根据WeatherData数据实时改变。

二：
    目前现方法， WeatherData中
     public void measurementsChanged()
    {
         display1.update(getTemperature(),getHumidity());
         display2.update(getTemperature(),getHumidity());
    }
    但方法体中的代码是可能会变的，有display3的时候，必须得修改代码。
三：
     The Observer pattern：defines a one-to-many dependency between objects so that when one object changes state,
                                           all of its dependents are notified and updated automatically.

    此模式类包括: Subject 接口{registerObserver();removeObserver(),notifyObservers()}, Concrete Subject 类
                             Observer接口{update();}, 多个ConcreteObserver类(display1,display2)。
    public class WeatherData implements Subject
    {
           private List observerList;
           private float temperature;
           private float humidity;

          public void registerObserver(Observer observer)
          {
                 observerList.add(observer);
          }
          public void notifyObjects()
        {
           for (Iterator iter=objectList.iterator();iter.hasNext();)
         {
           Observer observer=(Observer)iter.next();
           observer.update();
          }
       }
        public void changeData(float newTemperature)
        {
              this.temperature=newTemperature;
              notifyObjects();
        }
    }
   //
    public class WeatherReport1 implements Observer{
      private WeatherData weatherData;
      public WeatherReport1(WeatherData weatherData)
    {
        this.weatherData=weatherData;
        weatherData.registerObject(this);
    }
    public void update()
    {
     System.out.println("report1--now temperature is:"+weatherData.getTemperature());
    }
}
//客户端测试代码
public class Tester {
public static void main(String[] args) {
  WeatherData weatherData=new WeatherData();
  WeatherReport1 weatherReport1=new WeatherReport1(weatherData);
  WeatherReport2 weatherReport2=new WeatherReport2(weatherData);
  weatherData.changeData(10);
  weatherData.removeObject(weatherReport1);
  weatherData.changeData(20);
}
}
四：java语言build-in支持
       在java.util.包中
     Subject接口-->Observable 类（把Observer注册，notify等方法实现）
     Observer接口-->Observer接口
     缺点：Observable是一个类你必须继承它，如果还要继承其它类就不行了。
     所以如果java内建的类不适合你，就按我们上面写的自己重头写一个。

五：实例
     1: swing中的事件处理：
          button.addActionListener(new AL1);
          button.addActionListerner(new AL2);
          public void AL1 implements ActionListener{
                  public void actionPerformed(Event e)
                  {//---
                  }
         }

      2:应用系统中，订阅信息：
         如有多个用户订阅的跟踪某记录更新信息。

zhoumin 2006-03-27 19:17 发表评论

Strategy

zhoumin — Mon, 27 Mar 2006 08:24:00 GMT

1:case context:
现设计一个关于鸭子的系统，一个抽象类Duck，方法为quack(),swim(),abstract display()(具体子   类实现)。现需求为有部分类型的鸭子可以fly(),如何实现。
   a:继承：把fly()提到Duck类中，可实现代码复用。
                 问题：违反继承原则，父类的方法必须是所有子类都具有的行为，代码维护时如加入一种新类型木头鸭就没有fly()行为。

b:接口：写一个flyable接口，所有有fly()行为的鸭子都实现这个接口。
                问题：不能实现代码复用。

2: 重新分析：
    fly()行为不是每个子类都有，fly()的具体实现可能会变化（有的是用翅膀飞行，有的是滑行，或是其它没有发现的方法，总之它是会变的（change，add））。
    Design Principal：Identify the aspects of your application that vary and seperate them from what stays the same。
    （take the parts that vary and encapsulate them,so that later you can alter and extend the parts that vary without affecting those don't ）
   解决方法：
          写FlyBehavior接口，和两个实现类FlyWithWings和FlyNoWay，这样把Fly的行为从duck类的内部提了出来，我们可以修改和增加行为而不影响其它代码。
          把FlyBehavior实例作为Duck的属性，子类构造时可以通过new FlyBehavior的实现类设置此属性，（因为FlyBehavior是接口，我们可以在Runtime 改变它），然后在Duck写performFly()实现方法为代理flyBehavior.fly()。
    Design Principal：Favor composition than inheirtance.
    (1:change behavior at runtime.2:encapsulate a family of algorithms into their own classes)

   Strategy pattern: define a family of algorithms,encapsulates each one,and make them interchangeable. Strategy lets the algorithm vary independently from the client that use it.

3:现实应用：
   图书打折计算：有多种打折策略，折扣可能会变动或增加。
   排序系统：先写出各种排序实现，根据情况动态选择排序策略。

zhoumin 2006-03-27 16:24 发表评论

设计模式介绍

zhoumin — Sun, 26 Mar 2006 15:51:00 GMT

what（define）？设计模式是对重复出现的类似问题的经典解决方法。
why?经典优雅解决方式，不需自己再去走弯路。
when？先要熟悉基本的模式，熟练时就知道什么时候该用，什么时候不该用。
where?软件开发（面向对象语言），特别是底层系统框架开发。
how（to study it）？
                         学习case
                              1:需求（功能，可维护性，可扩展性）
                              2:解决方法
                        实际应用：生活例子，java类库，java系统

参考资料：《head first design pattern》
                     《java 与模式》
                      jive 研究

zhoumin 2006-03-26 23:51 发表评论