BlogJava-爪哇一角-文章分类-模式

抽象工厂模式-与-工厂方法模式区别

非洲小白脸 — Tue, 20 Jan 2009 09:34:00 GMT

工厂方法UML图：

抽象工厂UML图：

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
对于java来说，你能见到的大部分抽象工厂模式都是这样的：
它的里面是一堆工厂方法，每个工厂方法返回某种类型的对象。

比如说工厂可以生产鼠标和键盘。那么抽象工厂的实现类（它的某个具体子类）的对象都可以生产鼠标和键盘，但可能工厂A生产的是罗技的键盘和鼠标，工厂B是微软的。

这样A和B就是工厂，对应于抽象工厂；
每个工厂生产的鼠标和键盘就是产品，对应于工厂方法；

用了工厂方法模式，你替换生成键盘的工厂方法，就可以把键盘从罗技换到微软。但是用了抽象工厂模式，你只要换家工厂，就可以同时替换鼠标和键盘一套。如果你要的产品有几十个，当然用抽象工厂模式一次替换全部最方便（这个工厂会替你用相应的工厂方法）

所以说抽象工厂就像工厂，而工厂方法则像是工厂的一种产品生产线
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
“抽象工厂”模式依赖于“工厂方法”模式的。因此，抽象工厂强调的是前面的动词“抽象”，也就是说，你将工厂方法模式中的工厂方法抽象出来的那个"动作或设计"就是“抽象工程”模式了。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
factory method针对的是一个产品等级结构
abstract factory是面向多个产品等级结构的
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。
                              一个抽象工厂类，可以派生出多个具体工厂类。
                              每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
                              一个抽象工厂类，可以派生出多个具体工厂类。
                              每个具体工厂类可以创建多个具体产品类的实例。

区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
      工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
   1.如果一个后花园只种蔬菜类,那么就用简单工厂就可以了.
   2.如果后花园蔬菜品种繁多.得用工厂方法才可以,把共有的东西抽象出来.
   3.如果要扩大后花园的规模,比如一个在北方,一个在南方,这样工厂方法就无法实现了,就应当用抽象工厂,把各种各样的植物,又组成一个后花园.
所以我个人认为,简单工厂是一个工厂只生产一类的产品,面对的是具体的类,工厂方法是可以生产不同的产品,把公共的方法抽象出来,然后进行创建各种各样的产品.抽象工厂把几种产品划出共同的东西,把相互依赖的对象抽象出来,只要实现这些接口就可以得到不同的产品.
具体例子:
1.简单工厂:

using System;
public interface ICar
{
     void run();
}

public class BMWCar : ICar
{
     public void run()
     {
         Console.WriteLine("BMWCar run");
     }
}

public class BenzCar : ICar
{
     public void run()
     {
         Console.WriteLine("BenzCar run");
     }
}

public class Driver
{
     public static ICar DriverCar(string carType)
     {
         switch (carType)
         {
             case "BMWCar": return new BMWCar();
             case "BenzCar": return new BenzCar();
             default: throw new Exception();
        }
     }
}

public class Client
{
     public static void Main()
     {
         ICar myCar = Driver.DriverCar("BenzCar");
         myCar.run();
         Console.Read();
     }
}

心得:优点是只要实现共有的接口就可以实现不同车跑的方式.但缺点就是要判断哪一种车,造成要修改Driver 类
2.工厂方法:

using System;
public interface ICar
{
     void run();
}

public class BMWCar : ICar
{
     public void run()
     {
         Console.WriteLine("BMWCar run");
     }
}

public class BenzCar : ICar
{
     public void run()
     {
         Console.WriteLine("BenzCar run");
     }
}
public abstract class Driver
{
     public abstract ICar DriverCar();
}

public class BMWDriver : Driver
{
     public override ICar   DriverCar()
     {
         return new BMWCar();
     }

}
public class BenzDriver : Driver
{
     public   override ICar DriverCar()
     {
         return new BenzCar();
     }
}

class Client
{
     public static void Main()
     {
         Driver myDriver = new BenzDriver();
         ICar myCar = myDriver.DriverCar();
         myCar.run();
         Console.Read();
     }
}

心得:优点是符合了开放-封闭原则(OCP),从整体上还看不出什么缺点.

3.抽象工厂:

using System;

public interface IBusinessCar
{
     void run();
}

public interface ISportCar
{
void run();
}

public class BMWBusinessCar : IBusinessCar
{
     public void run()
     {
         Console.WriteLine("BMWCar run");
     }

}

public class BenzBusinessCar : IBusinessCar
{
     public void run()
     {
         Console.WriteLine("BenzBusinessCar run");
     }
}

public class BMWSportCar:ISportCar
{
public void run()
{
Console.WriteLine("BMWSportCar run");
}
}

public class BenzSportCar:ISportCar
{
public void run()
{

Console.WriteLine("BenzSportCar run");
}
}

public interface IDriver
{
IBusinessCar BusinessCarDriver();
ISportCar SportCarDriver();
}

public class BMWDriver:IDriver
{
public IBusinessCar BusinessCarDriver()
{
return new BMWBusinessCar();
}
public ISportCar SportCarDriver()
{
return new BMWSportCar();
}
}

public class BenzDriver:IDriver
{
public IBusinessCar BusinessCarDriver()
{
return new BenzBusinessCar();
}

public ISportCar SportCarDriver()
{
return new BenzSportCar();
}
}

class Client
{
     public static void Main()
     {
         IDriver myDriver =new BenzDriver();
         ISportCar myCar = myDriver.SportCarDriver();
         myCar.run();
         Console.Read();
     }

}

心得:抽象方法似乎达到了完美境界.把开奔驰的司机和开宝马的司机的公共方法抽象出来,并对不同的司机创建不同的类,到时候不管是开什么车的司机随你添加.它们唯一的共同点都是开车.

