BlogJava-『一只小蚂蚁』的专栏-随笔分类-蚂蚁学模式

『蚂蚁学模式』之实例化策略（Strategy）模式

Thomas — Thu, 06 Sep 2007 00:42:00 GMT

策略模式属于对象的行为模式。
其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。

策略模式的结构：

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

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

何时使用？
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）模式

Thomas — Tue, 29 May 2007 01:35:00 GMT

门面模式是对象的结构模式。
门面模式要求一个子系统的外部与其内部的通信必须通过一个统一的门面（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）模式

Thomas — Fri, 02 Feb 2007 14:27:00 GMT

给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

代理的种类：
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）模式

Thomas — Wed, 31 Jan 2007 15:05:00 GMT

又称包装（wrapper）模式。
以对客户端透明（客户端并不会觉得对象在装饰前后有什么不同，老孙就是老孙！^_^）的方式扩展对象的功能，是继承关系的一个替代方案。

何时使用？
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）模式

Thomas — Sat, 13 Jan 2007 03:54:00 GMT

摘要: 对象的结构模式，又称“部分－整体”模式。合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式可以使客户端将单纯元素与复合元素同等对待。适用场合：1. 需要描述对象的部分和整体的等级结构。2. 需要客户端忽略掉个体构件和组合构件的区别。客户端必须平等对待所有的构件，包括个体构件和组合构件。优点：1. 合成模式可以很容易地增加新种类的构件。2. 使用合成模式可以使客户端变得很容易设计，... 阅读全文

Thomas 2007-01-13 11:54 发表评论

『蚂蚁学模式』之实例化缺省适配器（Default Adapter）模式

Thomas — Wed, 10 Jan 2007 04:26:00 GMT

缺省适配器模式：为一个接口提供缺省实现，这样子类型可以从这个缺省实现进行扩展，而不必从原有接口进行扩展。
“平庸化”的适配器模式。

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）模式

Thomas — Tue, 09 Jan 2007 10:47:00 GMT

结构模式：描述如何将类或者对象组合在一起形成更大的结构。

适配器模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。
使用场合：
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:

package com.cleversoft.designpatterns.adapter;

public class Client {

    public static void main(String[] args) {
        System.out.println("Object Adapter");
        Adaptee adaptee = new Adaptee();
        ObjectAdapter objectAdapter = new ObjectAdapter(adaptee);
        objectAdapter.request();

        System.out.println("Class Adapter");
        ClassAdapter classAdapter = new ClassAdapter();
        classAdapter.request();
    }

}

参考资料：
1. 《Java与模式》
2. Thinking in Patterns

Thomas 2007-01-09 18:47 发表评论

『蚂蚁学模式』之实例化原型模式

Thomas — Tue, 02 Jan 2007 13:31:00 GMT

用意：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象。

1. com.cleversoft.designpatterns.prototype.Prototype.java:

package com.cleversoft.designpatterns.prototype;

interface Prototype {
    Object clone();

    String getName();

     void execute();
}

2. com.cleversoft.designpatterns.prototype.This.java:

package com.cleversoft.designpatterns.prototype;

class This implements Prototype {
    public Object clone() {
        return new This();
    }

    public String getName() {
        return "This";
    }

    public void execute() {
        System.out.println("This: execute");
    }
}

3. com.cleversoft.designpatterns.prototype.That.java:

package com.cleversoft.designpatterns.prototype;

class That implements Prototype {
    public Object clone() {
        return new That();
    }

    public String getName() {
        return "That";
    }

    public void execute() {
        System.out.println("That: execute");
    }
}

4. com.cleversoft.designpatterns.prototype.PrototypesModule.java:

package com.cleversoft.designpatterns.prototype;

class PrototypesModule {
    private static Prototype[] prototypes = new Prototype[9];

    private static int total = 0;

    public static void addPrototype(Prototype obj) {
        prototypes[total++] = obj;
    }

    public static Object findAndClone(String name) {
        for (int i = 0; i < total; i++)
            if (prototypes[i].getName().equals(name))
                return prototypes[i].clone();
        System.out.println(name + " not found");
        return null;
    }
}

5. com.cleversoft.designpatterns.prototype.Main.java:

package com.cleversoft.designpatterns.prototype;

public class Main {
    public static void initializePrototypes() {
        PrototypesModule.addPrototype(new This());
        PrototypesModule.addPrototype(new That());
    }

