实例

 1package com.sailor.adapter;
 2
 3
 4/** *//**
 5 * 被适配者
 6 * @author sailor
 7 * Jul 25, 2008 9:35:19 AM
 8 */
 9public class Duck {
10    
11    public Duck() {
12
13    }
14
15    public void fly(){
16        System.out.println("I can fly");
17    }
18    
19    public void quack(){
20        System.out.println("quake!");
21    }
22}
23

 1
 2package com.sailor.adapter;
 3
 4/** *//**
 5 * 目标接口
 6 * @author sailor
 7 * Jul 25, 2008 9:43:35 AM
 8 */
 9public interface Turkey {
10
11    public void gobble();
12    public void fly();
13}
14

 1
 2package com.sailor.adapter;
 3
 4/** *//**
 5 * 适配器
 6 * @author sailor
 7 * Jul 25, 2008 9:38:10 AM
 8 */
 9public class TurkeyAdapter implements Turkey{
10
11    private Duck duck;
12
13    public TurkeyAdapter(Duck duck) {
14        this.duck = duck;
15    }
16    
17    public void gobble(){
18        duck.quack();
19    }
20    
21    public void fly(){
22        duck.fly();
23    }
24    
25    
26}
27

 1
 2package com.sailor.adapter;
 3
 4/** *//**
 5 * 客户端
 6 * @author sailor
 7 * Jul 25, 2008 9:45:29 AM
 8 */
 9public class Client {
10
11    /** *//**
12     * @param args
13     */
14    public static void main(String[] args) {
15        
16        Duck duck = new Duck();
17        
18        Turkey turkey = new TurkeyAdapter(duck);
19        
20        turkey.gobble();
21        turkey.fly();
22    }
23
24}
25

    参考资料：《First Head 设计模式》

优点：

实例
抽象命令接口：

package command;
public interface Command{
    //执行方法
     void execute();
}

具体命令

package command;
public class ConcreteCommand implements Command{
    //接收者
    private Receiver receiver;
    //构造方法
    public ConcreteCommand(Receiver receiver){
        this.receiver=receiver;
    }
    //执行方法
    public void execute(){
        receiver.action();
    }
}

接收者：

package command;
public  class Receiver {
    //构造方法
    public Receiver(){};
    //行为方法
    public void action(){
        System.out.println("Action is taken here");
    }
}

请求者：

package command;
public class Invoker{
    //命令
    private Command command;
    //构造方法
    public Invoker(Command command){
        this.command=command;
    }
    //行为方法
    public void action(){
        command.execute();
    }
}

客户端：

package command;
public class Client{
    public static void main(String[] args){
        Receiver receiver=new Receiver();
        Command concreteCommand=new ConcreteCommand(receiver);
        Invoker invoker=new Invoker(concreteCommand);
        invoker.action();
    }
}

命令模式与责任链模式区别：
责任链模式使一个特定的请求接收对象对请求与命令的执行变得不确定性.而命令模式使得一个特定的对象对命令的执行变得明显与确定.

参考资料：《First Head 设计模式》
                        设计模式学习笔记(十五)--------命令(Command)模式

 1public class Singleton{
 2
 3 private static Singleton uniqueInstance;
 4
 5 private Singleton(){}  //私有构造器
 6
 7 public static Singleton getInstance(){
 8
 9  if(uniqueInstance == null){
10   
11   uniqueInstance = new Singleton();
12  }
13  
14  return uniqueSingleton
15 }
16}

    
    2、处理多线程
             这是保证可行的最直接做法，对于性能如果没有考虑，可以直接用这个方法。

 1public class Singleton{
 2
 3 private static Singleton uniqueInstance;
 4
 5 private Singleton(){}  //私有构造器
 6
 7 public static synchronized Singleton getInstance(){
 8
 9  if(uniqueInstance == null){
10   
11   uniqueInstance = new Singleton();
12  }
13  
14  return uniqueSingleton
15 }
16}

 1public class Singleton{
 2 
 3 private static uniqueInstance = new Singleton();
 4
 5 private Singleton(){}
 6
 7 public static Singleton getInstance(){
 8 
 9   return uniqueInstance;
10 }
11
12}

 1package com.sailor.singleton;
 2
 3/** *//**
 4 * @author sailor
 5 * Jul 23, 2008 9:46:17 AM
 6 */
 7public class Singleton {
 8    
 9    private volatile static Singleton uniqueInstance;
10    
11    private Singleton(){}
12    
13    public static Singleton getInstance(){
14        if(uniqueInstance == null){
15            synchronized(Singleton.class){
16                if(uniqueInstance == null){
17                    uniqueInstance = new Singleton();
18                }
19            }
20        }
21        return uniqueInstance;
22    }
23}

角色

图1. 抽象工厂模式的类图定义

　　从上图可以看出，简单工厂模式涉及到以下的角色

　　　抽象工厂(AbstractFactory)类或接口

　　　担任这个角色的是工厂方法模式的核心，它是与应用程序无关的。任何在模式中创立对象的工厂类必须实现这个接口，或继承这个类。

　　　实工厂类 (Conrete Factory)

　　　担任这个角色的是与应用程序紧密相关的，直接在应用程序调用下，创立产品实例的那样一些类。

　　　抽象产品 (Abstract Product)

　　　担任这个角色的类是工厂方法模式所创立的对象的父类，或它们共同拥有的接口。

　　　实产品 (Concrete Product)

　　　担任这个角色的类是工厂方法模式所创立的任何对象所属的类。

实例

二、简单工厂模式

        《Head First 设计模式》认为它不是一个设计模式，更像一种编程习惯，优点是可以将客户端程序从具体类中解耦，不失为一个简单的方法。