非洲小白脸 2009-01-20 17:34 发表评论

抽象工厂模式

非洲小白脸 — Tue, 20 Jan 2009 09:33:00 GMT

设计模式-快餐简解-【抽象工厂模式】

【抽象工厂模式应用场景举例】
写到抽象工厂模式了，我深知“抽象工厂模式”博文会带来一点点高潮，因为程序员对工厂模式中的“抽象工厂”都是比较感冒的，而且关注也很多，我就尽量用我所能理解的那么点程度来给大家介绍这个模式，如果有更好的比喻还请网友指正，先感谢了！
在设计模式-快餐简解-【工厂方法模式】博文，地址是：
http://www.blogjava.net/ghyghost/archive/2008/11/11/239909.html
介绍了工厂方法的使用，从那个程序中可以看到，奥迪audi车是从audi_car_factory_imple工厂中创建出来的，而大众3W车是从 threeW_car_factory_imple工厂中创建出来的，那么如果这2家汽车生产大厂由总部在北京市，现在发展到上海，深圳等城市创建生气汽车的分厂，该怎么办？是不是得将原来的奥迪汽车工厂类：

public class audi_car_factory_imple implements Icar_factory {

    public Icar_interface create_car() {

        car_audi_imple car_audi_imple_ref = new car_audi_imple();
        car_audi_imple_ref.setName("奥迪A6");
        car_audi_imple_ref.setSpeed(300);

        return car_audi_imple_ref;
    }
}

改成类似如下的模样：

public class audi_car_factory_imple implements Icar_factory {

    public Icar_interface create_car(String area_car) {

if (area_car.equals("北京")){创建一个北京的奥迪汽车}

if (area_car.equals("上海")){创建一个上海的奥迪汽车}

if (area_car.equals("深圳")){创建一个深圳的奥迪汽车}

        return car_audi_imple_ref;
    }
}

那么发现一个问题，不同地域的汽车却在一个工厂中出现，这是不合乎常理的，因为北京奥迪在北京分厂创建，上海奥迪在上海分厂创建，这样才对。

所以如果遇到分“大系”来创建对象的时候，抽象工厂方法是肯定要使用的时候了。这里的大系指的就是从地域上来分。

这个例子就应该以“用抽象工厂来定义具体工厂的抽象，而由具体工厂来创建对象”

比如在玩“极品飞车”这款游戏，每个地图处都有造车的工厂，每个造车的工厂都因为有造车的档次不同而划分为高级车厂，低级车厂，那么这样的场景正是应用抽象工厂的好时机，再来理解一下这句话“用抽象工厂来定义具体工厂的抽象，而由具体工厂来创建对象”，用抽象造车工厂来定义具体造车工厂的抽象，而由具体的造车工厂来创建汽车，这就是抽象工厂与工厂方法的不同，工厂方法中对象的创建是由工厂方法来确定的，创建的对象都是不分类并且实现一个接口的，而抽象工厂就是在工厂方法的基础上对创建车的对象的行为进行分类，比如北京车厂，上海车厂等。

【抽象工厂模式解释】
类型：创建模式
　　提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

【抽象工厂模式UML图】

【抽象工厂模式-JAVA代码实现】
新建抽象工厂接口：

package car_factory_interface;

import car_interface.Icar_interface;

public interface Icar_factory {

public Icar_interface create_threeW_car();

public Icar_interface create_audi_car();

}

新建抽象工厂接口的高级车adv工厂实现类：

package car_factory_imple;

import car_factory_interface.Icar_factory;
import car_imple.car_3w_imple_adv;
import car_imple.car_audi_imple_adv;
import car_interface.Icar_interface;

public class car_factory_adv implements Icar_factory {

    public Icar_interface create_audi_car() {

        car_audi_imple_adv car_audi_imple_adv = new car_audi_imple_adv();
        car_audi_imple_adv.setName("奥迪A6");
        car_audi_imple_adv.setSpeed(300);

        return car_audi_imple_adv;
    }

    public Icar_interface create_threeW_car() {

        car_3w_imple_adv car_3w_imple_adv_ref = new car_3w_imple_adv();
        car_3w_imple_adv_ref.setName("大众A6");
        car_3w_imple_adv_ref.setSpeed(300);

        return car_3w_imple_adv_ref;
    }

}

　　新建抽象工厂接口的普通车low工厂实现类：

package car_factory_imple;

import car_factory_interface.Icar_factory;
import car_imple.car_3w_imple_low;
import car_imple.car_audi_imple_low;
import car_interface.Icar_interface;

public class car_factory_low implements Icar_factory {

    public Icar_interface create_audi_car() {

        car_audi_imple_low car_audi_imple_low_ref = new car_audi_imple_low();
        car_audi_imple_low_ref.setName("奥迪A6");
        car_audi_imple_low_ref.setSpeed(300);

        return car_audi_imple_low_ref;
    }

    public Icar_interface create_threeW_car() {

        car_3w_imple_low car_3w_imple_low_ref = new car_3w_imple_low();
        car_3w_imple_low_ref.setName("大众A6");
        car_3w_imple_low_ref.setSpeed(300);

        return car_3w_imple_low_ref;
    }

}

上面已经有抽象工厂和具体工厂的实现类了。

新建汽车接口：

package car_interface;

public interface Icar_interface {

public void start();

public void stop();

}

新建汽车父类：

package car_imple;

import car_interface.Icar_interface;

public class base_car_imple implements Icar_interface {

    private int speed;

    private String name;

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void start() {
        // TODO Auto-generated method stub

    }

    public void stop() {
        // TODO Auto-generated method stub

    }

}

新建大众高级车：

package car_imple;

import car_interface.Icar_interface;

public class car_3w_imple_adv extends base_car_imple {