    public static void main(String[] args) {
        initializePrototypes();
        Object[] objects = new Object[9];
        int total = 0;

        for (int i = 0; i < args.length; i++) {
            objects[total] = PrototypesModule.findAndClone(args[i]);
            if (objects[total] != null)
                total++;
        }
        for (int i = 0; i < total; i++)
            ((Prototype) objects[i]).execute();

    }
}

参考资料：
1. 《Java与模式》
2. http://terrylee.cnblogs.com/archive/2006/01/16/317896.html
3. Design Patterns With Code
4. Thinking in Patterns

Thomas 2007-01-02 21:31 发表评论

『蚂蚁学模式』之实例化建造者模式

Thomas — Wed, 27 Dec 2006 03:56:00 GMT

摘要: 建造者模式可以将一个产品的内部表象与产品的生成过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。UML图示：1. com.cleversoft.designpatterns.builder2.PostalClert.java:package com.cleversoft.designpatterns.builder2;public class PostalClert { ... 阅读全文

Thomas 2006-12-27 11:56 发表评论

『蚂蚁学模式』之实例化单例模式（二）

Thomas — Sat, 23 Dec 2006 08:27:00 GMT

前面说了单例模式，这次说说单例模式的推广——多例模式。

有上限多例模式
com.cleversoft.designpatterns.multiton.Die.java:

package com.cleversoft.designpatterns.multiton;

import java.util.Random;
import java.util.Date;

public class Die {
    private static Die die1 = new Die();

    private static Die die2 = new Die();

    private Die() {
    }

    public static Die getInstance(int whichOne) {
        if (whichOne == 1) {
            return die1;
        } else {
            return die2;
        }
    }

    public synchronized int dice() {
        Date d = new Date();

        Random r = new Random(d.getTime());
        int value = r.nextInt();
        value = Math.abs(value);

        value = value % 6;
        value += 1;
        System.out.println(value);
        return value;
    }

}

com.cleversoft.designpatterns.multiton.Main.java:

package com.cleversoft.designpatterns.multiton;

public class Main {
    private static Die die1;

    private static Die die2;

    public static void main(String[] args) {
        die1 = Die.getInstance(1);
        die2 = Die.getInstance(2);

        die1.dice();
        die2.dice();
    }
}

无上限多例模式
比较合适的例子就是在应用程序中的“多语言支持”和序列键生成器。

参考资料：《Java与模式》

Thomas 2006-12-23 16:27 发表评论

『蚂蚁学模式』之实例化单例模式（一）

Thomas — Wed, 20 Dec 2006 14:58:00 GMT

饿汉式单例
com.cleversoft.designpatterns.singleton1.Singleton.java:

package com.cleversoft.designpatterns.singleton1;

/**
* Hungry Singleton
*
*/
public class Singleton {

    private static Singleton singleton = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return singleton;
    }

    public String demoMethod() {
        return "This is a hungry singleton demo!";
    }
}

com.cleversoft.designpatterns.singleton1.Main.java:

package com.cleversoft.designpatterns.singleton1;

public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(Singleton.getInstance().demoMethod());
    }

}

懒汉式单例
com.cleversoft.designpatterns.singleton2.LazySingleton.java:

package com.cleversoft.designpatterns.singleton2;

/**
* Lazy Singleton
*
*/
public class LazySingleton {
    static boolean instance_flag = false;

    private LazySingleton() {
    }

    synchronized public static LazySingleton getInstance() {
        if (!instance_flag) {
            instance_flag = true;
            return new LazySingleton();
        } else
            return null;
    }

}

com.cleversoft.designpatterns.singleton2.Main.java:

package com.cleversoft.designpatterns.singleton2;

public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LazySingleton ls1, ls2;
        System.out.println("Start to get first Instance");
        ls1 = LazySingleton.getInstance();
        if (ls1 != null){
            System.out.println("This is the first Instance!\n");
        }

        System.out.println("Start to get second Instance");
        ls2 = LazySingleton.getInstance();
        if (ls2 != null){
            System.out.println("This is the second Instance!");
        }
        else{
            System.out.println("You can just get 1 Instance!");
        }

    }

}

