内射干少妇亚洲69XXX,亚洲AV日韩AV一区二区三曲,亚洲av综合av一区

Singleton

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

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

public class Singleton {
    private volatile static Singleton singleton;

    // 设�ؓ(f��)private�Q�外界不能通过new的方法来获得一个实例�?/span>
    private Singleton() {
    }

    // synchronized如果加在�Ҏ(gu��)��定义处，开销相对较大
    public static Singleton getInstance() {
        if (singleton == null) {
            //必须处理多线�E�带来的问题�Q�如果thread1执行��C��一步，同时thread2也执行到上一步，
            //都判断出singleton==null ��׃��(x��)得到两个实例�?/span>
            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

一�Q?br /> 聚集的方式有多种(Vector,ArrayList,Queue,HashSet,Array)�{�，对存取删对象的方式各不相同，��Z��(ji��n)�l�一接口�Q��用Iterator模式�Q�客��L(f��ng)��和具体Collection中间增加一层Iterator�?/p>

public class ArrayIterator implements I(y��ng)terator {
     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 ++ ];
    }
}

�q�样数组也有�?ji��n)Iterator接口�Q�客��L(f��ng)��不用��是用数�l�存的对象还是List�Q�都用Iterator的方法统一处理�?br />
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

一�Q?br /> 准备饮料的方法：(x��)

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

}
}

可以发现�Q�这两个�c�M��prepareRecipe()�Ҏ(gu��)��Q�部分代码是一��L(f��ng)��Q�所以把�q�个�Ҏ(gu��)��提到基类中，其中boilWater()和pourInCup()�Ҏ(gu��)��所有子�c�都是一��L(f��ng)��Q�可以在基类实现�Q�其它两个方法�ؓ(f��)abstract�Q�又具体子类来实现�?br />
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

一�Q?br />     某些情况下客户不��x��不能直接引用一个对象，而代理对象可以在客户端和目标对象之间起中介作�?br />    1�Q�远�E?remote)代理�Q�访问不同在一个JVM的类的方法�?br />    2�Q�虚�?virtual)代理�Q�根据需要创��Z��个资源消耗较大的对象�Q��得此对象只在真正需要时才创�?br />                                        (如加载图�?
    3�Q�智能引�?smart reference)代理�Q�当一个对象被引用�Ӟ��提供一些额外的操作�Q�比如将此对象调用的
                                                               �ơ数记录下来�?br />    4�Q�保�?protection)代理�Q�控制一个对象的讉K��Q�权限控�Ӟ��(j��)�?br />

// 查询代理�c?/span>
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 ;
    }
     // ��(g��)查权�?/span>
     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();
    }
}

// 客户端��?/span>
     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

一�Q?br /> 一个看dvd的例子：(x��)通常做法�Q�先调节灯光�Q�调节屏�q�，调节投媄(ji��ng)仪，调节功放�Q�然后才是开DVD.

light.dim(10);

screen.down();

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

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

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

�q�其实是一个比较普通的完整需求，�q�确涉及(qi��ng)��C��六个�c�，如果直接�l�这��L(f��ng)��接口�l�client�Q�十分不方便�Q�我们应该根据需求，把细节包装�v来，直接提供一个showMovie�Q�包装以上实玎ͼ�(j��)的方法给客户端�?br />
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.��Z��个复杂子�pȝ��提供一个简单接�?br /> �Q?:用一个方法包装不同类的多个方法�?:把一个逻辑模块�c�L��口集中到一个类�Q?br /> 2.子系�l�的独立性，��一个子�pȝ��与它的客��L(f��ng)��以及(qi��ng)其它子系�l�分开�Q�可提高子系�l�的独立性和可移植�?br /> 3. 层次化结构，��化层与层直接的依赖关�p�R�?img src ="http://www.tkk7.com/zhoumin007/aggbug/38221.html" width = "1" height = "1" />

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

Adapter

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

一�Q?br /> 现实生活例子�Q�插座是三相的如果电(sh��)器插头是两相的，那么需要一个adapter把三相的插��转成两相�?br />