    public void start() {
        System.out.println("富华版：" + this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
    }

    public void stop() {
        System.out.println("富华版：" + this.getName() + " 车以专利技术停车了");
    }

}

新建大众普通车：

package car_imple;

import car_interface.Icar_interface;

public class car_3w_imple_low extends base_car_imple {

    public void start() {
        System.out.println("普通版：" + this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
    }

    public void stop() {
        System.out.println("普通版：" + this.getName() + " 车以专利技术停车了");
    }

}

新建奥迪高级车：

package car_imple;

import car_interface.Icar_interface;

public class car_audi_imple_adv extends base_car_imple {

    public void start() {
        System.out.println("富华版：" + this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
    }

    public void stop() {
        System.out.println("富华版：" + this.getName() + " 车以专利技术停车了");
    }

}

新建奥迪普通车：

package car_imple;

import car_interface.Icar_interface;

public class car_audi_imple_low extends base_car_imple {

    public void start() {
        System.out.println("普通版：" + this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
    }

    public void stop() {
        System.out.println("普通版：" + this.getName() + " 车以专利技术停车了");
    }

}

新建客户端运行类：

package run_main;

import car_factory_imple.car_factory_adv;
import car_factory_interface.Icar_factory;
import car_interface.Icar_interface;

public class run_main {

    public static void main(String[] args) {

        Icar_factory Icar_factory_ref = new car_factory_adv();

        Icar_interface Icar_interface_ref = Icar_factory_ref
                .create_threeW_car();
        Icar_interface_ref.start();
        Icar_interface_ref.stop();


    }
}

程序运行结果如下：

富华版：大众A6 车以专利技术起动了　最高速度为：300
富华版：大众A6 车以专利技术停车了

抓一篇阎宏的小文字：

一开始只在后花园中种蔬菜类的时候可以用简单工厂模式，由工厂负责生成具体的蔬菜类，

但是如果后花园要引进水果类的时候简单模式就行不通了，因此需要使用工厂方法模式，将产品类族分开。

但是如果后花园的规模继续扩大到地域范围的分割时，比如说一个在北京，一个在上海的时候，工厂方法模式就不够了，因为对两个后花园来说，每个后花园的植物是要被种在一起的，并且两个后花园用工厂方法模式是无法体现其区别的。

从程序中可以看到，工厂是抽象的，工厂的实现是不样的，不同的工厂创建出不同汽车。而工厂方法仅仅是用一个工厂去创建很多汽车。

非洲小白脸 2009-01-20 17:33 发表评论

观察者模式

非洲小白脸 — Tue, 20 Jan 2009 09:32:00 GMT

设计模式-快餐简解-【观察者模式】

【观察者模式应用场景举例】
比如在玩“极品飞车”这款游戏，每一个车手到达终点的时候，都会在其它车手的屏幕上显示：某某人以多少时间到达终点的提示，其实这就是一个典型的观察者模式的应用，观察者模式即是典型的双向一对多的应用场景下用一的一端来通知多的一端。

【观察者模式解释】
类型：行为模式
　　定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象的状态发生改变时，会通知所有的观察者对象，使它们能够自己更新自己。

【观察者模式UML图】

【观察者模式-JAVA代码实现】
新建抽象发布通知父类：

package carer_subject;

import java.util.ArrayList;
import java.util.List;

import carer_observer.carer_observer;

public interface carer_subject_parent {

    public void set_state(String state_string);

    public String get_state();

    public void add_observer(carer_observer carer_observer_ref);

    public void sub_observer(carer_observer carer_observer_ref);

    public void notityAllCarer();

}

新建发布通知实现类：

package carer_subject;

import java.util.ArrayList;
import java.util.List;

import carer_observer.carer_observer;

public class carer_subject_sub implements carer_subject_parent {

    List<carer_observer> list_observer = new ArrayList<carer_observer>();

    private String state;

    public void set_state(String state_string) {
        this.state = state_string;
    }

    public String get_state() {
        return state;
    }

    public void add_observer(carer_observer carer_observer_ref) {
        list_observer.add(carer_observer_ref);
    }

    public void sub_observer(carer_observer carer_observer_ref) {
        list_observer.remove(carer_observer_ref);

    }

    public void notityAllCarer() {
        state = "到达终点";
        for (int i = 0; i < list_observer.size(); i++) {
            list_observer.get(i).show_info();
        }

    }

}

　　新建观察者接口：

package carer_observer;

import carer_subject.carer_subject_parent;

public interface carer_observer {

public void show_info();

}

新建观察者实现类：

package carer_observer;

import carer_subject.carer_subject_parent;

public class carer_observer_imple implements carer_observer {

    private carer_subject_parent carer_subject_parent_ref;

    public carer_subject_parent getCarer_subject_parent_ref() {
        return carer_subject_parent_ref;
    }

    public void setCarer_subject_parent_ref(
            carer_subject_parent carer_subject_parent_ref) {
        this.carer_subject_parent_ref = carer_subject_parent_ref;
    }

    public carer_observer_imple(carer_subject_parent carer_subject_parent_ref) {
        super();
        this.carer_subject_parent_ref = carer_subject_parent_ref;
    }

    public void show_info() {
        System.out.println(carer_subject_parent_ref.get_state());

    }

}

新建客户端运行类：

package run_main;

import carer_observer.carer_observer_imple;
import carer_subject.carer_subject_parent;
import carer_subject.carer_subject_sub;

public class run_main {

