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

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

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

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

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

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

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

 《设计模式》一书对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模式。

 《设计模式》一书对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模式，我们可以先定义步骤序列，然后覆盖那些需要改变的步骤。

 

 《设计模式》一书对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上。