BlogJava-『一只小蚂蚁』的专栏-随笔分类-蚂蚁学模式http://www.blogjava.net/qixiangnj/category/14807.html<strong>生命不息，拼搏不止。</strong>zh-cnThu, 06 Sep 2007 07:22:38 GMTThu, 06 Sep 2007 07:22:38 GMT60『蚂蚁学模式』之实例化策略（Strategy）模式http://www.blogjava.net/qixiangnj/archive/2007/09/06/142749.htmlThomasThomasThu, 06 Sep 2007 00:42:00 GMThttp://www.blogjava.net/qixiangnj/archive/2007/09/06/142749.htmlhttp://www.blogjava.net/qixiangnj/comments/142749.htmlhttp://www.blogjava.net/qixiangnj/archive/2007/09/06/142749.html#Feedback0http://www.blogjava.net/qixiangnj/comments/commentRss/142749.htmlhttp://www.blogjava.net/qixiangnj/services/trackbacks/142749.html行为模式。
其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。

策略模式的结构：













应当由客户端自己决定在什么情况下使用什么具体策略模式。

策略模式不适合于处理同时嵌套多于一个算法的情形。

何时使用？
1. 一个系统需要动态地让一个对象在许多行为中选择一种行为。
2. 一个系统需要动态地在几种算法中选择一种。
3. 一个系统的算法使用的数据不可以让客户端知道。
4. 避免使用难以维护的多重条件选择语句。

优点：
1. 提供了管理相关的算法族的办法。
2. 提供了可以替换继承关系的办法。
3. 可以避免使用多重条件转移语句。

缺点：
1. 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
2. 策略模式造成很多的策略类。

与其他模式的关系：
建造（Builder）模式
适配器（Adapter）模式
享元（Flyweight）模式
模板（Template）模式
MVC模式
装饰（Decorator）模式

1. com.cleversoft.designpatterns.behavioral.strategy.Sorter.java:
package com.cleversoft.designpatterns.behavioral.strategy;

public class Sorter {
    public void sort() {
        sortStrategy.sort();
    }

    public void setSortStrategy(SortStrategy sort) {
        this.sortStrategy = sort;
    }

    private SortStrategy sortStrategy;
}

2. com.cleversoft.designpatterns.behavioral.strategy.SortStrategy.java:
package com.cleversoft.designpatterns.behavioral.strategy;

public abstract class SortStrategy {
    public abstract void sort();
}

3. com.cleversoft.designpatterns.behavioral.strategy.RadixSort.java:
package com.cleversoft.designpatterns.behavioral.strategy;

public class RadixSort extends SortStrategy {
    public void sort() {
        System.out.println("Radix Sort!");
    }
}

4. com.cleversoft.designpatterns.behavioral.strategy.QuickSort.java:
package com.cleversoft.designpatterns.behavioral.strategy;

public class QuickSort extends SortStrategy {
    public void sort() {
        System.out.println("Quick Sort!");
    }
}

5. com.cleversoft.designpatterns.behavioral.strategy.HeapSort.java:
package com.cleversoft.designpatterns.behavioral.strategy;

public class HeapSort extends SortStrategy {
    public void sort() {
        System.out.println("Heap Sort!");
    }
}

6. com.cleversoft.designpatterns.behavioral.strategy.BubbleSort.java:
package com.cleversoft.designpatterns.behavioral.strategy;

public class BubbleSort extends SortStrategy {
    public void sort() {
        System.out.println("Bubble Sort!");
    }
}

7. com.cleversoft.designpatterns.behavioral.strategy.Client.java:
package com.cleversoft.designpatterns.behavioral.strategy;

public class Client {

    /**
     * @param args
     * @author qixiang
     */
    public static void main(String[] args) {
        SortStrategy sortStrategy = new HeapSort();
        Sorter sorter = new Sorter();
        sorter.setSortStrategy(sortStrategy);
        sorter.sort();
    }

}



Thomas 2007-09-06 08:42 发表评论
]]>『蚂蚁学模式』之实例化门面（Facade）模式http://www.blogjava.net/qixiangnj/archive/2007/05/29/119824.htmlThomasThomasTue, 29 May 2007 01:35:00 GMThttp://www.blogjava.net/qixiangnj/archive/2007/05/29/119824.htmlhttp://www.blogjava.net/qixiangnj/comments/119824.htmlhttp://www.blogjava.net/qixiangnj/archive/2007/05/29/119824.html#Feedback1http://www.blogjava.net/qixiangnj/comments/commentRss/119824.htmlhttp://www.blogjava.net/qixiangnj/services/trackbacks/119824.html门面模式要求一个子系统的外部与其内部的通信必须通过一个统一的门面（Facade）对象进行。