    public static void main(String[] args) {

        carer_subject_parent carer_subject_parent_ref = new carer_subject_sub();

        carer_observer_imple carer_observer_imple_ref1 = new carer_observer_imple(
                carer_subject_parent_ref);
        carer_observer_imple carer_observer_imple_ref2 = new carer_observer_imple(
                carer_subject_parent_ref);
        carer_observer_imple carer_observer_imple_ref3 = new carer_observer_imple(
                carer_subject_parent_ref);
        carer_observer_imple carer_observer_imple_ref4 = new carer_observer_imple(
                carer_subject_parent_ref);

        carer_subject_parent_ref.add_observer(carer_observer_imple_ref1);
        carer_subject_parent_ref.add_observer(carer_observer_imple_ref2);
        carer_subject_parent_ref.add_observer(carer_observer_imple_ref3);
        carer_subject_parent_ref.add_observer(carer_observer_imple_ref4);

        carer_subject_parent_ref.sub_observer(carer_observer_imple_ref3);

        carer_subject_parent_ref.set_state("到达终点");

        carer_subject_parent_ref.notityAllCarer();

    }

}

程序运行结果如下：

到达终点
到达终点
到达终点

以一对多的方式进行对一方状态的改变而去通知多方，观察者模式也叫发布/订阅模式，一方进行发布，而多方进行订阅，和生活中看报纸一样，你喜欢订城市晚报，就会发给你。

非洲小白脸 2009-01-20 17:32 发表评论

外观模式

非洲小白脸 — Tue, 20 Jan 2009 09:31:00 GMT

设计模式-快餐简解-【外观模式】

【外观模式应用场景举例】
比如在玩“极品飞车”这款游戏，你只需要等待的就是倒计时到0时以最快的车速冲到第一名，但游戏者根本没有想过在车冲出去之前要做哪些工作，比如挂档，离合器，油箱检测，调整方向等等的微操作，将这些微操作封装起来变成一个接口就是外观模式了。在WEB开发中的MVC分层架构就是典型的一个外观模式，每一层将操作的具体内容隐藏起来，保留一个接口供上层调用。

【外观模式解释】
类型：结构模式
　　为子系统中的一组接口提供一个一致的interface接口界面。

【外观模式UML图】

【外观模式-JAVA代码实现】
新建赛车类：

package car_package;

public class car {

    public void start() {
        System.out.println("车子已启动");
    }

    public void check_stop() {
        System.out.println("刹车检查");
    }

    public void check_box() {
        System.out.println("检查油箱");
    }

    public void check_console() {
        System.out.println("检查仪表盘是否异常");
    }

}

新建赛车操作的外观类：

package car_facade;

import car_package.car;

public class car_facade_imple {

    public void car_go_go(car car_ref) {
        car_ref.check_box();
        car_ref.check_console();
        car_ref.check_stop();
        car_ref.start();
    }

}

　　新建客户端运行类：

package run_main;

import car_facade.car_facade_imple;
import car_package.car;

public class run_main {

    public static void main(String[] args) {
        car_facade_imple car_facade_imple_ref = new car_facade_imple();
        car_facade_imple_ref.car_go_go(new car());
    }

}

程序运行结果如下：

检查油箱
检查仪表盘是否异常
刹车检查
车子已启动

很简单吧，将子操作用一个外观接口封装起来，然后调用这个接口就是调用那些非常复杂的微操作了。

非洲小白脸 2009-01-20 17:31 发表评论

建造者模式

非洲小白脸 — Tue, 20 Jan 2009 09:31:00 GMT

设计模式-快餐简解-【建造者模式】

【建造者模式应用场景举例】
比如在玩“极品飞车”这款游戏，那么每一关的地图会千变万化，简单的来说，地图会有晴天和阴天之分，那么创建地图时就要根据晴天或者阴天来对地图上的场景，比如：天空，树，房子，和路面进行渲染，这个过程是一个固定的，每创建一个新地图都要执行这几个渲染，这是针对高级配置的电脑来说的。
现在拥有低配置电脑的人不在少数，那么他们就不能玩游戏了吗？完全可以！只要将地图中占用资源比较高的渲染去掉就可以，比如带反射光影的树，这时候需要创建不同的地图，但地图的创建过程却是固定的，建造者模式完全可以应对这样的情况。

【建造者模式解释】
类型：创建模式
　　将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

【建造者模式UML图】

【建造者模式-JAVA代码实现】
新建地图接口：

package map_package;

public interface map_interface {

    public void create_weather();

    public void create_house();

    public void create_tree();

    public void create_way();

}

新建晴天地图类：

package map_package;

public class map_sun implements map_interface {

    public void create_weather() {
        System.out.println("晴天");
    }

    public void create_house() {
        System.out.println("房了上玻璃发亮");
    }

    public void create_tree() {
        System.out.println("树的颜色是浅绿色");
    }

    public void create_way() {
        System.out.println("路面有些干燥");
    }

}

　　新建阴天地图类：

package map_package;

public class map_cloudy implements map_interface{

    public void create_weather() {
        System.out.println("阴天");
    }

    public void create_house() {
        System.out.println("房了上玻璃发暗");
    }

    public void create_tree() {
        System.out.println("树的颜色是深绿色");
    }

    public void create_way() {
        System.out.println("路面有些潮湿");
    }

}

新建高画质builder建造者类：

package map_build;

import map_package.map_interface;

public class map_build_adv {

    private map_interface map_interface_ref;

    public map_build_adv(map_interface map_interface_ref) {
        super();
        this.map_interface_ref = map_interface_ref;
    }

    public void create_map() {
        System.out.println("创建一个高画质的地图");
        // 创建的顺序很重要从天空往路面创建
        map_interface_ref.create_weather();
        map_interface_ref.create_house();
        map_interface_ref.create_tree();
        map_interface_ref.create_way();

    }

}

新建低画质builder建造者类：

package map_build;

import map_package.map_interface;

public class map_build_low {

    private map_interface map_interface_ref;

    public map_build_low(map_interface map_interface_ref) {
        super();
        this.map_interface_ref = map_interface_ref;
    }

    public void create_map() {
        System.out.println("创建一个低画质的地图");
        // 创建的顺序很重要从天空往路面创建
        map_interface_ref.create_weather();
        map_interface_ref.create_house();
        // map_interface_ref.create_tree();将创建树的过程去掉
        map_interface_ref.create_way();

    }

}

新建客户端运行类：

package run_main;

import map_build.map_build_adv;
import map_build.map_build_low;
import map_package.map_cloudy;
import map_package.map_sun;

public class run_main {