引用：
>强烈建议大家不要再花时间在实现双重检查成例上
是这样，不必在这上面钻牛角尖，而且单例模式在实际应用中已经逐步被Ioc容器替代，实用价值不高。（banq）
(http://www.jdon.com/jive/thread.jsp?forum=91&thread=23890)

参考资料：
1. 《Java与模式》
2. http://www.java2s.com

Thomas 2006-12-20 22:58 发表评论

『蚂蚁学模式』之实例化抽象工厂模式及碎言

Thomas — Mon, 18 Dec 2006 14:22:00 GMT

延续『蚂蚁学模式』之实例化简单工厂、工厂方法模式中工厂方法模式的实例。
而这次，汽车厂(MotorFactory)有新的需求，不只要生产国产车(NativeMotor)，还需要生产进口车(ForeignMotor)。这两种车都包括公交(Bus)和小轿车(Car)。
1. com.cleversoft.designpatterns.abstractfactory.MotorFactory.java

package com.cleversoft.designpatterns.abstractfactory;

public interface MotorFactory {

}

2. com.cleversoft.designpatterns.abstractfactory.NativeMotor.java

package com.cleversoft.designpatterns.abstractfactory;

public class NativeMotor implements MotorFactory {
    public Car produceCar() {
        return new NativeCar();
    }

    public Bus produceBus() {
        return new NativeBus();
    }
}

3. com.cleversoft.designpatterns.abstractfactory.ForeignMotor.java

package com.cleversoft.designpatterns.abstractfactory;

public class ForeignMotor implements MotorFactory {
    public Car produceCar() {
        return new ForeignCar();
    }

    public Bus produceBus() {
        return new ForeignBus();
    }
}

4. com.cleversoft.designpatterns.abstractfactory.Bus.java

package com.cleversoft.designpatterns.abstractfactory;

public interface Bus {
public void run();
}

5. com.cleversoft.designpatterns.abstractfactory.Car.java

package com.cleversoft.designpatterns.abstractfactory;

public interface Car {
public void run();
}

6. com.cleversoft.designpatterns.abstractfactory.ForeignBus.java

package com.cleversoft.designpatterns.abstractfactory;

public class ForeignBus implements Bus {

    public ForeignBus() {

    }

    public void run() {
        System.out.println("This is a foreign bus!");
    }
}

7. com.cleversoft.designpatterns.abstractfactory.ForeignCar.java

package com.cleversoft.designpatterns.abstractfactory;

public class ForeignCar implements Car {

    public ForeignCar() {

    }

    public void run() {
        System.out.println("This is a foreign car!");
    }
}

8. com.cleversoft.designpatterns.abstractfactory.NativeBus.java

package com.cleversoft.designpatterns.abstractfactory;

public class NativeBus implements Bus {

    public NativeBus() {

    }

    public void run() {
        System.out.println("This is a native bus!");
    }
}

9. com.cleversoft.designpatterns.abstractfactory.NativeCar.java

package com.cleversoft.designpatterns.abstractfactory;

public class NativeCar implements Car {
    public NativeCar() {

    }

    public void run() {
        System.out.println("This is a native car!");
    }
}

10. com.cleversoft.designpatterns.abstractfactory.Main.java

package com.cleversoft.designpatterns.abstractfactory;

public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Bus b = new ForeignMotor().produceBus();
        b.run();
        Car c = new NativeMotor().produceCar();
        c.run();
    }

}

终于开始想通一些问题，。也再次印证这样的道理：没有笨的读者，只有笨的作者。
从分析的角度，你要做的无非是些抽象的活儿；从普通编程人员的角度，你要实现的是类似NativeBus.java的具体实现。这是差距，巨大的差距！
会写实例以外的一些东西。

参考资料：
1. http://terrylee.cnblogs.com/archive/2005/12/13/295965.html
2. 《Java与模式》

Thomas 2006-12-18 22:22 发表评论

『蚂蚁学模式』之实例化简单工厂、工厂方法模式

Thomas — Wed, 13 Dec 2006 14:08:00 GMT

摘要: 我想“一切从实例开始”是我最易接受的方式。网上有太多的理论和经验总结，于已而言，吸收亦成乐事。先看实例，很简单。UML图也懒得画了，更喜欢CRC卡片的方式。一、简单工厂模式1. com.cleversoft.designpatterns.simplefactory.Motor.javapackage com.cleversoft.designpatterns.simplefactory;publi... 阅读全文