何时使用？
1. 为一个复杂子系统提供一个简单接口
2. 子系统的独立性
3. 层次化结构

对象图示意：


1. com.cleversoft.designpatterns.facade.Alarm.java:
package com.cleversoft.designpatterns.facade;

public class Alarm {
    public void activate() {
        System.out.println("Activating the alarm.");
    }

    public void deactivate() {
        System.out.println("Deactivating the alarm.");
    }

    public void ring() {
        System.out.println("Ring the alarm.");
    }

    public void stopRing() {
        System.out.println("Stop the alarm.");
    }
}

2. com.cleversoft.designpatterns.facade.Camera.java:
package com.cleversoft.designpatterns.facade;

public class Camera {
    public void turnOn() {
        System.out.println("Turning on the camera.");
    }

    public void turnOff() {
        System.out.println("Turning off the camera.");
    }

    public void rotate(int degrees) {
        System.out.println("Rotating the camera by " + degrees + " degrees.");
    }
}

3. com.cleversoft.designpatterns.facade.Light.java:
package com.cleversoft.designpatterns.facade;

public class Light {
    public void turnOn() {
        System.out.println("Turning on the light.");
    }

    public void turnOff() {
        System.out.println("Turning off the light.");
    }

    public void changeBulb() {
        System.out.println("Changing the light-bulb.");
    }
}

4. com.cleversoft.designpatterns.facade.Sensor.java:
package com.cleversoft.designpatterns.facade;

public class Sensor {
    public void activate() {
        System.out.println("Activating on the sensor.");
    }

    public void deactivate() {
        System.out.println("Deactivating on the sensor.");
    }

    public void trigger() {
        System.out.println("The sensor has been triggered.");
    }
}

5. com.cleversoft.designpatterns.facade.SecurityFacade.java:
package com.cleversoft.designpatterns.facade;

public class SecurityFacade {
    private Camera camera1, camera2;

    private Light light1, light2, light3;

    private Sensor sensor;

    private Alarm alarm;

    public SecurityFacade() {
        camera1 = new Camera();
        camera2 = new Camera();
        light1 = new Light();
        light2 = new Light();
        light3 = new Light();
        sensor = new Sensor();
        alarm = new Alarm();
    }

    public void activate() {
        camera1.turnOn();
        camera2.turnOn();

        light1.turnOn();
        light2.turnOn();
        light3.turnOn();

        sensor.activate();
        alarm.activate();
    }

    public void deactivate() {
        camera1.turnOff();
        camera2.turnOff();

        light1.turnOff();
        light2.turnOff();
        light3.turnOff();

        sensor.deactivate();
        alarm.deactivate();
    }
}

6. com.cleversoft.designpatterns.facade.Client.java:
package com.cleversoft.designpatterns.facade;

public class Client {
    private static SecurityFacade security = new SecurityFacade();

    public static void main(String[] args) {
        security.activate();
    }
}


参考资料：
1. 《Java与模式》


Thomas 2007-05-29 09:35 发表评论
]]>『蚂蚁学模式』之实例化代理（Proxy）模式http://www.blogjava.net/qixiangnj/archive/2007/02/02/97687.htmlThomasThomasFri, 02 Feb 2007 14:27:00 GMThttp://www.blogjava.net/qixiangnj/archive/2007/02/02/97687.htmlhttp://www.blogjava.net/qixiangnj/comments/97687.htmlhttp://www.blogjava.net/qixiangnj/archive/2007/02/02/97687.html#Feedback0http://www.blogjava.net/qixiangnj/comments/commentRss/97687.htmlhttp://www.blogjava.net/qixiangnj/services/trackbacks/97687.html给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

代理的种类：
1. 远程（Remote）代理：为一个位于不同的地址空间的对象提供一个局域代表对象。这个不同的地址空间可以是在本机器中，也可是在另一台机器中。
2. 虚拟（Virtual）代理：根据需要创建一个资源消耗较大的对象，使得此对象只在需要时才会被真正创建。
3. Copy-on-Write代理：虚拟代理的一种。把复制（克隆）拖延到只有在客户端需要时，才真正采取行动。
4. 保护（Protect or Access）代理：控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。
5. Cache代理：为某一个目标操作的结果提供临时的存储空间，以便多个客户端可以共享这些结果。
6. 防火墙（Firewall）代理：保护目标，不让恶意用户接近。
7. 同步化（Synchronization）代理：使几个用户能够同时使用一个对象而没有冲突。
8. 智能引用（Smart Reference）代理：当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来等。