    public static void main(String[] args) {

        map_cloudy map_cloudy = new map_cloudy();
        map_build_adv map_build_adv = new map_build_adv(map_cloudy);
        map_build_adv.create_map();

        System.out.println();

        map_sun map_sun = new map_sun();
        map_build_low map_build_low = new map_build_low(map_sun);
        map_build_low.create_map();

    }

}

程序运行结果如下：

创建一个高画质的地图
阴天
房了上玻璃发暗
树的颜色是深绿色
路面有些潮湿

创建一个低画质的地图
晴天
房了上玻璃发亮
路面有些干燥

从程序中可以看到，建造者模式将不变的创建过程进行封装，创建的过程与main分法进行分离，这样内部的创建过程就和表示层的代码进行分开，有利于创建过程功能上的修改。另外可以发现，代码的设计和功能有些类似于facade外观模式，区别在于，建造者模式目的在于以相同的构建过程通过不同的建造者得到不同的结果，而外观模式并不需要不同的建造者，也不希望得到不同的结果，只是简单的将几个接口合并成高级的一个接口，不影响原有的结果，目的是使调用变得更加容易。

　　本程序中有2个建造者：高画者建造者和低画质建造者，它们都封装了创建地图的过程，这个过程很固定，但通过不同的建造者类可以返回不样式的地图，建造者规定了对象创建的过程，比如高画质的建造者的创建过程为：
map_interface_ref.create_weather();
map_interface_ref.create_house();
map_interface_ref.create_tree();
map_interface_ref.create_way();
必须得执行4个方法才可以创建一个高画质的地图，如果不使用建造者模式，直接调用map类的create_xxxx方法，如果create_xxxx 方法有几十个，那么很有可能就把其中的某些方法忘记调用而影响最终地图的效果了，所以我们要使用建造者模式来规定地图创建的过程，这就是一个“行为守则 ”。

非洲小白脸 2009-01-20 17:31 发表评论

模板方法模式

非洲小白脸 — Tue, 20 Jan 2009 09:29:00 GMT

设计模式-快餐简解-【模板方法模式】

【模板方法模式应用场景举例】
比如在玩“极品飞车”这款游戏，每辆车都有显示速度的仪表盘，但有可能A车显示的是蓝色的仪表盘，B车显示的是红色的仪表盘，分析中可以发现，他们都有车速度的值，但显示的方式不太一样。其实模板方法就是最典型的“继承”的使用，大家平时百分百都可以用到，只是不知道叫模板方法模式：）！

【模板方法模式解释】
类型：行为模式
　　模板方法模式定义一个操作中算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

【模板方法模式UML图】

【模板方法模式-JAVA代码实现】
新建赛车的父类：

package car_package;

public class car_parent {

    private int speed;

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public void print_speed() {
        System.out.println("将速度" + this.getSpeed() + "取出来！");

    }

}

新建红色仪表盘的赛车实现类：

package car_imple;

import car_package.car_parent;

public class car_imple_red extends car_parent {

    @Override
    public void print_speed() {
        super.print_speed();
        System.out.println("将速度" + this.getSpeed() + "用红色的仪表盘显示车的速度");
    }

}

新建蓝色仪表盘的赛车实现类：

package car_imple;

import car_package.car_parent;

public class car_imple_blue extends car_parent {

    @Override
    public void print_speed() {
        super.print_speed();
        System.out.println("将速度" + this.getSpeed() + "用蓝色的仪表盘显示车的速度");
    }

}

　　新建客户端运行类：

package run_main;

import car_imple.car_imple_blue;
import car_imple.car_imple_red;
import car_package.car_parent;

public class run_main {

    public static void main(String[] args) {

        car_parent car_ref_red = new car_imple_red();
        car_ref_red.setSpeed(300);
        car_ref_red.print_speed();

        car_parent car_ref_blue = new car_imple_blue();
        car_ref_blue.setSpeed(400);
        car_ref_blue.print_speed();

    }

}

程序运行结果如下：

将速度300取出来！
将速度300用红色的仪表盘显示车的速度
将速度400取出来！
将速度400用蓝色的仪表盘显示车的速度

这就是模板方法模式，一个最常用，最容易理解的一个模式，将相同的功能抽象出来成一个父类，然后用子类做不同功能的实现。

非洲小白脸 2009-01-20 17:29 发表评论

原型模式

非洲小白脸 — Tue, 20 Jan 2009 09:28:00 GMT

设计模式-快餐简解-【原型模式】

【原型模式应用场景举例】
比如在玩“极品飞车”这款游戏，每个游戏者都有自己的账号用来标识玩家，而每个玩家都可以拥有相同的车辆，这样每个玩家都拥有相同的车，比如你的领居有奥迪A6，你的老婆对你说，我也要开和邻居一样的奥迪A6，好了，现在你们家也有奥迪A6了，你们每天开着自己的车去上班，那么在这种情况下就可以应用原型模式了，原型模式很简单哟：）就是类的copy复制。

【原型模式解释】
类型：创建模式
　　用原型实例制定创建对象的种类，并且通过拷贝这些原型创建新的对象。

【原型模式UML图】

【原型模式-JAVA代码实现】
新建赛车的接口：

package car_interface;

public interface car_interface {

public void start();

public void stop();
}

新建奥迪汽车的实现类：

package car_imple;

import car_fittings.car_tyre;
import car_interface.car_interface;

public class audi_imple implements car_interface, Cloneable {

    private car_tyre car_tyre_ref;

    public void start() {
        System.out.println("奥迪A6启动了");

    }

    public void stop() {
        System.out.println("奥迪A6停止了");

    }

    public car_tyre getCar_tyre_ref() {
        return car_tyre_ref;
    }