Thomas 2006-12-13 22:08 发表评论

『蚂蚁学模式』之迪米特法则（LoD）

Thomas — Thu, 28 Sep 2006 14:06:00 GMT

一个对象应当对其他对象有尽可能少的了解。

11.1 迪米特法则的各种表述：
1）只与你直接的朋友们通信。
2）不要跟“陌生人”说话。
3）每一个软件单位对其他的单位都只有最少的知识，而且局限于那些与本单位密切相关的软件单位。

11.2 狭义的迪米特法则
如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中的一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。

朋友圈的确定
“朋友”条件：
1）当前对象本身（this）
2）以参量形式传入到当前对象方法中的对象
3）当前对象的实例变量直接引用的对象
4）当前对象的实例变量如果是一个聚集，那么聚集中的元素也都是朋友
5）当前对象所创建的对象
任何一个对象，如果满足上面的条件之一，就是当前对象的“朋友”；否则就是“陌生人”。
缺点：会在系统里造出大量的小方法，散落在系统的各个角落。

与依赖倒转原则互补使用

11.3 迪米特法则与设计模式
门面模式*
调停者模式*

11.4 广义的迪米特法则
迪米特法则的主要用意是控制信息的过载。在将迪米特法则运用到系统设计中时，要注意下面的几点：
1）在类的划分上，应当创建有弱耦合的类。
2）在类的结构设计上，每一个类都应当尽量降低成员的访问权限。
3）在类的设计上，只要有可能，一个类应当设计成不变类。
4）在对其他类的引用上，一个对象对其对象的引用应当降到最低。

11.5 广义迪米特法则在类的设计上的体现
1）优先考虑将一个类设置成不变类
2）尽量降低一个类的访问权限
3）谨慎使用Serializable
4）尽量降低成员的访问权限
5）取代C Struct

一个类似于C Struct的Java类：

public class Point
{
public int x;
public int y;
}

一个好的设计：

public class Point
{
  private int x;
  private int y;
  public Point(int x, int y)
  {
    this.x = x;
    this.y = y;
  }
  public int getX()
  {
    return x;
  }
  public int getY()
  {
    return y;
  }
  public void setX(int x)
  {
    this.x = x;
  }
  public void setY(int y)
  {
    this.y = y;
  }
}

11.6 广义迪米特法则在代码层次上的实现
1）限制局域变量的有效范围

Thomas 2006-09-28 22:06 发表评论

『蚂蚁学模式』之合成/聚合复合原则（CARP）

Thomas — Mon, 25 Sep 2006 14:23:00 GMT

第10章合成/聚合复用原则（CARP）
合成/聚合复用原则：在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分；新的对象通过向这些对象的委派达到复用已有功能的目的。
简言之：要尽量使用合成/聚合，尽量不要使用继承。

10.1 合成和聚合的区别
聚合关系：
关联关系的一种，是强的关联关系。聚合是整体和个体之间的关系。

合成关系：
关联关系的一种，是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分的对象的生命周期，合成关系是不能共享的。

10.2 复用的基本种类
1. 合成/聚合复用
好处：
1）新对象存取成分对象的惟一方法是通过成分对象的接口。
2）这种复用是黑箱复用，因为成分对象的内部细节是新对象所看不见的。
3）这种复用支持包装。
4）这种复用所需的依赖较少。
5）每一个新的类可以将焦点集中在一个任务上。
6）这种复用可以在运行时间内动态进行，新对象可以动态地引用与成分对象类型相同的对象。
主要缺点：通过使用这种复用建造的系统会有较多的对象需要管理。

2. 继承
优点：
1）新的实现较为容易，因为超类的大部分功能可以通过继承关系自动进入子类。
2）修改或扩展继承而来的实现较为容易。
缺点：
1）继承复用破坏包装，因为继承将超类的实现细节暴露给子类。
2）如果超类的实现发生改变，那么子类的实现也不得不发生改变。
3）从超类继承而来的实现是静态的，不可能在运行时间内发生改变，因此没有足够的灵活性。

10.3
区分“Has－A”与“Is－A”
“Is－A”代表一个类是另一个类的一种；
“Has－A”代表一个类是另一个类的一个角色，而不是另一个类的一个特殊种类。

里氏代换原则是继承复用的基石。

Thomas 2006-09-25 22:23 发表评论

