亚洲国产小视频精品久久久三级 ,国产精品亚洲аv无码播放,亚洲福利视频网站

抽象工厂模式-�?工厂�Ҏ��模式区别

Tue, 20 Jan 2009 09:34:00 GMT

工厂�Ҏ��UML图：

抽象工厂UML图：

�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br /> 对于java来说�Q�你能见到的大部分抽象工厂模式都是这��L��Q?
它的里面是一堆工厂方法，每个工厂�Ҏ��q�回某种�c�d��的对象�?

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

�q�样A和B��是工厂�Q�对应于抽象工厂�Q?
每个工厂生��的鼠标和键盘��是产品�Q�对应于工厂�Ҏ��Q?

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

所以说抽象工厂��像工厂�Q�而工厂方法则像是工厂的一�U��品生产线
�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br /> “抽象工厂”模式依赖�?#8220;工厂�Ҏ��”模式的。因此，抽象工厂��的是前面的动�?#8220;抽象”�Q�也��是��_��你将工厂�Ҏ��模式中的工厂�Ҏ��抽象出来的那�?动作或设�?��是“抽象工程”模式了�?br /> �Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br /> factory method针对的是一个��品等�U�结�?nbsp;
abstract factory是面向多个��品等�U�结构的
�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br /> 工厂�Ҏ��模式�Q�一个抽象��品类�Q�可以派生出多个具体产品�c�R�?nbsp;
                              一个抽象工厂类�Q�可以派生出多个具体工厂�c�R�?nbsp;
                              每个具体工厂�c�d��能创��Z��个具体��品类的实例�?nbsp;
抽象工厂模式�Q�多个抽象��品类�Q�每个抽象��品类可以�z��出多个具体��品类�?nbsp;
                              一个抽象工厂类�Q�可以派生出多个具体工厂�c�R�?nbsp;
                              每个具体工厂�c�d��以创建多个具体��品类的实例�?nbsp;

区别�Q�工厂方法模式只有一个抽象��品类�Q�而抽象工厂模式有多个�?br />       工厂�Ҏ��模式的具体工厂类只能创徏一个具体��品类的实例，而抽象工厂模式可以创建多个�?br /> �Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br />    1.如果一个后花园只种蔬菜�c?那么��q��单工厂就可以�?
   2.如果后花园蔬菜品�U�繁�?得用工厂�Ҏ��才可�?把共有的东西抽象出来.
   3.如果要扩大后花园的规�?比如一个在北方,一个在南方,�q�样工厂�Ҏ��无法实��C��,��应当用抽象工厂,把各�U�各��L��植物,又组成一个后花园.
所以我个�h认�ؓ,��单工厂是一个工厂只生��一�cȝ��产品,面对的是具体的类,工厂�Ҏ��是可以生产不同的产品,把公��q��Ҏ��抽象出来,然后�q�行创徏各种各样的��?抽象工厂把几�U��品划出共同的东西,把相互依赖的对象抽象出来,只要实现�q�些接口��可以得��C��同的产品.
具体例子:
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();
     }
}

心得:优点是只要实现共有的接口��可以实��C��同�R跑的方式.但缺点就是要判断哪一�U��R,造成要修改Driver �c?br /> 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),从整体上�q�看不出什么缺�?

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();
     }

}

心得:抽象�Ҏ��g��辑ֈ�了完��境�?把开奔驰的司机和开宝马的司机的公共�Ҏ��抽象出来,�q�对不同的司机创��Z��同的�c?到时候不��是开什么�R的司机随你添�?它们唯一的共同点都是开�?

非洲��白�?/a> 2009-01-20 17:34 发表评论

抽象工厂模式

Tue, 20 Jan 2009 09:33:00 GMT

设计模式-快餐��?【抽象工厂模式�?/strong>

�?strong>抽象工厂模式应用场景举例�?br /> 写到抽象工厂模式了，我深�?#8220;抽象工厂模式”博文会带来一点点高潮�Q�因为程序员对工厂模式中�?#8220;抽象工厂”都是比较感冒的，而且��x��也很多，我就��量用我所能理解的那么点程度来�l�大家介�l�这个模式，如果有更好的比喻�q�请�|�友指正�Q�先感谢了！
在设计模�?快餐��?【工厂方法模式】博文，地址是：
http://www.tkk7.com/ghyghost/archive/2008/11/11/239909.html
介绍了工厂方法的使用�Q�从那个�E�序中可以看刎ͼ�奥��_audi车是从audi_car_factory_imple工厂中创建出来的�Q�而大�?W车是�? threeW_car_factory_imple工厂中创建出来的�Q�那么如果这2家汽车生产大厂由总部在北京市�Q�现在发展到上�v�Q�深圳等城市创徏生气�? 车的分厂�Q�该怎么办？是不是得��原来的奥��_汽�R工厂�c�：

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;
    }
}