示意类图：








1. com.cleversoft.designpatterns.proxy.Subject.java:
package com.cleversoft.designpatterns.proxy;

public interface Subject {
    public void request();
}

2. com.cleversoft.designpatterns.proxy.RealSubject.java:
package com.cleversoft.designpatterns.proxy;

public class RealSubject implements Subject {

    public void request() {
        System.out.println("From real subject");

    }

}

3. com.cleversoft.designpatterns.proxy.ProxySubject.java:
package com.cleversoft.designpatterns.proxy;

public class ProxySubject implements Subject {
    private RealSubject realSubject;

    public ProxySubject() {
    }

    public void request() {
        preRequest();

        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        realSubject.request();

        postRequest();
    }

    private void postRequest() {
        System.out.println("From post request");

    }

    private void preRequest() {
        System.out.println("From pre request");

    }

}

4. com.cleversoft.designpatterns.proxy.Client.java:
package com.cleversoft.designpatterns.proxy;

public class Client {
    private static Subject subject;

    public static void main(String[] args) {
        subject = new ProxySubject();
        subject.request();
    }

}


参考资料：
1. 《Java与模式》

Thomas 2007-02-02 22:27 发表评论
]]>『蚂蚁学模式』之实例化装饰（Decorator）模式http://www.blogjava.net/qixiangnj/archive/2007/01/31/97095.htmlThomasThomasWed, 31 Jan 2007 15:05:00 GMThttp://www.blogjava.net/qixiangnj/archive/2007/01/31/97095.htmlhttp://www.blogjava.net/qixiangnj/comments/97095.htmlhttp://www.blogjava.net/qixiangnj/archive/2007/01/31/97095.html#Feedback0http://www.blogjava.net/qixiangnj/comments/commentRss/97095.htmlhttp://www.blogjava.net/qixiangnj/services/trackbacks/97095.html以对客户端透明（客户端并不会觉得对象在装饰前后有什么不同，老孙就是老孙！^_^）的方式扩展对象的功能，是继承关系的一个替代方案。

何时使用？
1. 需要扩展一个类的功能，或给一个类增加附加责任。
2. 需要动态地给一个对象增加功能，这些功能可以再动态地撤销。
3. 需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变得不现实。

优点：
1. 可以提供比继承更多的灵活性。
2. 通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合。

缺点：
1. 会产生比使用继承关系更多的对象，会使得查错变得困难。

类图示意：



















1. com.cleversoft.designpatterns.decorator.Widget.java:
package com.cleversoft.designpatterns.decorator;

public interface Widget {
    void draw();
}

2. com.cleversoft.designpatterns.decorator.TextField.java:
package com.cleversoft.designpatterns.decorator;

public class TextField implements Widget {
    private int width, height;

    public TextField(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public void draw() {
        System.out.println("TextField: " + width + ", " + height);
    }
}

3. com.cleversoft.designpatterns.decorator.Decorator.java:
package com.cleversoft.designpatterns.decorator;

public abstract class Decorator implements Widget {
    private Widget wid;

    public Decorator(Widget wid) {
        this.wid = wid;
    }

    public void draw() {
        wid.draw();
    }
}

4. com.cleversoft.designpatterns.decorator.BorderDecorator.java:
package com.cleversoft.designpatterns.decorator;

public class BorderDecorator extends Decorator {

    public BorderDecorator(Widget wid) {
        super(wid);
    }

    public void draw() {
        super.draw();
        System.out.println("   BorderDecorator");
    }
}

5. com.cleversoft.designpatterns.decorator.ScrollDecorator.java:
package com.cleversoft.designpatterns.decorator;

public class ScrollDecorator extends Decorator {

    public ScrollDecorator(Widget wid) {
        super(wid);
    }

    public void draw() {
        super.draw();
        System.out.println("   ScrollDecorator");
    }

}

6. com.cleversoft.designpatterns.decorator.Client.java:
package com.cleversoft.designpatterns.decorator;

public class Client {