//Enumeration到Iterator的Adapter
public class EnumerationIterator implements I(y��ng)terator {
    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();
    }
}

    /**
     * 客户端代�?br />     */
    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模式不同�Q�decorator对类包装后是增加它的功能�Q�而Adapter是改变接口�Ş式以适用client需�?br />
   应用实例�Q�WINE在Linux环境下运行W(xu��)indows�E�序�?br />                       JDBC/ODBC桥�?img src ="http://www.tkk7.com/zhoumin007/aggbug/38216.html" width = "1" height = "1" />

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

Factory

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

一�Q�case context:
一个Pizza��理�pȝ��

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();
      }

问题�Q�红色字体部分可能会(x��)modification(增加新的或删除旧�?�Q�所以必��L��q�部分包装�v来成一个独立的�c�R�?br />
二：(x��)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;
         }
    }

优点�Q�因为是一个独立的�c�，所以可以共享，一处修改即可，不需修改客户端�?br /> �~�点�Q�对"close-opening"原则支持不够�Q�如有新产品加入�q�是要改Factory中的代码�?br /> 实例�Q�DateFormat�c�：(x��)

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

三：(x��)Factory Method模式
        当构建对象部分需求发生变化，如现在pizza分�ؓ(f��)��国和意大利两种口味�?br />        解决办法�Q?:一个抽象创建基�c�，abstract Product create();
                            2:具体�c�L��实现create�Ҏ(gu��)��
                            3:抽象产品基类�?br />                            4:具体产品�c�R�?br />

// 具体工厂实现
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.

四：(x��)Abstract Factory
抽象工厂模式和工厂方法模式的主要区别是，工厂�Ҏ(gu��)��模式针对的是一个��品等�U�结构，而抽象工厂方法对应多个��品等�U�结构�?br />
实例�Q�创建分属不同操作系�l�的视窗构�g�?br />

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

Decorator

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