�Ҏ��c�M��如下的模��P��

public class audi_car_factory_imple implements Icar_factory {

    public Icar_interface create_car(String area_car) {

if (area_car.equals("北京")){创徏一个北京的奥��_汽�R}

if (area_car.equals("上�v")){创徏一个上��L��奥��_汽�R}

if (area_car.equals("深圳")){创徏一个深圳的奥��_汽�R}

        return car_audi_imple_ref;
    }
}

那么发现一个问题，不同地域的汽车却在一个工厂中出现�Q�这是不合乎常理的，因�ؓ北京奥��_在北京分厂创建，上�v奥��_在上��分厂创建，�q�样才对�?br />
所以如果遇到分“大系”来创建对象的时候，抽象工厂�Ҏ��是肯定要使用的时候了。这里的大系指的��是从地域上来分�?br />
�q�个例子��应该以“用抽象工厂来定义具体工厂的抽象，而由具体工厂来创建对�?#8221;

比如在玩“极品飞�R”�q�款游戏�Q�每个地囑֤�都有造�R的工厂，每个造�R的工厂都因�ؓ有造�R的档�ơ不同而划分�ؓ高��车厂�Q�低�U��R厂，那么�q�样的场景正是应用抽象工厂的好时机，再来理解一下这句话“用抽象工厂来定义具体工厂的抽象，而由具体工厂来创建对�?#8221;�Q�用抽象造�R工厂来定义具体造�R工厂的抽象，而由�? 体的造�R工厂来创建汽车，�q�就是抽象工厂与工厂�Ҏ��的不同，工厂�Ҏ��中对象的创徏是由工厂�Ҏ��来确定的�Q�创建的对象都是不分�c�dƈ且实��C��个接口的�Q�而抽�? 工厂��是在工厂方法的基础上对创徏车的对象的行��行分�c�，比如北京车厂�Q�上��R厂等�?br />
�?strong>抽象工厂模式解释�?br /> �c�d��Q�创建模�?br /> 　　提供一个创��Z��p�d��相关或相互依赖对象的接口�Q�而无需指定他们具体的类�?br />
�?strong>抽象工厂模式UML�?/strong>�?br />

�?strong>抽象工厂模式-JAVA代码实现�?br /> 新徏抽象工厂接口�Q?/p>

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();

}

新徏抽象工厂接口的高�U��Radv工厂实现�c�：

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;
    }

}

　　新徏抽象工厂接口的普通�Rlow工厂实现�c�：

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;
    }

}

上面已经有抽象工厂和具体工厂的实现类了�?br />
新徏汽�R接口�Q?/p>

package car_interface;

public interface Icar_interface {

public void start();

public void stop();

}

新徏汽�R父类�Q?/p>

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() + " 车以专利技术�v动了　最高速度为："
                + this.getSpeed());
    }

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

}

新徏大众普通�R�Q?/p>

package car_imple;

import car_interface.Icar_interface;

public class car_3w_imple_low extends base_car_imple {

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

    public void stop() {
        System.out.println("普通版�Q?/span>" + 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() + " 车以专利技术�v动了　最高速度为："
                + this.getSpeed());
    }

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

}

新徏奥��_普通�R�Q?/p>

package car_imple;

import car_interface.Icar_interface;

public class car_audi_imple_low extends base_car_imple {

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

    public void stop() {
        System.out.println("普通版�Q?/span>" + this.getName() + " 车以专利技术停车了");
    }

}

新徏客户端运行类�Q?/p>

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();


    }
}

�E�序�q�行�l�果如下�Q?/p>

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

抓一��阎宏的��文字：

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