    public static void main(String[] args) {
        // Widget w = new TextField(20, 10);
        // Widget b = new BorderDecorator(w);
        // b.draw();

        Widget w = new BorderDecorator(new ScrollDecorator(
                new TextField(50, 20)));
        w.draw();
    }
}


参考资料：
1. 《Java与模式》
2. Design Patterns With Code

Thomas 2007-01-31 23:05 发表评论
]]>『蚂蚁学模式』之实例化合成（Composite）模式http://www.blogjava.net/qixiangnj/archive/2007/01/13/93580.htmlThomasThomasSat, 13 Jan 2007 03:54:00 GMThttp://www.blogjava.net/qixiangnj/archive/2007/01/13/93580.htmlhttp://www.blogjava.net/qixiangnj/comments/93580.htmlhttp://www.blogjava.net/qixiangnj/archive/2007/01/13/93580.html#Feedback1http://www.blogjava.net/qixiangnj/comments/commentRss/93580.htmlhttp://www.blogjava.net/qixiangnj/services/trackbacks/93580.html阅读全文

Thomas 2007-01-13 11:54 发表评论
]]>『蚂蚁学模式』之实例化缺省适配器（Default Adapter）模式http://www.blogjava.net/qixiangnj/archive/2007/01/10/92873.htmlThomasThomasWed, 10 Jan 2007 04:26:00 GMThttp://www.blogjava.net/qixiangnj/archive/2007/01/10/92873.htmlhttp://www.blogjava.net/qixiangnj/comments/92873.htmlhttp://www.blogjava.net/qixiangnj/archive/2007/01/10/92873.html#Feedback2http://www.blogjava.net/qixiangnj/comments/commentRss/92873.htmlhttp://www.blogjava.net/qixiangnj/services/trackbacks/92873.html 缺省适配器模式：为一个接口提供缺省实现，这样子类型可以从这个缺省实现进行扩展，而不必从原有接口进行扩展。
“平庸化”的适配器模式。

1. com.cleversoft.designpatterns.defaultadapter.InterfaceA.java:

package  com.cleversoft.designpatterns.defaultadapter;

 public   interface  InterfaceA  {
     public   void  a();

     public   void  b();

     public   void  c();

     public   void  d();
}

2. com.cleversoft.designpatterns.defaultadapter.AdapterB.java:
package com.cleversoft.designpatterns.defaultadapter;

public abstract class AdapterB implements InterfaceA {
    public void a() {
    }

    public void b() {
    }

    public void c() {
    }

    public void d() {
    }
}

3. com.cleversoft.designpatterns.defaultadapter.ClassC.java:
package com.cleversoft.designpatterns.defaultadapter;

public class ClassC extends AdapterB {
    public void a() {
        System.out.println("a()");
    }

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


参考资料：
1. 《Java与模式》

Thomas 2007-01-10 12:26 发表评论
]]>『蚂蚁学模式』之实例化适配器（Adapter）模式http://www.blogjava.net/qixiangnj/archive/2007/01/09/92693.htmlThomasThomasTue, 09 Jan 2007 10:47:00 GMThttp://www.blogjava.net/qixiangnj/archive/2007/01/09/92693.htmlhttp://www.blogjava.net/qixiangnj/comments/92693.htmlhttp://www.blogjava.net/qixiangnj/archive/2007/01/09/92693.html#Feedback0http://www.blogjava.net/qixiangnj/comments/commentRss/92693.htmlhttp://www.blogjava.net/qixiangnj/services/trackbacks/92693.html结构模式：描述如何将类或者对象组合在一起形成更大的结构。

适配器模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。
使用场合：
1）系统需要使用现有的类，而此类的接口不符合系统的需要。
2）想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。这些源类不一定有很复杂的接口。
3）（对对象的适配器模式而言）在设计里，需要改变多个已有的子类的接口，如果使用类的适配器模式，就要针对每一个子类做一个适配器类，而这不太实际。


类/对象的适配器模式：
1. com.cleversoft.designpatterns.adapter.Target.java:
package com.cleversoft.designpatterns.adapter;

public interface Target {
    public void request();
}

2. com.cleversoft.designpatterns.adapter.Adaptee.java:
package com.cleversoft.designpatterns.adapter;

public class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee: SpecificRequest");
    }
}

3. com.cleversoft.designpatterns.adapter.ClassAdapter.java:
package com.cleversoft.designpatterns.adapter;

public class ClassAdapter extends Adaptee implements Target {
    public void request() {
        specificRequest();
    }
}

4. com.cleversoft.designpatterns.adapter.ObjectAdapter.java:
package com.cleversoft.designpatterns.adapter;

public class ObjectAdapter implements Target {
    private Adaptee adaptee;

    public ObjectAdapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    public void request() {
        adaptee.specificRequest();
    }
}

5. com.cleversoft.designpatterns.adapter.Client.java: