摘要: 设计模式之Proxy模式  阅读全文

posted @ 2007-12-06 13:19 flustar 阅读(3377) | 评论 (0)编辑 收藏

     摘要: 设计模式之state模式  阅读全文

posted @ 2007-12-05 16:35 flustar 阅读(1477) | 评论 (1)编辑 收藏

     摘要: 设计模式之Command模式  阅读全文

posted @ 2007-12-05 13:23 flustar 阅读(1250) | 评论 (0)编辑 收藏

     摘要: 设计模式之Iterator模式  阅读全文

posted @ 2007-12-04 23:52 flustar 阅读(3111) | 评论 (1)编辑 收藏

     摘要: 设计模式之Builder模式  阅读全文

posted @ 2007-12-03 21:39 flustar 阅读(1127) | 评论 (0)编辑 收藏

     摘要: 设计模式之Prototype模式  阅读全文

posted @ 2007-12-02 16:16 flustar 阅读(851) | 评论 (0)编辑 收藏

     摘要: 设计模式之Factory Method模式  阅读全文

posted @ 2007-11-29 17:41 flustar 阅读(1586) | 评论 (0)编辑 收藏

 《设计模式》一书对Singleton模式是这样描述的:
保证一个类只有一个实例,并提供一个访问它的全局访问点。
这个模式比较简单,下面给出一个例子:
public class Singleton {
  private static Singleton instance;
  private Singleton(){
  
  }
  public static Singleton getInstance(){
   if(instance==null)
    instance=new Singleton();
   return instance;
  }
}
这个程序在单线程下运行不会有问题,但是它不能运行在多线程的环境下,若想让运行在多线程的环境下,必须修改如下:
public class Singleton {
  private static class Instance{
   static final Singleton instance=new Singleton();
  }
  private Singleton(){
  
  }
  public static Singleton getInstance(){
   return Instance.instance;
  }
}
这样做之所以可以,是因为静态的内部类Instance只会被装载一次。运行在多线程下的单态设计模式也叫Double-Checked Looking模式。

posted @ 2007-11-28 20:39 flustar 阅读(627) | 评论 (1)编辑 收藏

 《设计模式》一书对Template Method模式是这样描述的:
 定义一个操作中算法的骨架,而将一些步骤延迟到子类中。不改变算法的结构而重新定义它的步骤。
 我的理解:定义一个抽象类或者说接口,在它的内部定义一些抽象的方法(供TemplateMethod调用的步骤)和一个TemplateMethod方法(非抽象方法),封装了这些抽象方法的接口或抽象类就是骨架。而将它的实现延迟到子类中,也就是用子类实现它。不改变算法的结构而重新定义它的步骤,也就是改写或者实现父类的这些非TemplateMethod的抽象方法。下面给出一个例子:
abstract class QueryTemplate{
 public void doQuery(){  //Template Method
  formatConnect();
  formatSelect();
 }
  protected abstract void formatConnect();
  protected abstract void formatSelect();
}
class OracleQT extends QueryTemplate{
 public void formatConnect() {
  System.out.println("格式化Qracle数据库连接");
 }
 public void formatSelect() {
  System.out.println("格式化Oracle数据库查询");
 }
}
class MysqlQT extends QueryTemplate{
 public void formatConnect() {
  System.out.println("格式化Mysql数据库连接");
 }
 public void formatSelect() {
  System.out.println("格式化Mysql数据库查询");
 }
}
public class client {
 public static void main(String[] args) {
  QueryTemplate oracleQT=new OracleQT();
  oracleQT.doQuery();
  
  QueryTemplate mysqlQT=new MysqlQT();
  mysqlQT.doQuery();
 }
}
输出结果:
格式化Qracle数据库连接
格式化Oracle数据库查询
格式化Mysql数据库连接
格式化Mysql数据库查询
在这个例子中,我们定义了一个骨架QueryTemplate,在它的内部定义了一个Template Method,和一些步骤(抽象方法),使用Template Method来调用这些步骤。步骤是在子类中实现的。
小结:有时候,会遇到由一系列步骤构成的过程需要执行。这个过程从高层次上看是相同的,但有些步骤的实现可能不同。正如,查询SQL数据库从高层次上看过程是相同的,但某些细节比如如何连接数据库则可能因平台等细节的不同而不同。通过Template Method模式,我们可以先定义步骤序列,然后覆盖那些需要改变的步骤。

 

posted @ 2007-11-28 20:36 flustar 阅读(908) | 评论 (0)编辑 收藏

 《设计模式》一书对Observer是这样描述的:
定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都将得到通知并自动更新。
举个例子,在现实生活中,父母与孩子是最亲密的人。父母做为孩子(被观察者)的监护人(观察者),当孩子和别人打架后,一定会告诉他的父母这件事(呵呵,当孩子很小时,通常会告诉父母,长大了以后,可能不会,这里的孩子指的是小孩子),当孩子获得奖学金后,也一定会告诉他的父母。下面我用Observer实现这个程序。代码如下:
import java.util.Vector;

class Children{
 static private Vector<Observer> obs;
 static private String state=null;
 static{
  obs=new Vector<Observer>();
 }
 public static void attach(Observer o){
  obs.addElement(o);
 }
 public static void detach(Observer o){
  obs.removeElement(o);
 }
 public void setState(String str){
  state=str;
 }
 public String getState(){
  return state;
 }
 public void notifyObs(){
  for(Observer o:obs){
   o.update(this); 
  }
 }
}
interface Observer{
 public void update(Children child);
}
class Parent implements Observer{
 public void update(Children child){
  if(child.getState().equals("fight")){
   System.out.println("Parent,他和别人打架了");
  }else if(child.getState().equals("scholarship")){
   System.out.println("告诉Parent,他得到了奖学金");
  }
 }
}
class Mother implements Observer{
 public void update(Children child){
  if(child.getState().equals("fight")){
   System.out.println("告诉Mother,他和别人打架了");
  }else if(child.getState().equals("scholarship")){
   System.out.println("告诉Mother,他得到了奖学金");
  }
 }
}
public class Client {

 public static void main(String[] args) {
  Children child=new Children();
  Observer parent=new Parent();
  Observer mother=new Mother();
  child.attach(parent);
  child.attach(mother);
  child.setState("fight");
  child.notifyObs();
  child.setState("scholarship");
  child.notifyObs();

 }

}

输出如下:
告诉Parent,他和别人打架了
告诉Mother,他和别人打架了
告诉Parent,他得到了奖学金
告诉Mother,他得到了奖学金
 小结:对于Observer模式,触发事件的对象-Subject对象无法预测可能需要知道该事件的所有对象。为了解决这一问题,我们创建一个Observer接口,要求所有的Observer负责将自己注册到Subject上。

posted @ 2007-11-28 20:34 flustar 阅读(563) | 评论 (0)编辑 收藏

仅列出标题
共6页: 上一页 1 2 3 4 5 6 下一页 

posts - 54, comments - 143, trackbacks - 0, articles - 0

Copyright © flustar