但是如果后花园要引进水果�cȝ��时候简单模式就行不通了�Q�因此需要��用工厂方法模式，��品类族分开�?br />
但是如果后花园的规模�l�箋扩大到地域范围的分割�Ӟ��比如说一个在北京�Q�一个在上�v的时候，工厂�Ҏ��模式��׃��够了�Q�因为对两个后花园来��_��每个后花园的植物是要被种在一��L��Q��ƈ且两个后花园用工厂方法模式是无法体现其区别的�?/span>

从程序中可以看到�Q�工厂是抽象的，工厂的实现是不样的，不同的工厂创建出不同汽�R。而工厂方法仅仅是用一个工厂去创徏很多汽�R�?br />

非洲��白�?/a> 2009-01-20 17:33 发表评论

Tue, 20 Jan 2009 09:32:00 GMT

设计模式-快餐��?【观察者模式�?/strong>

�?strong>观察者模式应用场景�D�?/strong>�?br /> 比如在玩“极品飞�R”�q�款游戏�Q�每一个�R手到辄��点的时候，都会在其它�R手的屏幕上显�C�：某某��Z��多少旉��到达�l�点的提�C�，其实�q�就是一个典型的观察者模式的应用�Q�观察者模式即是典型的双向一对多的应用场景下用一的一端来通知多的一端�?br />
�?strong>观察�?/strong>模式解释�?br /> �c�d��Q�行为模�?br /> 　　定义了一�U�一对多的依赖关�p�，让多个观察者对象同时监听某一个主题对象。这个主题对象的状态发生改变时�Q�会通知所有的观察者对象，使它们能够自己更新自己�?br />
�?strong>观察�?/strong>模式UML�?/strong>�?br />

�?strong>观察�?/strong>模式-JAVA代码实现�?br /> 新徏抽象发布通知父类�Q?
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();

}

新徏发布通知实现�c�：

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 = "到达�l�点";
        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();

}

新徏观察者实现类�Q?/p>
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());

    }

}

新徏客户端运行类�Q?/p>
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("到达�l�点");

        carer_subject_parent_ref.notityAllCarer();

    }

}

�E�序�q�行�l�果如下�Q?/p>
到达�l�点
到达�l�点
到达�l�点

以一对多的方式进行对一方状态的改变而去通知多方�Q�观察者模式也叫发�?订阅模式�Q�一方进行发布，而多方进行订阅，和生�z�M��看报�U怸��P��你喜�Ƣ订城市晚报�Q�就会发�l�你�?

非洲��白�?/a> 2009-01-20 17:32 发表评论

外观模式

Tue, 20 Jan 2009 09:31:00 GMT
设计模式-快餐��?【外观模式�?/strong>

�?strong>外观模式应用场景举例�?br /> 比如在玩“极品飞�R”�q�款游戏�Q�你只需要等待的��是倒计时到0时以最快的车速冲到第一名，但游戏者根本没有想�q�在车冲出去之前要做哪些工作�Q�比如挂档，��d��器，油箱��，调整方向�{�等的微操作�Q�将�q�些微操作封装�v来变成一个接口就是外观模式了。在WEB开发中的MVC分层架构��是典型的一个外观模式，每一层将操作的具体内定w��藏�v来，保留一个接口供上层调用�?br />
�?strong>外观模式解释�?br /> �c�d��Q�结构模�?br /> 　　为子�pȝ��中的一�l�接口提供一个一致的interface接口界面�?br />
�?strong>外观模式UML�?/strong>�?br />

�?strong>外观模式-JAVA代码实现�?br /> 新徏赛�R�c�：

package car_package;

public class car {

    public void start() {
        System.out.println("车子已启�?/span>");
    }

    public void check_stop() {
        System.out.println("刹�R��?/span>");
    }

    public void check_box() {
        System.out.println("��查��a��?/span>");
    }

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

}

新徏赛�R操作的外观类�Q?/p>

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();
    }

}

　　新徏客户端运行类�Q?/p>

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());
    }

}

�E�序�q�行�l�果如下�Q?/p>

��查��a��?br /> ��查��A表盘是否异常
刹�R��?br /> 车子已启�?/span>

很简单吧�Q�将子操作用一个外观接口封装�v来，然后调用�q�个接口��是调用那些非常复杂的微操作了�?br />

非洲��白�?/a> 2009-01-20 17:31 发表评论

Tue, 20 Jan 2009 09:31:00 GMT

设计模式-快餐��?【徏造者模式�?/strong>