1、定义
    简单工厂模式是由一个工厂对象决定创建出那一种产品类的实例，它是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例。

2、角色
    简单工厂模式涉及到工厂角色、抽象角色以及具体产品角色等
    
    工厂类（Creator）角色：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象，它往往由一个具体的JAVA类实现。

    抽象产品（Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或他们共同拥有的接口。抽象产品角色可以用一个java接口或者Java抽象类实现。

    具体产品（Concrete Product）角色：工厂方法模式所创建的任何对象是这个角色的实例，具体产品角色由一个具体java类实现。

3、实例

 1package com.sailor.simpleFactory;
 2
 3public abstract class Product {
 4
 5    public void produce(){
 6        System.out.println("生产产品");
 7    }
 8    
 9    public abstract void category();
10
11    
12    public abstract int salePrice();
13    
14}
15

 1/** *//**
 2 * 
 3 */
 4package com.sailor.simpleFactory;
 5
 6/** *//**
 7 * 具体产品
 8 * @author sailor
 9 * Jul 22, 2008 10:15:14 AM
10 */
11public class Car extends Product{
12
13    @Override
14    public void category() {
15        System.out.println("生产小汽车");
16    }
17
18    @Override
19    public int salePrice() {
20        return new Integer(10000);
21    }
22
23}
24

 1package com.sailor.simpleFactory;
 2
 3/** *//**
 4 * 具体产品
 5 * @author sailor
 6 * Jul 22, 2008 10:17:12 AM
 7 */
 8public class Pizza extends Product{
 9
10    @Override
11    public void category() {
12        System.out.println("生产Pizza");
13    }
14
15    @Override
16    public int salePrice() {
17        return 20;
18    }
19
20}

 1/** *//**
 2 * 工厂
 3 * @author sailor
 4 * Jul 22, 2008 10:13:23 AM
 5 */
 6public class SimpleFactory {
 7
 8    public static Product createProduct(String product){
 9        if("car".equals(product))
10            return new Car();
11        else if("pizza".equals(product))
12            return new Pizza();
13        else
14            return null;
15    }
16}

 1package com.sailor.simpleFactory;
 2
 3/** *//**
 4 * 客户端
 5 * @author sailor
 6 * Jul 22, 2008 10:20:59 AM
 7 */
 8public class Client {
 9
10    /** *//**
11     * @param args
12     */
13    public static void main(String[] args) {
14        
15        Product product1 = SimpleFactory.createProduct("car");    
16        product1.category();
17        product1.produce();
18        System.out.println("销售额： " + product1.salePrice());
19        
20        
21        Product product2 = SimpleFactory.createProduct("pizza");
22        product2.category();
23        product2.produce();
24        System.out.println("销售额： " + product2.salePrice());    
25    }
26}

    抽象构件(Component):给出一个抽象接口，以规范准备接收附加责任的对象。
    具体构件(Concrete Component)：定义一个接收到附加责任的类。
    装饰（Decorator）:持有一个构件对象的实例，并定义与抽象构件一致的接口。
    具体装饰（Concrete Decorator）:负责给构件对象贴上附加的责任。

（图例）

package decorator;
//抽象构件接口
public interface Component{
    public void sampleOperation();
}

package decorator;
//具体构件-----门
public class  Door implements Component{
    //实现方法
    public void sampleOperation(){
        System.out.println("build a door");
    }
}

package decorator;

public abstract class Decorator implements Component{
    //持有一个构件对象的实例
    private Component component;
    //构造方法
    public Decorator(Component component){
        this.component=component;
    }
    //方法的具体实现
    public  void sampleOperation(){
        component.sampleOperation();
    }
}

package decorator;
//具体装饰----把手
public class Knob extends Decorator{

    public Knob(Component component){
        super(component);
    }
    
    public void sampleOperation(){
        super.sampleOperation();
        //附加的"责任"
        System.out.println("add a knob");
    }
}

package decorator;
//具体装饰----锁
public class Lock extends Decorator{

    public Lock(Component component){
        super(component);
    }
    public void sampleOperation(){
        super.sampleOperation();
        //附加"责任"
        System.out.println("add a lock");
    }
}

package decorator;

public class DecoratorPattern{
    public static void main(String[] args){
        Component door=new Door();
        Component lock=new Lock(door);
        Component knob=new Knob(lock);
        knob.sampleOperation();
    }
}

3、设计原则

    找出程序中会变化的方面，然后将其和固定不变的方面相分离
        在观察者模式中，会改变的是主题的状态，以及观察者的数目和类型。用这个模式，你可以依赖于主题状态的对象，却不必改变主题。这就叫提前规划。

    针对接口编程，不针对实现编程
        主题与观察者都使用接口：观察者利用主题的接口，向主题注册；而主题利用观察者的接口通知接口。这样可以让两者之间运作正常，又同事具有松耦合的优点。

    多用组合，少用继承
        观察者模式利用“组合”，将许多观察者组合进主题中。对象之间的这种关系不是通过继承产生的，而是在运行时利用组合的方式而产生的。
 
4、实现
   

l         需要使用ConcreteStrategy提供的算法。

l         内部维护一个Strategy的实例。

l         负责动态设置运行时Strategy具体的实现算法。

l         负责跟Strategy之间的交互和数据传递。

        Strategy(抽象策略类)：

l         定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，Context使用这个接口调用不同的算法，一般使用接口或抽象类实现。

        
        ConcreteStrategy(具体策略类)：

l         实现了Strategy定义的接口，提供具体的算法实现。