一�Q�case context�Q�咖啡店产品��理�pȝ��
        饮料基类abstract Beverage{cost();}, 两种饮料子类HouseBlend�Q�Decaf都实��C��(ji��n)cost()�Ҏ(gu��)��。每�U�饮料有自己的�h(hu��n)钱，如果加牛奶糖�{�condiments按䆾��钱�?br />
二：(x��)目前实现�Q?br />      基类增加milk�Q�sweet�{�属性，增加hasMilk�Q�hasSweet�{�方法，cost()实现时根据hasMilk()�{�判断计��?br />      问题�Q?�Q�condiments��h��变化必须改变已有代码�?br />                  2�Q�增加新的condiments必须修改基类�?br />                  3�Q�把所有condiments都作为基�cȝ��属性不合适，因�ؓ(f��)不是每个子类必须的，比如某些可能不适合Tea�{�饮料�?br />                  4�Q�如果顾客需要多份condiments没办法计��?br />
三：(x��)
     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.
      现实�Ҏ(gu��)��Q?br />      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());
     说明�Q?br />    1:decorators�l�承被包装的�cȝ��基类�Q�不是�ؓ(f��)�?ji��n)代码重用，而是��Z��(ji��n)有一个相同的基类�Q�这样包装一�ơ之后其基类�q�是被包装类的基�c�，所以可以��l�包装�?br />    2:decorator有一个被包装�c�d��性，�q�样decorator在被包装�c�d��得信息后在做处理�?br />
四：(x��)when
     1:当需要扩展一个类的功能，或给一个类增加新的behavior�Q?br />     2:需要动态给一个对象增加功能，�q�些功能可以再动态的撤销�?br />     3:需要增加有一些基本功能的排列�l�合而��生的非常大量的功能，从而�ɾl�承关系变得不现实�?br />
五：(x��)现实使用
     1:java I/O �c�：(x��)abstract component�Q�》InputStream�Q�abstract decorator�Q�》FilterInputStream,
                             decorator�Q�》BufferInputStream�Q�LineNumberInputStream
     2:文本�q��o(h��)�pȝ��

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

Observer

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

一�Q�case context�Q?br />     有一个气象信息类WeatherData�Q�属性包括temperature�Q�humidity�{�，现有两种昄��WeatherData数据的类WeatherDataDisplay1和W(xu��)eatherDataDisplay2�Q�当WeatherData的信息改变时�Q�这两个昄��的类中的数据也改变，�l�护性方面，可能�?x��)有�W�三�U�显�C�方法，某个昄��c�d��以申请不�Ҏ(gu��)��WeatherData数据实时改变�?br />
二：(x��)
    目前现方法， WeatherData�?
     public void measurementsChanged()
    {
         display1.update(getTemperature(),getHumidity());
         display2.update(getTemperature(),getHumidity());
    }
    但方法体中的代码是可能会(x��)变的�Q�有display3的时候，必须得修改代码�?br />三：(x��)
     The Observer pattern�Q�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 �c?br />                             Observer接口{update();}, 多个ConcreteObserver�c?display1,display2)�?br />    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());
    }
}
//客户端测试代�?br /> 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);
}
}
四：(x��)java语言build-in支持
       在java.util.包中
     Subject接口-->Observable �c�（把Observer注册�Q�notify�{�方法实玎ͼ�(j��)
     Observer接口-->Observer接口
     �~�点�Q�Observable是一个类你必��ȝ��承它�Q�如果还要��承其它类��׃��行了(ji��n)�?br />     所以如果java内徏的类不适合你，��按我们上面写的自己重头写一个�?br />
五：(x��)实例
     1: swing中的事�g处理�Q?br />          button.addActionListener(new AL1);
          button.addActionListerner(new AL2);
          public void AL1 implements ActionListener{
                  public void actionPerformed(Event e)
                  {//---
                  }
         }

      2:应用�pȝ��中，订阅信息�Q?br />         如有多个用户订阅的跟�t�某记录更新信息�?/p>

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

Strategy

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

1:case context:
现设计一个关于鸭子的�pȝ��Q�一个抽象类Duck�Q�方法�ؓ(f��)quack(),swim(),abstract display()(具体子 �?�c�d��?。现需求�ؓ(f��)有部分类型的鸭子可以fly(),如何实现�?br />   a:�l�承�Q�把fly()提到Duck�c�M��Q�可实现代码复用�?br />                 问题�Q�违反��承原则，父类的方法必��L��所有子�c�都��h��的行为，代码�l�护时如加入一 �U�新�c?型木头鸭��没有fly()行�ؓ(f��)�?br />
b:接口�Q�写一个flyable接口�Q�所有有fly()行�ؓ(f��)的鸭子都实现�q�个接口�?br />                问题�Q�不能实��C��码复用�?br />
2: 重新分析�Q?br />    fly()行�ؓ(f��)不是每个子类都有�Q�fly()的具体实现可能会(x��)变化�Q�有的是用翅膀飞行�Q�有的是滑行�Q?或是其它没有发现的方法，��M��它是�?x��)变的（change�Q�add�Q�）(j��)�?br />    Design Principal�Q�Identify the aspects of your application that vary and seperate them from what stays the same�?br />    �Q�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 �Q?br />   解决�Ҏ(gu��)��Q?br />          写FlyBehavior接口�Q�和两个实现�c�FlyWithWings和FlyNoWay�Q�这��h��Fly的行��Z��duck�cȝ��内部提了(ji��n)出来�Q�我们可以修改和增加行�ؓ(f��)而不影响其它代码�?br />          把FlyBehavior实例作�ؓ(f��)Duck的属性，子类构造时可以通过new FlyBehavior的实现类讄��此属性，�Q�因为FlyBehavior是接口，我们可以在Runtime 改变它）(j��)�Q�然后在Duck写performFly()实现�Ҏ(gu��)��Z��理flyBehavior.fly()�?br />    Design Principal�Q�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:现实应用�Q?br />   图书打折计算�Q�有多种打折�{�略�Q�折扣可能会(x��)变动或增加�?br />   排序�pȝ��Q�先写出各种排序实现�Q�根据情况动态选择排序�{�略。�?

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

设计模式介绍

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

what�Q�define�Q�？设计模式是对重复出现的类似问题的�l�典解决�Ҏ(gu��)��?br />why?�l�典优雅解决方式�Q�不需自己再去走弯路�?br />when�Q�先要熟�(zh��n)�基本的模式�Q�熟�l�时��q��道什么时候该用，什么时候不该用�?br />where?软�g开发（面向对象语言�Q�，特别是底层系�l�框架开发�?br />how�Q�to study it�Q�？
                         学习(f��n)case
                              1:需求（功能�Q�可�l�护性，可扩展性）(j��)
                              2:解决�Ҏ(gu��)��
                        实际应用�Q�生�z�M��子，java�c�d��Q�java�pȝ��

参考资料：(x��)《head first design pattern�?br />                     《java �?模式�?br />                      jive 研究

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