『蚂蚁学模式』之接口隔离原则（ISP）

Thomas — Thu, 21 Sep 2006 13:46:00 GMT

第9章接口隔离原则（ISP）
使用多个专门的接口比使用单一的总接口要好。
换言之，从一个客户类的角度来讲：一个类对另外一个类的依赖性应当是建立在最小的接口上的。

9.1 what?
角色隔离原则

定制服务
每一个Java接口都仅仅将客户端需要的行为暴露给客户端，而没有将客户端所不需要的行为放到接口中。
适配器模式

接口污染

迪米特法则要求任何一个软件实体，除非绝对需要，不然不要与外界通信。即使必须进行通信，也应当尽量限制通信的广度和深度。
符合迪米特法则。

9.3 定制服务的例子
定制服务：如果客户端仅仅需要某一些方法的话，那么就应当向客户端提供这些需要的方法，而不要提供不需要的方法。
效果：
1）这样做很整洁
2）系统的可维护性

备忘录模式*

迭代子模式*

Thomas 2006-09-21 21:46 发表评论

『蚂蚁学模式』之依赖倒转原则（DIP）

Thomas — Tue, 19 Sep 2006 14:40:00 GMT

第8章依赖倒转原则（DIP）

依赖倒转原则：要依赖于抽象，不要依赖于具体。

8.3 依赖倒转原则
三种耦合关系：
1）零耦合
2）具体耦合：发生在两个具体的（可实例化的）类之间。
3）抽象耦合：发生在一个具体类和一个抽象类（或者Java接口）之间。

what?
抽象不应当依赖于细节；细节应当依赖于抽象。

另一种表述：
要针对接口编程，不要针对实现编程。
一个具体Java类应当只实现Java接口和抽象Java类中声明过的方法，而不应当给出多余的方法。

变量的静态类型：变量被声明时的类型。
变量的真实类型：变量所引用的对象的真实类型。

引用对象的抽象类型
在很多情况下，一个Java程序需要引用一个对象。这个时候，如果这个对象有一个抽象类型的话，应当使用这个抽象类型作为变量的静态类型。这就是针对接口编程的含义。
例如：蛋 x = new 鸡();
而非：鸡 x = new 鸡();

List employees = new Vector();
而非：Vector employees = new Vector();

8.4 how?
工厂方法模式*
模版方法模式*
迭代子模式*

8.5 Java对抽象类型的支持
Java接口与Java抽象类的区别：
1）Java抽象类可以提供某些方法的部分实现，而Java接口则不可以。
2）一个抽象类的实现只能由这个抽象类的子类给出；任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型，而一个类可以实现任意多个Java接口。
3）从代码重构的角度上讲，将一个单独的Java具体类重构成一个Java接口的实现是很容易的；而为一个已有的具体类添加一个Java抽象类作为抽象类型却不那么容易，因为这个具体类有可能已经有一个超类。
4）Java接口是定义混合类型的理想工具。

联合使用Java接口和Java抽象类
缺省适配模式

8.8 优缺点
不容易实现；
假定所有的具体类都是会变化的。

Thomas 2006-09-19 22:40 发表评论

『蚂蚁学模式』之里氏代换原则（LSP）

Thomas — Fri, 15 Sep 2006 08:42:00 GMT