�?strong>建造者模式应用场景�D�?/strong>�?br /> 比如在玩“极品飞�R”�q�款游戏�Q�那么每一关的地图会千变万化，��单的来说�Q�地图会有晴天和阴天之分�Q�那么创建地图时��p��Ҏ��晴天或者阴天来对地图上�? 场景�Q�比如：天空�Q�树�Q�房子，和�\面进行渲染，�q�个�q�程是一个固定的�Q�每创徏一个新地图都要执行�q�几个渲染，�q�是针对高��配置的电脑来说的�?br /> 现在拥有低配�|�电脑的��Z��在少敎ͼ�那么他们��׃��能玩游戏了吗�Q�完全可以！只要��地图中占用资源比较高的渲染��L��可以，比如带反��光��q��树，�q�时候需要创��Z��同的地图�Q�但地图的创��E�却是固定的�Q�徏造者模式完全可以应对这��L��情况�?br />
�?strong>建造�?/strong>模式解释�?br /> �c�d��Q�创建模�?br /> 　　��一个复杂对象的构徏与它的表�C�分��，使得同样的构��E�可以创��Z��同的表示�?br />
�?strong>建造�?/strong>模式UML�?/strong>�?br />

�?strong>建造�?/strong>模式-JAVA代码实现�?br /> 新徏地图接口�Q?
package map_package;

public interface map_interface {

    public void create_weather();

    public void create_house();

    public void create_tree();

    public void create_way();

}

新徏晴天地图�c�：

package map_package;

public class map_sun implements map_interface {

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

    public void create_house() {
        System.out.println("房了上玻璃发�?/span>");
    }

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

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

}

　　新徏阴天地图�c�：

package map_package;

public class map_cloudy implements map_interface{

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

    public void create_house() {
        System.out.println("房了上玻璃发�?/span>");
    }

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

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

}

新徏高画质builder建造者类�Q?/p>
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("创徏一个高画质的地�?/span>");
        // 创徏的顺序很重要从天�I�往路面创徏
        map_interface_ref.create_weather();
        map_interface_ref.create_house();
        map_interface_ref.create_tree();
        map_interface_ref.create_way();

    }

}

新徏低画质builder建造者类�Q?/p>
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("创徏一个低画质的地�?/span>");
        // 创徏的顺序很重要从天�I�往路面创徏
        map_interface_ref.create_weather();
        map_interface_ref.create_house();
        // map_interface_ref.create_tree();��创建树的过�E�去�?/span>
        map_interface_ref.create_way();

    }

}

新徏客户端运行类�Q?/p>
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();

    }

}

�E�序�q�行�l�果如下�Q?/p>
创徏一个高画质的地�?br /> 阴天
房了上玻璃发�?br /> 树的颜色是深�l�色
路面有些潮湿

创徏一个低画质的地�?br /> 晴天
房了上玻璃发�?br /> 路面有些�q�燥

从程序中可以看到�Q�徏造者模式将不变的创��E�进行封装，创徏的过�E�与main分法�q�行分离�Q�这样内部的创徏�q�程��和表示层的代码�q�行分开�Q�有利于�? ��E�功能上的修攏V��另外可以发玎ͼ�代码的设计和功能有些�c�M��于facade外观模式�Q�区别在于，建造者模式目的在于以相同的构��E�通过不同的徏造者得 ��C��同的�l�果�Q�而外观模式�ƈ不需要不同的建造者，也不希望得到不同的结果，只是��单的��几个接口合�q�成高��的一个接口，不媄响原有的�l�果�Q�目的是使调用变得更加容易�?/p>
　　本程序中�?个徏造者：高画者徏造者和低画质徏造者，它们都封装了创徏地图的过�E�，�q�个�q�程很固定，但通过不同的徏造者类可以�q�回不样式的地图�Q�徏造者规定了对象创徏的过�E�，比如高画质的建造者的创徏�q�程为：
map_interface_ref.create_weather();
map_interface_ref.create_house();
map_interface_ref.create_tree();
map_interface_ref.create_way();
必须得执�?个方法才可以创徏一个高画质的地图，如果不��用徏造者模式，直接调用map�cȝ��create_xxxx�Ҏ��Q�如果create_xxxx �Ҏ��有几十个�Q�那么很有可能就把其中的某些�Ҏ��忘记调用而媄响最�l�地囄��效果了，所以我们要使用建造者模式来规定地图创徏的过�E�，�q�就是一�?#8220;行�ؓ守则 ”�?/p>