    public void setCar_tyre_ref(car_tyre car_tyre_ref) {
        this.car_tyre_ref = car_tyre_ref;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        super.clone();
        audi_imple audi_imple = new audi_imple();
        audi_imple.setCar_tyre_ref(new car_tyre());

        return audi_imple;
    }
}

　　在奥迪汽车实现类中需要注意的是将原来protected类型的clone方法要变成public，这样才可以对外公开，可以被调用，将秘密公开化。

新建奥迪汽车的配件轮胎类：

package car_fittings;

public class car_tyre {

    private String name = "德国制造原版轮胎";

    public String getName() {
        return name;
    }

}

　　新建客户端运行类：

package run_main;

import car_fittings.car_tyre;
import car_imple.audi_imple;
import car_interface.car_interface;

public class run_main {

    public static void main(String[] args) {

        try {
            audi_imple car_ref_my = new audi_imple();
            car_ref_my.setCar_tyre_ref(new car_tyre());
            System.out.println("我的奥迪车的参数是：" + car_ref_my);
            System.out.println("我的奥迪车的轮胎参数是：" + car_ref_my.getCar_tyre_ref());

            audi_imple car_ref_other = (audi_imple) car_ref_my.clone();
            System.out.println("其它人的奥迪车的参数是：" + car_ref_other);
            System.out.println("其它人的奥迪车的轮胎参数是："
                    + car_ref_other.getCar_tyre_ref());

        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

程序运行结果如下：

我的奥迪车的参数是：car_imple.audi_imple@9cab16
我的奥迪车的轮胎参数是：car_fittings.car_tyre@1a46e30
其它人的奥迪车的参数是：car_imple.audi_imple@3e25a5
其它人的奥迪车的轮胎参数是：car_fittings.car_tyre@19821f

从打印的结果来看，我的汽车我的轮胎和其它人的汽车和轮胎都是不一样的对象，但“类型”都是一样的：奥迪的汽车，原版的轮胎。本例中也实现了“原型模式”中的“深拷贝/深复制”，即汽车类中有一个对象“轮胎”对象，关于深拷贝/深复制的概念请参考其它的资料。原型模式通常都是在复制对象的时候使用，而在常规的情况下都是使用new重新创建一个，并且重新对属性进行复制，代码重复度很高，原型模式的出现避免了new的硬操作。

非洲小白脸 2009-01-20 17:28 发表评论

装饰模式

非洲小白脸 — Tue, 20 Jan 2009 09:27:00 GMT

【装饰模式应用场景举例】
比如在玩“极品飞车”这款游戏，游戏中有对汽车进行喷涂鸦的功能，而且这个喷涂鸦是可以覆盖的，并且覆盖的顺序也影响到最后车身的显示效果，假设现在喷涂鸦具有2种样式：
（1）红色火焰　（2）紫色霞光
如果使用“继承父类”设计这样的功能，那么类图就像如下的这样：

从图中可以看到使用继承来实现这种功能，并且是2种涂鸦样式，就需要创建4个子类，如果喷涂鸦有3种，4种呢？这种情况就是典型中学课程学习过的“排列与组合”，那简直就是“Head First设计模式”书中讲的“类爆炸”。
显然继承“奥迪汽车类”的这个办法是无效，而且是非常徒劳，繁琐的。
那么如何才能以“灵活”，“顺序敏感”这样的需求来实现这样的功能呢？

【装饰模式解释】
类型：结构模式
　　动态的对一个对象进行功能上的扩展，也可以对其子类进行功能上的扩展。

【装饰模式UML图】

【装饰模式-JAVA代码实现】
新建一个抽象汽车父类：

package car_package;

public abstract class car_parent {
    // 汽车抽象父类
    private String make_address;
    private int speed;

    public String getMake_address() {
        return make_address;
    }

    public void setMake_address(String make_address) {
        this.make_address = make_address;
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public abstract void print_face();

}

然后新建一个奥迪汽车子类：

package car_package;

public class audi_sub extends car_parent {
    // 奥迪汽车子类

    @Override
    public void print_face() {
        System.out.println("audi车默认的颜色为　黑色");
    }

}

然后再新建一个装饰者父类：

package decorator_package;

import car_package.car_parent;

public abstract class decorator_parent extends car_parent {
    // 装饰者父类

    protected car_parent car_parent_ref;

    public void setCar_parent_ref(car_parent car_parent_ref) {
        this.car_parent_ref = car_parent_ref;
    }

    @Override
    public void print_face() {
        car_parent_ref.print_face();
    }

}

然后再新建装饰者子类：红色火焰装饰者类：

package decorator_package;

public class decorator_audi_red extends decorator_parent {

    @Override
    public void print_face() {
        super.print_face();
        System.out.println("给　奥迪　喷涂鸦　-　颜色为　红色火焰");
    }

}

然后再新建装饰者子类：紫色霞光装饰者类：

package decorator_package;

public class decorator_audi_purple extends decorator_parent {

    @Override
    public void print_face() {
        super.print_face();
        System.out.println("给　奥迪　喷涂鸦　-　颜色为　紫色霞光");
    }

}

新建一个运行类：

package main_run;

import car_package.audi_sub;
import decorator_package.decorator_audi_purple;
import decorator_package.decorator_audi_red;

public class main_run {

    public static void main(String[] args) {

        audi_sub audi_sub_ref = new audi_sub();
        audi_sub_ref.setMake_address("北京市朝阳区");
        audi_sub_ref.setSpeed(200);

        decorator_audi_red decorator_audi_red_ref = new decorator_audi_red();
        decorator_audi_red_ref.setCar_parent_ref(audi_sub_ref);

        decorator_audi_purple decorator_audi_purple_ref = new decorator_audi_purple();
        decorator_audi_purple_ref.setCar_parent_ref(decorator_audi_red_ref);

        decorator_audi_purple_ref.print_face();

    }
}

程序运行结果如下：

audi车默认的颜色为　黑色
给　奥迪　喷涂鸦　-　颜色为　红色火焰
给　奥迪　喷涂鸦　-　颜色为　紫色霞光

从程序结构中可以看到，完全符合了前面我们的要求：“灵活”，“顺序敏感”。

非洲小白脸 2009-01-20 17:27 发表评论

策略模式

非洲小白脸 — Tue, 20 Jan 2009 09:27:00 GMT

设计模式-快餐简解-【策略模式】

【策略模式应用场景举例】
比如在玩“极品飞车”这款游戏，那么游戏对车的轮胎是可以更换的，不同的轮胎在高速转弯时有不同的痕迹样式，那么针对“汽车”的配件“轮胎”就要可以变化，而且轮胎和轮胎之间是可以相互替换的，这就是典型的要应用“策略模式”的场景！

【策略模式解释】
类型：行为模式
　　定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。策略模式使这些算法在客户端调用它们的时候能够互不影响地变化。

【策略模式UML图】

【策略模式-JAVA代码实现】
从策略模式UML图中可以看到Context与接口Strategy是组合关系，即强引用关系。

新建一个轮胎接口：

package strategy_interface;

public interface tyre_interface {

// tyre 轮胎
public void print_tyre_line();// 显示出轮胎的痕迹

}

新建2个轮胎接口的实现类：

package strategy_implement;

import strategy_interface.tyre_interface;

//长痕迹轮胎类
public class tyre_long_implement implements tyre_interface {

    public void print_tyre_line() {
        System.out.println("在路面上显示一个长轮胎痕迹");
    }

}

package strategy_implement;

import strategy_interface.tyre_interface;

//短痕迹轮胎类
public class tyre_short_implement implements tyre_interface {

    public void print_tyre_line() {
        System.out.println("在路面上显示一个短轮胎痕迹");
    }

}

基于一个轮胎接口来实现不同样式的轮胎样式。

组装一个Car车类：

package car_package;

import strategy_interface.tyre_interface;

public class Car {

    private String make_address;// 制造地
    private int death_year;// 报废年限
    private int speed;// 速度
    private tyre_interface tyre_interface_ref;// 轮胎的样式

    public String getMake_address() {
        return make_address;
    }

    public void setMake_address(String make_address) {
        this.make_address = make_address;
    }

    public int getDeath_year() {
        return death_year;
    }

    public void setDeath_year(int death_year) {
        this.death_year = death_year;
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public tyre_interface getTyre_interface_ref() {
        return tyre_interface_ref;
    }

    public void setTyre_interface_ref(tyre_interface tyre_interface_ref) {
        this.tyre_interface_ref = tyre_interface_ref;
    }

    public void start() {

        System.out.println("车的基本信息为：");
        System.out.println("制造地make_address：" + this.getMake_address());
        System.out.println("报废年限death_year：" + this.getDeath_year());
        System.out.println("速度speed：" + this.getSpeed());

        System.out.println("Car 起动了！");

        System.out.println("Car高速行驶，遇到一个大转弯，路面显示：");
        this.getTyre_interface_ref().print_tyre_line();

    }
}

让车跑起来，并且具有更换轮胎样式的功能：

package main_run;

import strategy_implement.tyre_long_implement;
import strategy_implement.tyre_short_implement;
import car_package.Car;

public class run_main {

    public static void main(String[] args) {

        tyre_long_implement tyre_long_implement = new tyre_long_implement();
        tyre_short_implement tyre_short_implement = new tyre_short_implement();
        Car car = new Car();
        car.setDeath_year(8);
        car.setMake_address("北京朝阳区");
        car.setSpeed(200);
        car.setTyre_interface_ref(tyre_long_implement);
        car.start();

    }
}

控制台打印出：

车的基本信息为：
制造地make_address：北京朝阳区
报废年限death_year：8
速度speed：200
Car 起动了！
Car高速行驶，遇到一个大转弯，路面显示：
在路面上显示一个长轮胎痕迹

是一个长轮胎痕迹，但在程序中可以使用代码：car.setTyre_interface_ref(tyre_long_implement);来对轮胎的样式进行不同的替换，可以替换成短轮胎痕迹的汽车轮胎，这样在不更改Car类的前题下进行了不同轮胎样式的改变，轮胎和轮胎之间可以互相替换，这就是策略模式。

非洲小白脸 2009-01-20 17:27 发表评论

代理模式

非洲小白脸 — Tue, 20 Jan 2009 09:26:00 GMT

【代理模式应用场景举例】
比如在玩“极品飞车”这款游戏，如果游戏者手中的金钱达到了一定的数量就可以到车店买一部性能更高的赛车，那么这个卖车的“车店”就是一个典型的“汽车厂家”的“代理”，他为汽车厂家“提供卖车的服务”给有需求的人士。从面向对象的方面考虑，“销售汽车的代理”也是一个对象，那么这个对象也具有一定的状态，在软件项目中这个对象也具有管理财务进销存的基本功能，那么在设计时就要以面向OOP编程的思想来考虑软件的类结构，这个销售汽车的代理也是一个类了。

【代理模式解释】
类型：结构模式
　　对一些对象提供代理，以限制那些对象去访问其它对象。

【代理模式UML图】

【代理模式-JAVA代码实现】
新建一个买车的接口：

package buy_car_package;

public interface buy_car_package {

public void buy_car();
}

新建一个people人类，具有买车的行为，所以实现接口buy_car_package：

package buy_car_imple;

import buy_car_package.buy_car_package;

public class people implements buy_car_package {

    private int cash;
    private String username;

    public int getCash() {
        return cash;
    }

    public void setCash(int cash) {
        this.cash = cash;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void buy_car() {
        System.out.println(username + "买了一台新车");
    }

}

people类不能拥有车，必须经过proxy代理类的认证，符合条件之后才可以拥有车辆，新建一个代理，这个代理类来考察当前的people是否有资格进行买车：

package buy_car_imple;

import buy_car_package.buy_car_package;

public class proxy_buy_car_imple implements buy_car_package {

    private people people;

    public people getPeople() {
        return people;
    }

    public void setPeople(people people) {
        this.people = people;
    }

    public void buy_car() {
        if (people.getCash() > 3000) {
            System.out.print("汽车商店帮：");
            people.buy_car();
        } else {
            System.out.println(people.getUsername() + "金钱不够，请继续比赛!");
        }
    }

}

最后创建一个客户端，用来模拟买车的行为：

package run_main;

import buy_car_imple.people;
import buy_car_imple.proxy_buy_car_imple;

public class run_main {
    public static void main(String[] args) {
        people people_ref1 = new people();
        people_ref1.setCash(4000);
        people_ref1.setUsername("高洪岩");

        people people_ref2 = new people();
        people_ref2.setCash(2000);
        people_ref2.setUsername("岩洪高");

        proxy_buy_car_imple proxy_buy_car_imple = new proxy_buy_car_imple();
        proxy_buy_car_imple.setPeople(people_ref1);
        proxy_buy_car_imple.buy_car();

        proxy_buy_car_imple.setPeople(people_ref2);
        proxy_buy_car_imple.buy_car();

    }
}

程序运行结果如下：

高洪岩花4000块　买了新车　交易结束
岩洪高金钱不够，请继续比赛!

这样people就不可能自由的拥有车辆，必须经过proxy的认证之后才可以。
而代理模式在GOF四人帮的介绍中大体有4种使用情景：
（1）远程代理。典型的就是客户端与webservice使用的情况，客户端由于是针对OOP编程，而不是针对webservice中的方法进行编程，所以得在客户端模拟一下webservice的环境，用proxy来对webservice进行包装，这样就可以使用proxy代理类来远程操作 webservice了。
（2）虚拟代理。比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。
（3）安全代理。其实也就是本例中所举的买车的例子，金钱不够不可以买车！
（4）智能指引。比如在访问一个对象时检测其是否被锁定等情况。

非洲小白脸 2009-01-20 17:26 发表评论

工厂方法模式

非洲小白脸 — Tue, 20 Jan 2009 09:24:00 GMT

【工厂方法模式应用场景举例】
比如在玩“极品飞车”这款游戏，晕了吧，我喜欢极品飞车：），在玩这款游戏时，游戏者可以选择从不同品牌来选择赛车，那么这个“品牌”其实也就是工厂，每个工厂生产的赛车都不一样，这就是典型的工厂方法的应用场景。

【工厂方法模式解释】
类型：创建模式
　　定义一个用于创建对象的接口，让其子类来决定实例化哪一个类（产品），工厂方法使一个类的创建延迟到其子类中。

【工厂方法模式UML图】

【工厂方法模式-JAVA代码实现】
新建赛车的接口：

package car_interface;

public interface Icar_interface {

public void start();

public void stop();

}

新建1个汽车信息的基类：

新建奥迪汽车实现类：

package car_imple;

import car_interface.Icar_interface;

public class car_audi_imple extends base_car_imple {

    public void start() {
        System.out.println(this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
    }

    public void stop() {
        System.out.println(this.getName() + " 车以专利技术停车了");
    }

}

新建大众汽车实现类：

package car_imple;

import car_interface.Icar_interface;

public class car_3w_imple extends base_car_imple {

    public void start() {
        System.out.println(this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
    }

    public void stop() {
        System.out.println(this.getName() + " 车以专利技术停车了");
    }

}

新建一个汽车工厂接口：

package car_factory_interface;

import car_interface.Icar_interface;

public interface Icar_factory {

public Icar_interface create_car();

}

新建一个创建奥迪车的汽车工厂实现类：

package car_factory_imple;

import car_factory_interface.Icar_factory;
import car_imple.car_audi_imple;
import car_interface.Icar_interface;

public class audi_car_factory_imple implements Icar_factory {

    public Icar_interface create_car() {

        car_audi_imple car_audi_imple_ref = new car_audi_imple();
        car_audi_imple_ref.setName("奥迪A6");
        car_audi_imple_ref.setSpeed(300);

        return car_audi_imple_ref;
    }
}

新建一个创建大众车的汽车工厂实现类：

package car_factory_imple;

import car_factory_interface.Icar_factory;
import car_imple.car_3w_imple;
import car_imple.car_audi_imple;
import car_interface.Icar_interface;

public class threeW_car_factory_imple implements Icar_factory {

    public Icar_interface create_car() {

        car_3w_imple car_3w_imple_ref = new car_3w_imple();
        car_3w_imple_ref.setName("大众A6");
        car_3w_imple_ref.setSpeed(400);

        return car_3w_imple_ref;

    }

}

客户端运行程序代码：

package run_main;

import car_factory_imple.audi_car_factory_imple;
import car_factory_interface.Icar_factory;
import car_interface.Icar_interface;

public class run_main {

    public static void main(String[] args) {

        Icar_factory car_factory = new audi_car_factory_imple();
        Icar_interface car_ref = car_factory.create_car();
        car_ref.start();
        car_ref.stop();

    }

}

程序运行结果如下：

奥迪A6 车以专利技术起动了　最高速度为：300
奥迪A6 车以专利技术停车了

通过使用工厂方法模式就可以将对象的创建延迟到子类进行实例化，而且每个工厂创建不同的品牌的汽车，每个汽车的功能都有自己“专利”的实现，这样可以将不同“品牌”的“汽车”的创建进行分类，有利于对象创建的清晰性。创建不同的汽车只需要改动这句代码就可以了：
Icar_factory car_factory = new audi_car_factory_imple();

非洲小白脸 2009-01-20 17:24 发表评论