摘要: 7.2 what一个软件实体如果使用的是一个基类的话，那么一定适用于其子类，而且它根本不能觉察出基类对象和子类对象的区别。反之不成立。7.3 在设计模式中的体现策略模式合成模式代理模式7.5长方形和正方形Rectangle类的源代码： 1package com.javapatterns.liskov.version1; 2 3public class Rectangle 4{ 5 priva... 阅读全文

Thomas 2006-09-15 16:42 发表评论

『蚂蚁学模式』之抽象类

Thomas — Wed, 13 Sep 2006 13:57:00 GMT

第6章专题：抽象类
6.1 what？
抽象类仅提供一个类型的部分实现。抽象类可以有实例变量，以及一个或多个构造子。抽象类可以同时有抽象方法和具体方法。
一个抽象类不会有实例，这些构造子不能被客户端调用来创建实例。一个抽象类的构造子可以被其子类调用，从而使一个抽象类的所有子类都可以有一些共有的实现，而不同的子类可以在此基础上有其自己的实现。

6.2 用途
抽象类通常代表一个抽象概念，它提供一个继承的出发点。

具体类不是用来继承的

抽象类应当拥有尽可能多的共同代码
在一个从抽象类到多个具体类的继承关系中，共同的代码应当尽量移动到抽象类里。
策略模式

抽象类应当拥有尽可能少的数据

6.3 基于抽象类的模式和原则
1. 针对抽象编程
    依赖倒转原则（DIP）
2. 正确使用继承
    组合/聚合复用原则（CARP）
    里氏代换原则（LSP）
3. 模版方法模式

6.4 什么时候才应当使用继承复用
1. 子类是超类的一个特殊种类，而不是超类的一个角色。
    Has－A关系应当使用聚合关系描述，而只有Is－A关系才符合继承关系。
2. 永远不会出现需要将子类换成另一个类的子类的情况。
3. 子类具有扩展超类的责任，而不是具有置换掉（Override）或注销掉（Nullify）超类的责任。
4. 只有在分类学角度上有意义时，才可以使用继承，不要从工具类继承。

Thomas 2006-09-13 21:57 发表评论

『蚂蚁学模式』之接口

Thomas — Mon, 11 Sep 2006 14:08:00 GMT

第5章专题：Java语言的接口
5.1 what?
一个Java接口是一些方法特征的集合。

接口继承：一个类实现一个接口。
实现继承：一个类是另一个类的子类。

接口和类的最重要区别：
接口仅仅描述方法的特征，而不给出方法的实现；而类不仅给出方法的特征，而且给出方法的实现。

5.2 why？
接口是对可插入性的保证。
关联的可插入性
关联：一个对象需要完成一项任务，所以需要知道其他的对象，并且调用其他对象的方法。这个对象对其他对象的知识叫做关联。
当前对象并不在意所关联的是哪一个具体类，而仅仅关心这个类是否实现了某一个接口。

调用的可插入性

类型
Java接口（以及Java抽象类）用来声明一个新的类型。
在理想的情况下，一个具体Java类应当只实现Java接口和抽象Java类中声明过的方法，而不应当给出多余的方法。

类型等级结构
混合类型：
如果一个类已经有一个主要的超类型，那么通过实现一个接口，这个类可以拥有另一个次要的超类型。这种次要的超类型就叫做混合类型。
当一个具体类处于一个类的等级结构之中的时候，为这个具体类定义一个混合类型是可以保证基于这个类型的可插入性的关键。

5.3 how？
单方法接口：
一个单方法接口只含有一个方法。

实现单方法接口的源代码：

public class MyThreadedClass extends SomeClass implements Runnable
{
  .
  .
  .
  public void run()
  {
    //write your code here
  }
}

ActionListener接口的源代码：

public interface ActionListener
{
public abstract void actionPerformed(ActionEvent event);
}

标识接口：
标识接口是没有任何方法和属性的接口。
标识接口不对实现它的类有任何语义上的要求，它仅仅表明实现它的类属于一个特定的类型。
java.io.Serializable、java.rmi.Remote等

java.io.Serializable接口的源代码：

package java.io;
public interface Serializable{}

java.rmi.Remote接口的源代码：

package java.rmi;
public interface Remote{}

标识接口通常使用在工具类中，很少在其他地方使用。

常量接口：
用Java接口来声明一些常量，然后由实现这个接口的类使用这些常量。

AppConstants接口的源代码：

public interface AppConstants
{
  public static final DATA_SOURCE_NAME = "WEBSPHERE_DATA_SOURCE";
  public static final USER_NAME = "APP_USER";
  public static final PASSWORD = "w1nter";
}

Thomas 2006-09-11 22:08 发表评论

『蚂蚁学模式』之软件的可维护性和可复用性、“开－闭”原则（OCP）

Thomas — Sun, 10 Sep 2006 14:19:00 GMT

第3章软件的可维护性和可复用性
3.1
真正的原因：
过于僵硬；过于脆弱；复用率低；黏度过高
设计目标：
可扩展性；灵活性；可插入性

3.2
在面向对象的设计里面，可维护性复用是以设计原则和设计模式为基础的
设计原则：
“开－闭”原则
里氏代换原则
依赖倒转原则
接口隔离原则
组合/聚合复用原则
迪米特法则

第4章 “开－闭”原则（OCP）
4.1
“开－闭”原则：一个软件实体应当对扩展开放，对修改关闭。
即，在设计一个模块的时候，应当使这个模块可以在不被修改的前提下被扩展。换言之，应当可以在不必修改源代码的情况下改变这个模块的行为。

4.2
抽象是关键

对可变性的封装原则：
1）一种可变性不应当散落在代码的很多角落里，而应当被封装到一个对象里面。
继承应当被看做是封装变化的方法，而不应当被认为是以一般的对象生成特殊的对象的方法。
2）一种可变性不应当与另一种可变性混合在一起。

4.3
里氏代换原则：
任何基类可以出现的地方，子类一定可以出现。

依赖倒转原则：
要依赖于抽象，不要依赖于实现。

合成/聚合复用原则：
要尽量使用合成/聚合，而不是继承关系达到复用的目的。

迪米特法则：
一个软件实体应当与尽可能少的其他实体发生相互作用。

接口隔离原则：
应当为客户端提供尽可能小的单独的接口，而不要提供大的总接口。

4.4
*

4.5
*

4.6
“将条件转移语句改写成为多态性”？
如果一个条件转移语句确实封装了某种商务逻辑的可变性，那么将此种可变性封装起来就符合“开－闭”原则设计思想了。

Thomas 2006-09-10 22:19 发表评论

『蚂蚁学模式』之UML简介

Thomas — Tue, 05 Sep 2006 14:25:00 GMT

第2章统一建模语言UML简介
2.1
不使用标准设计图纸，如何建造出世贸中心？
2.2
UML语言具有以下重要功能：
可视化功能；说明功能（通用的、精确的、没有歧义的）；建造功能（映射）；建文档功能
2.3
UML包括以下的图：
使用案例图、类图、序列图、合作图、状态图、活动图、构件图、部署图
结构型图（静态）：类图、对象图、构件图、部署图
行为型图（动态）：使用案例图、活动图、状态图、时序图、合作图
2.4
描述类的类图
图一
类名；属性清单；方法清单；性质清单
性质是由一个属性即由一个内部变量、一个赋值函数（mutator）和一个取值函数（accessor）组成的结构。
描述接口的类图
图二
描述对象的类图

类图中的关系
一般化关系：表示类与类之间的继承关系，接口与接口之间的继承关系，或类对接口的实现关系。
图三
extends、implements
关联关系：类与类之间的联接，它使一个类知道另一个类的属性和方法。
在Java语言里，关联关系是使用实例变量实现的。
图四
在每一个关联的端点，还可以有一个基数（Multiplicity），表明这一端的类可以有几个实例。
聚合关系：关联关系的一种，是强的关联关系。聚合是整体和个体之间的关系。
图五
合成关系：关联关系的一种，是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分的对象的生命周期。合成关系是不能共享的。
图六
依赖关系：依赖（Dependency）是类与类之间的连接，依赖总是单向的。依赖关系表示一个类依赖于另一个类的定义。
图七
在Java语言中体现为局域变量、方法的参量，以及对静态方法的调用。
2.5
时序图
2.6
状态图
有限状态机

Thomas 2006-09-05 22:25 发表评论

『蚂蚁学模式』之写在开始

Thomas — Sun, 03 Sep 2006 14:10:00 GMT

设计模式，对它，我满是畏惧。在此之前，也零星地阅读过一些相关的资料，终觉参透太难。然而，近来的学习，自己发现许多知识的掌握离不开它们。我需要系统地去学习它们。
手里的《Java与模式》，1000多页的大部头。我不指望通过读某一本书就可以功力倍增。『蚂蚁学模式』这个系列，将是自己学习设计模式过程的一个记录，也是《Java与模式》的读书笔记。放在这里，也是希望它可以成为一种激励，希望自己可以坚持下来。
《Java与模式》，从第12章开始具体讨论各种模式。前面的一些章节，是以后学习的准备。
今天阅读的是第1章。

第1章模式的简史和形而上学
1.1
共同的本质是模式
1.2
GoF
1.3
建筑的永恒之道
质、门、道
1.4
再论无名的质、门、道
1.5
三论无名的质、门、道
无名的质可以理解为软件的“风水”
1.6
模式的要素：
名字；问题；环境或初始环境；力；解答；举例；末态环境；推理；其他有关模式；已知的应用

Thomas 2006-09-03 22:10 发表评论