非洲��白�?/a> 2009-01-20 17:31 发表评论

模板�Ҏ��模式

Tue, 20 Jan 2009 09:29:00 GMT
设计模式-快餐��?【模板方法模式�?/strong>

�?strong>模板�Ҏ��模式应用场景举例�?br /> 比如在玩“极品飞�R”�q�款游戏�Q�每辆�R都有昄��速度的��A表盘�Q�但有可能A车显�C�的是蓝色的仪表盘，B车显�C�的是红色的仪表盘，分析中可以发玎ͼ�他们�? 有�R速度的��|��但显�C�的方式不太一栗��其实模板方法就是最典型�?#8220;�l�承”的��用，大家�q�x��癑ֈ��N��可以用到�Q�只是不知道叫模板方法模式：�Q�！

�?strong>模板�Ҏ��模式解释�?br /> �c�d��Q�行为模�?br /> 　　模板�Ҏ��模式定义一个操作中��法的骨�Ӟ��而将一些步骤�g�q�到子类中，使得子类可以不改变一个算法的�l�构卛_��重定义该��法的某些特定步骤�?br />
�?strong>模板�Ҏ��模式UML�?/strong>�?br />

�?strong>模板�Ҏ��模式-JAVA代码实现�?br /> 新徏赛�R的父�c�：

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() + "取出来！");

    }

}

新徏�U�色仪表盘的赛�R实现�c�：

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() + "用红色的仪表盘显�C��R的速度");
    }

}

新徏蓝色仪表盘的赛�R实现�c�：

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() + "用蓝色的仪表盘显�C��R的速度");
    }

}

　　新徏客户端运行类�Q?/p>

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();

    }

}

�E�序�q�行�l�果如下�Q?/p>

��速度300取出来！
��速度300用红色的仪表盘显�C��R的速度
��速度400取出来！
��速度400用蓝色的仪表盘显�C��R的速度

�q�就是模板方法模式，一个最常用�Q�最�Ҏ��理解的一个模式，��相同的功能抽象出来成一个父�c�，然后用子�c�d��不同功能的实现�?

非洲��白�?/a> 2009-01-20 17:29 发表评论

原型模式

Tue, 20 Jan 2009 09:28:00 GMT

设计模式-快餐��?【原型模式�?/strong>

�?strong>原型模式应用场景举例�?br /> 比如在玩“极品飞�R”�q�款游戏�Q�每个游戏者都有自��q��账号用来标识玩家�Q�而每个玩安��可以拥有相同的�R辆，�q�样每个玩家都拥有相同的车，比如你的领居有奥�q�A6�Q�你的老婆对你��_��我也要开和邻居一��L��奥��_A6�Q�好了，现在你们家也有奥�q�A6了，你们每天开着自己的�R��M��班，那么在这�U�情况下��可以应�? 原型模式了，原型模式很简单哟�Q�）��是�cȝ��copy复制�?br />
�?strong>原型模式解释�?br /> �c�d��Q�创建模�?br /> 　　用原型实例制定创建对象的�U�类�Q��ƈ且通过拯��q�些原型创徏新的对象�?br />
�?strong>原型模式UML�?/strong>�?br />

�?strong>原型模式-JAVA代码实现�?br /> 新徏赛�R的接口：

package car_interface;

public interface car_interface {

public void start();

public void stop();
}

新徏奥��_汽�R的实现类�Q?/p>

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启动�?/span>");

    }

    public void stop() {
        System.out.println("奥��_A6停止�?/span>");

    }

    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;
    }
}

　　在奥�q�汽车实现类中需要注意的是将原来protected�c�d��的clone�Ҏ��要变成public�Q�这��h��可以对外公开�Q�可以被调用�Q�将�U�密公开化�?br />
新徏奥��_汽�R的配件轮胎类�Q?/p>

package car_fittings;

public class car_tyre {

    private String name = "德国刉��原版轮�?/span>";

    public String getName() {
        return name;
    }

}

　　新徏客户端运行类�Q?/p>

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();
        }
    }

}

�E�序�q�行�l�果如下�Q?/p>

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

从打印的�l�果来看�Q�我的汽车我的轮胎和其它人的汽�R和轮胎都是不一��L��对象�Q�但“�c�d��”都是一��L��Q�奥�q�的汽�R�Q�原版的轮胎。本例中也实��C��“原型�? �?#8221;中的“深拷�?深复�?#8221;�Q�即汽�R�c�M��有一个对�?#8220;轮胎”对象�Q�关于深拯��/深复制的概念请参考其它的资料。原型模式通常都是在复制对象的时候��用，�? 在常规的情况下都是��用new重新创徏一个，�q�且重新对属性进行复�Ӟ��代码重复度很高，原型模式的出现避免了new的硬操作�?br />

非洲��白�?/a> 2009-01-20 17:28 发表评论

装饰模式

Tue, 20 Jan 2009 09:27:00 GMT

�?strong>装饰模式应用场景举例�?br /> 比如在玩“极品飞�R”�q�款游戏�Q�游戏中有对汽�R�q�行��h��鸦的功能�Q�而且�q�个��h��鸦是可以覆盖的，�q�且覆盖的顺序也影响到最后�R�w�的昄��效果�Q�假讄��在喷涂鸦��h��2�U�样式：
�Q?�Q�红色火焰　�Q?�Q��色霞�?br /> 如果使用“�l�承父类”设计�q�样的功能，那么�c�d��像如下的这��P��

从图中可以看��C��用��承来实现�q�种功能�Q��ƈ且是2�U�涂鸦样式，��需要创�?个子�c�，如果��h��鸦有3�U�，4�U�呢�Q�这�U�情况就是典型中学课�E�学习过�?#8220;排列与组�?#8221;�Q�那��直就�?#8220;Head First设计模式”书中讲的“�cȝ��?#8221;�?br /> 昄��l�承“奥��_汽�R�c?#8221;的这个办法是无效�Q�而且是非常徒劻I��J�琐的�?br /> 那么如何才能�?#8220;灉|��”�Q?#8220;��序敏感”�q�样的需求来实现�q�样的功能呢�Q?br />
�?strong>装饰模式解释�?br /> �c�d��Q�结构模�?br /> 　　动态的对一个对象进行功能上的扩展，也可以对其子�c�进行功能上的扩展�?br />
�?strong>装饰模式UML�?/strong>�?br />

�?strong>装饰模式-JAVA代码实现�?br /> 新徏一个抽象汽车父�c�：

package car_package;

public abstract class car_parent {
    // 汽�R抽象父类
    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();

}

然后新徏一个奥�q�汽车子�c�：

package car_package;

public class audi_sub extends car_parent {
    // 奥��_汽�R子类

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

}

然后再新��Z��个装饰者父�c�：

package decorator_package;

import car_package.car_parent;

public abstract class decorator_parent extends car_parent {
    // 装饰者父�c?/span>

    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();
    }

}

然后再新��饰者子�c�：�U�色火焰装饰者类�Q?/p>

package decorator_package;

public class decorator_audi_red extends decorator_parent {

    @Override
    public void print_face() {
        super.print_face();
        System.out.println("�l�　奥��_　��h��鸦　-　颜色为　�U�色火焰");
    }

}

然后再新��饰者子�c�：紫色霞光装饰者类�Q?br />

package decorator_package;

public class decorator_audi_purple extends decorator_parent {

    @Override
    public void print_face() {
        super.print_face();
        System.out.println("�l�　奥��_　��h��鸦　-　颜色为　紫色霞光");
    }

}

新徏一个运行类�Q?/p>

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();

    }
}

�E�序�q�行�l�果如下�Q?br />

audi车默认的颜色为　黑色
�l�　奥��_　��h��鸦　-　颜色为　�U�色火焰
�l�　奥��_　��h��鸦　-　颜色为　紫色霞光

从程序结构中可以看到�Q�完全符合了前面我们的要求：“灉|��”�Q?#8220;��序敏感”�?

非洲��白�?/a> 2009-01-20 17:27 发表评论

�{�略模式

Tue, 20 Jan 2009 09:27:00 GMT

设计模式-快餐��?【策略模式�?/strong>

�?strong>�{�略模式应用场景举例�?br /> 比如在玩“极品飞�R”�q�款游戏�Q�那么游戏对车的轮胎是可以更换的�Q�不同的轮胎在高速�{弯时有不同的痕迹样式�Q�那么针�?#8220;汽�R”的配�?#8220;轮胎”��p��可以变化�Q�而且轮胎和轮胎之间是可以�怺�替换的，�q�就是典型的要应�?#8220;�{�略模式”的场景！

�?strong>�{�略模式解释�?br /> �c�d��Q�行为模�?br /> 　　定义一�l�算法，��每个算法都��装��h��Q��ƈ且��它们之间可以互换。策略模式�ɘq�些��法在客��L��调用它们的时候能够互不媄响地变化�?br />
�?strong>�{�略模式UML�?/strong>�?br />
�?strong>�{�略模式-JAVA代码实现�?br /> 从策略模式UML图中可以看到Context与接口Strategy是组合关�p�，卛_��引用关系�?br />
新徏一个轮胎接口：

package strategy_interface;

public interface tyre_interface {

// tyre 轮胎
public void print_tyre_line();// 昄��胎的痕迹

}

新徏2个轮胎接口的实现�c�：

package strategy_implement;

import strategy_interface.tyre_interface;

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

    public void print_tyre_line() {
        System.out.println("在�\面上昄��一个长轮胎痕迹");
    }

}

package strategy_implement;

import strategy_interface.tyre_interface;

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

    public void print_tyre_line() {
        System.out.println("在�\面上昄��一个短轮胎痕迹");
    }

}

��Z��一个轮胎接口来实现不同样式的轮胎样式�?br />
�l�装一个Car车类�Q?br />

package car_package;

import strategy_interface.tyre_interface;

public class Car {

    private String make_address;// 刉��地
    private int death_year;// 报废�q�限
    private int speed;// 速度
    private tyre_interface tyre_interface_ref;// 轮胎的样�?/span>

    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�Q?/span>" + this.getMake_address());
        System.out.println("报废�q�限death_year�Q?/span>" + this.getDeath_year());
        System.out.println("速度speed�Q?/span>" + this.getSpeed());

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

        System.out.println("Car高速行�Ӟ��遇到一个大转弯�Q��\面显�C�：");
        this.getTyre_interface_ref().print_tyre_line();

    }
}

让�R跑�v来，�q�且��h��更换轮胎样式的功能：

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("北京朝阳�?/span>");
        car.setSpeed(200);
        car.setTyre_interface_ref(tyre_long_implement);
        car.start();

    }
}

控制台打印出�Q?br />

车的基本信息为：
刉��地make_address�Q�北京朝阛_��
报废�q�限death_year�Q?/span>8
速度speed�Q?/span>200
Car 起动了！
Car高速行�Ӟ��遇到一个大转弯�Q��\面显�C�：
在�\面上昄��一个长轮胎痕迹

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

非洲��白�?/a> 2009-01-20 17:27 发表评论

代理模式

Tue, 20 Jan 2009 09:26:00 GMT

�?strong>代理模式应用场景举例�?br /> 比如在玩“极品飞�R”�q�款游戏�Q�如果游戏者手中的金钱辑ֈ�了一定的数量��可以到车店��C��部性能更高的赛车，那么�q�个卖�R�?#8220;车店”��是一个典型的“�? 车厂�?#8221;�?#8220;代理”�Q�他为汽车厂�?#8220;提供卖�R的服�?#8221;�l�有需求的人士。从面向对象的方面考虑�Q?#8220;销售汽车的代理”也是一个对象，那么�q�个对象也具有一定的状态，在��Y仉��目中�q�个对象也具有管理胦务进销存的基本功能�Q�那么在设计时就要以面向OOP�~�程的思想来考虑软�g的类�l�构�Q�这个销售汽车的代理也是一个类了�?br />
�?strong>代理模式解释�?br /> �c�d��Q�结构模�?br /> 　　对一些对象提供代理，以限刉��些对象去讉K��其它对象�?br />
�?strong>代理模式UML�?/strong>�?br />

�?strong>代理模式-JAVA代码实现�?br /> 新徏一个买车的接口�Q?

package buy_car_package;

public interface buy_car_package {

public void buy_car();
}

新徏一个people人类�Q�具有买车的行�ؓ�Q�所以实现接口buy_car_package�Q?/p>

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 + "��C��一台新�?/span>");
    }

}

people�c�M��能拥有�R�Q�必��ȝ��q�proxy代理�cȝ��认证�Q�符合条件之后才可以拥有车辆�Q�新��Z��个代理，�q�个代理�c�L��考察当前的people是否有资��D��行买车：

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("汽�R商店帮：");
            people.buy_car();
        } else {
            System.out.println(people.getUsername() + "金钱不够�Q�请�l�箋比赛!");
        }
    }

}

最后创��Z��个客��L��Q�用来模拟买车的行�ؓ�Q?/p>

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("高洪�?/span>");

        people people_ref2 = new people();
        people_ref2.setCash(2000);
        people_ref2.setUsername("岩洪�?/span>");

        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();

    }
}

�E�序�q�行�l�果如下�Q?/p>

高洪岩花4000块　��C��新�R　交易�l�束
岩洪高金�׃��够，��L��l�比�?/span>!

�q�样people��׃��可能自由的拥有�R辆，必须�l�过proxy的认证之后才可以�?br /> 而代理模式在GOF四�h帮的介绍中大体有4�U��用情景：
�Q?�Q�远�E�代理。典型的��是客户端与webservice使用的情况，客户端由于是针对OOP�~�程�Q�而不是针对webservice中的�Ҏ��q�行�~? �E�，所以得在客��L��模拟一下webservice的环境，用proxy来对webservice�q�行包装�Q�这样就可以使用proxy代理�c�L��q�程操作 webservice了�?br /> �Q?�Q�虚拟代理。比如你要开发一个大文档查看软�g�Q�大文档中有大的囄��Q�有可能一个图片有100MB�Q�在打开文�g时不可能��所有的囄��都显�C�出来，�q�样��可以��用代理模式，当需要查看图片时�Q�用proxy来进行大囄��的打开�?br /> �Q?�Q�安全代理。其实也��是本例中所丄��买�R的例子，金钱不够不可以买车！
�Q?�Q�智能指引。比如在讉K��一个对象时��其是否被锁定等情况�?

非洲��白�?/a> 2009-01-20 17:26 发表评论

工厂�Ҏ��模式

Tue, 20 Jan 2009 09:24:00 GMT

�?strong>工厂�Ҏ��模式应用场景举例�?br /> 比如在玩“极品飞�R”�q�款游戏�Q�晕了吧�Q�我喜欢极品飞�R�Q�）�Q�在玩这�ƾ游戏时�Q�游戏者可以选择从不同品牌来选择赛�R�Q�那么这�?#8220;品牌”其实也就是工厂，每个工厂生��的赛车都不一��P��q�就是典型的工厂�Ҏ��的应用场景�?br />
�?strong>工厂�Ҏ��模式解释�?br /> �c�d��Q�创建模�?br /> 　　定义一个用于创建对象的接口�Q�让其子�c�L��军_��实例化哪一个类�Q��品）�Q�工厂方法��一个类的创建�g�q�到其子�c�M��?br />
�?strong>工厂�Ҏ��模式UML�?/strong>�?br />

�?strong>工厂�Ҏ��模式-JAVA代码实现�?br /> 新徏赛�R的接口：

package car_interface;

public interface Icar_interface {

public void start();

public void stop();

}

新徏1个汽车信息的基类�Q?/p>

新徏奥��_汽�R实现�c�：

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() + " 车以专利技术�v动了　最高速度为："
                + this.getSpeed());
    }

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

}

新徏大众汽�R实现�c�：

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() + " 车以专利技术�v动了　最高速度为："
                + 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();

}

新徏一个创建奥�q��R的汽车工厂实现类�Q?/p>

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;
    }
}

新徏一个创建大众�R的汽车工厂实现类�Q?/p>

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();

    }

}

�E�序�q�行�l�果如下�Q?/p>

奥��_A6 车以专利技术�v动了　最高速度为：300
奥��_A6 车以专利技术停车了

通过使用工厂�Ҏ��模式��可以将对象的创建�g�q�到子类�q�行实例化，而且每个工厂创徏不同的品牌的汽�R�Q�每个汽车的功能都有自己“专利”的实玎ͼ��q�样可以��不�?#8220;品牌”�?#8220;汽�R”的创��行分�c�，有利于对象创建的清晰性。创��Z��同的汽�R只需要改动这句代码就可以了：
Icar_factory car_factory = new audi_car_factory_imple();

非洲��白�?/a> 2009-01-20 17:24 发表评论