亚洲欧洲精品一区二区三区 ,日韩免费一级,亚洲精品国产一区二区精华液

命��o模式学习�W�记

扭�{乑֝� — Mon, 05 May 2008 01:28:00 GMT

命��o模式�Q�将“��h��”��装成对象，以便使用不同得请求，队列或者日志来参数化其他对象，命��o模式也支持可撤销得操作！�Q�Head First Design Patterns �Q?br /> 优点�Q�解耦了发送者和接受者之间联�p�R�?发送者调用一个操作，接受者接受请求执行相应的动作�Q�因��Z��用Command模式解耦，发送者无需知道接受者�Q何接口�?br /> 1. ��单的命��o模式
命��o接口�Q?br />

public interface Command {
public void execute();
}

关闭灯命令：

public class LightOffCommand implements Command {
Light light;

public LightOffCommand(Light light) {
this.light = light;
}

public void execute() {
light.off();
}
}

打开灯命令：

public class LightOnCommand implements Command {
    Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    public void execute() {
        light.on();
    }
}

灯：

public class Light {

    public Light() {
    }

    public void on() {
        System.out.println("Light is on");
    }

    public void off() {
        System.out.println("Light is off");
    }
}

命��o调用者：

public class SimpleRemoteControl {
    Command slot;

    public SimpleRemoteControl() {}

    public void setCommand(Command command) {
        slot = command;
    }

    public void buttonWasPressed() {
        slot.execute();
    }
}

��试�c�：

public class RemoteControlTest {
public static void main(String[] args) {
  SimpleRemoteControl remote = new SimpleRemoteControl();
  Light light = new Light();
  LightOnCommand lightOn = new LightOnCommand(light);

  remote.setCommand(lightOn);
  remote.buttonWasPressed();
    }
}

命��o模式得特点：
1�?分布登记�l�一执行�Q?br /> 在作�E�序�Ӟ��l�常��到一些需求，先注册一些操作，�q�不马上执行�Q�等最�l�确定后�l�一执行。如一个具体的例子:用户定制自己的报表，可以订阅��|��柱，折线�Q�曲�U�图�Q�客户选择相应的报表组合，�q�样对应一个命令集合，在没��定之前用户可以增删�q�些报表�Q�命令）�Q�等最�l�确定统一交给调用者根据命令执行，生成�l�合报表。实��C��命��o分布提出�Q�确定后�l�一执行的功能�?br />
2》�Ş如流水线操作�Q�还是出书的例子
//先是一本空白的书：
Book book = new Book();
//扑և�个作�?br /> Author author1 �Q?new Author();
Author author2 �Q?new Author();
//把写1�Q?章的名类分别�l�这两个作�?br /> Command writeCommand = new Write1Command (author1�Q�book);
Command writeCommand = new Write2Command (author2�Q�book);
List commands �Q?new List ();
Commands.add(writeCommand);
//调用�?br /> Invoker invoker = new invoker();
Invoker.setCommands(commands);
//��水写书
invoker.action()
实际上在aciton�q�一�Ҏ��中，invoker按照命��o�Q�让两个作者流水写作这本书。（�c�M��一个书的流水线加工工厂�Q?br /> �q�样我们的书��p��水加工成功�Q�当然这本书只有两章�Q?br />
�q�样��q��了我们一�U�系�l�设计的框架�Q?br /> 模型�Q�工��P��命��o
客户端��生命令，命��o调用工具操作模型�?br /> Book 相当于模�?br /> Author 相当于和多工��L��中的一�?br /> Command 命��o

3》系�l�需要支持命令的撤消(undo)。提供redo()�Ҏ��【容易扩展�?br /> 我们可以和容易的加入undo和redo�Q�这个不隄��?br />
4》在Invoker中我们可以实现跟�t�，和日志�?br />
5》当�pȝ��需要�ؓ某项复制增加形的功能的时候，命��o模式使新的功能（表现��Z��U�命令）很容易地被加入到服务�U�里�?br /> 命��o联系了工��L��x��行类和系�l�逻辑�Q?br />
��?变化的命令模式：
命��o模式的角色比较多�Q�在实际应用�U�我们可以根据所需要的功能和不需要的功能加以��化�?br />
1》去�?调用�?br /> 产生命��o集合后，我们可以直接在client中�P代执行执行操�?br /> 2�?变化调用�?成�ؓ 跟踪�?br /> //调用�?br /> public class Invoker{
List commands; //已经执行完毕的命令集�?br /> public void addCommand (Command command,int i){
commands.add(i,command);
}
public void action(Command command){
//执行操作
command. execute();
//
commands.add(command);
}
}
……………
//�q�可以有丰富的redo和undo操作�Q?当然一些都�l�基于命令类提供的相应方�?
}
�q�样�q�个�c�d��记录了所有执行过的操作�?br />
3》去�?命��o 用map替代
我们完全可以用map代替命��o�Q�这��h��需定义各种命��o�c?br /> 我们改进例子
Author author �Q?new Author();
Publisher publisher �Q?new Publisher ();
Map m = new HashMap;
m.put(author, write);
m.put(author, publisherBook);
在Invoker的action�Ҏ��Q?br /> 得代map
�q�用java反射来调用方法；

4》去掉执行者：
直接在命令中�Q�execute�Ҏ��U�）加业务逻辑。这样只适合于简单的��的�pȝ��.

其他要说的内�?br /> 1�?��某些参��C��l�某个方发的方式很多�Q�除了当作方法的参数外还可以当作�cȝ��成员便俩变量传入�Q?br /> �q�就为命令的抽象带来了极大的方便
abstract class Command
{
abstract public void execute();
}
当我们已�l�有了执行者（�c�Test�Q�方法execute�Q�args1�Q�args2 ….argsn�Q?br /> 我们不必向Command加入execute�Q�args1�Q�args2 ….argsn�Q�抽象方法，在说即��加了�Q�在我们�q�代的时候也无法判断或十分不�Ҏ��判断哪个命��o调用哪个execute�Ҏ��?br /> 那么我们可以�q�样
class ConcreteCommand : Command
{
Test test;
args1
args2
…..
argsn
public override void Execute()
{
test. execute (args1�Q�args2 ….argsn);
}
}
2�?在想跟踪操作的时候，一般�ؓ每一个操作对象分配一个调用者，操作对象在调用者中讄��。（可以抽象��Z��个�ȝ��调用者，来协调调用每一个具体的调用者）
3�?命��o的抽象粒度我觉得是要注意的�?br /> 4�?理解思想�Q�不要机械的照搬。消化成自己的，加以灉|��的运用和创造在是根本出路�?br /> 所谓命令模式的�Ҏ��思想��是�?先�Ş成命令，在根据命令执行�?br />
参考：http://blog.csdn.net/baggio785/archive/2006/05/23/750513.aspx

扭�{乑֝� 2008-05-05 09:28 发表评论

工厂模式学习�W�记

扭�{乑֝� — Sun, 04 May 2008 06:13:00 GMT

1. ��单工厂模式又�U�静态工厂方法模式。从命名上就可以看出�q�个模式一定很��单。它存在的目的很��单：定义一个用于创建对象的接口�?/font>

1.public class CarFactory{
       public static Car getCar(int type){
           if(type == 1){
                  return new Car1();
              } else {
              return new Car2();
           }
       }
}

2. public class CarFactory{
        public static Car getCar(String carClass){
            String className = carClass;
             Class c = Class.forName(className);
             Car car = (Car)c.newInstance();
             return car;
        }
}

3. public class CarFactory{
        public static Car getCar(String carJNDIName){
            InitialContext ic = new InitialContext();
            String className = ic.lookUp(carJNDIName);
            Car car = (Car)Class.forName(className).newInstance();
            return car;
        }
}
方式1�?适合于工厂所产生的对象都是属于同一个父�c�d��的，而从方式1�?来看�Q�方�?无疑是最��单的�Q�也是最�Ҏ��理解和接受的�Q�而方�?和方�?则相�Ҏ��说要高��一炏V��高�U�在哪里呢？我们可以看到�Q�方�?中对对象的创建是使用Hardcode的�Ş式，也即是程序员需要事先知道系�l�里面存在多��个�c�d��的对象及其对应的�~�号�Q�一旦增加或删除、修改了对象的类型，则必然引起if-else块的改变�Q�造成了维护的困难�?br />
而方�?则采用了动态类加蝲的方式，方式3在方�?的基��上��用了JNDI�Q�更�q�了一步，其好处是不用出现HardCode的方式，即便你后面的应用增加、删除了对象的类型，我的�E�序�q�是保持现在的样子，跟进一步来��_��可以��L��那些讨厌的if-else语句�?br /> 2. 工厂�Ҏ��模式��L��了简单工厂模式中工厂�Ҏ��的静态属性，使得它可以被子类�l�承。这样在��单工厂模式里集中在工厂方法上的压力可以由工厂�Ҏ��模式里不同的工厂子类来分担。�?font style="background-color: #c7edcc">实质上它是让工厂实现了抽象的工厂接口�Q�它把具体怎么生��一�U�东西，攑֜�具体的工厂去实现了，所�?#8221;延迟到子�c�M��实现“�?/span>
�C�Z��一�Q?br /> public interface Driver{
       public Car driverCar();
}
public class BenzDriver implements Driver{
       public Car driverCar(){
              return new Benz();
       }
}
public class BmwDriver implements Driver{
       public Car driverCar()   {

return new Bmw();
}
}

// 应该和具体��品�Ş成对应关�p?/span> ...
// 有请暴发户先�?/span>
public class Magnate

{

public static void main(String[] args)

{

try{
Driver driver = new BenzDriver();

Car car = driver.driverCar();

car.drive();

}

……

}
�C�Z��二：

public interface Creator
{
public Prouct factory();
}

public SubCreator1 implent Creator
{
   public Prouct factory()
{
   return new ConcreteProduct1();
   }
}

public SubCreator2 implent Creator
{
   public Prouct factory()
{
    return new ConcreteProduct2();
   }
}

��h��意：�q�回�c�d��是Product型的�Q�！
�q�样客户端调用是直接new 一个具体工厂的实例�Q�然后命令它�ȝ��产，而对于具体工厂的父类�Q�既工厂接口�Q�接口完全可以改成子�cȝ��承父�c�L��实现�Q�只是这样不好，不符合OO的原则）�Q�它完全不知道什么��品被生��了，甚至它连那个具体工厂被实例化它都不知道！
3. 抽象工厂
public abstract class AbstractFactory{
        public abstract Car getCar(String carClass);
        public abstract Plane getPlane(String planeClass);
}

public class Factory1 extends AbstractFactory{
      public Car getCar(String carClass){
          // 参考上面的方式1�?
          return car1;
      }

      public Plane getPlane(String planeClass){
          // 参考上面的方式1�?
          return plane1;
      }
}

public class Factory2 extends AbstractFactory{
     public Car getCar(String carClass){
          // 参考上面的方式1�?
          return car2;
     }

     public Plane getPlane(String planeClass){
          // 参考上面的方式1�?
          return plane2;
     }
}

方式4是最为复杂而且也是最为强大的一�U�，它在实现了对象工厂抽象的基础上，又集成了工厂�Ҏ��。��C��同的工厂可以生��相同�c�d��的��品，但��品的子类可能有所不同�?/span>��像上面的工�?和工�?都可以生产汽车和飞机一��P��他们各自之间可以生��不同�p�d��的��?抽象工厂)�Q�而且每个�p�d��下面可能有不同的型号(工厂�Ҏ��)�?br />
参考资料：http://www.aygfsteel.com/pengpenglin/archive/2008/01/02/172325.html
http://www.aygfsteel.com/killme2008/archive/2007/03/15/104031.html
http://www.aygfsteel.com/alex/archive/2006/08/29/66479.html

扭�{乑֝� 2008-05-04 14:13 发表评论

扭�{乑֝� — Sun, 04 May 2008 00:38:00 GMT

1. �l�典的单实例模式例子�Q�非�U�程安全�Q�：
public class Singleton {
    private static Singleton uniqueInstance;

    // other useful instance variables here

    private Singleton() {}

    public static Singleton getInstance() {
        if (uniqueInstance == null) {
        uniqueInstance = new Singleton();
     }
         return uniqueInstance;
    }

    // other useful methods here
}
本例是最�l�典的单实例模式例子�Q�但是在多线�E�的情况下就会��生多个实例！

2. �U�程安全的例子：
public class Singleton {
private static Singleton uniqueInstance;

// other useful instance variables here

private Singleton() {}

public static synchronized Singleton getInstance() {
  if (uniqueInstance == null) {
   uniqueInstance = new Singleton();
  }
  return uniqueInstance;
}

// other useful methods here
}
增加synchronized�Q�会让该�Ҏ��是线�E�安全的�Q�但是会引�v每个�U�程在调用该�Ҏ��时的�{�待�Q�如果getInstance的性能对应用程序不是很关键�Q�记住，同步�Ҏ��可能会��getInstance�Ҏ��得运行效率降�?00倍）�Q�本�Ҏ��是最好得�Ҏ��Q?br /> 3. 提前实例化，不适用延迟实例化（使用于创建和�q�行时负担不太繁重或者应用程序��L��创徏�q��用单件实例）�Q�它是线�E�安全得�Q?br /> public class Singleton {
    private static Singleton uniqueInstance = new Singleton();

    // other useful instance variables here

    private Singleton() {}

    public static Singleton getInstance() {
            return uniqueInstance;
    }

    // other useful methods here
}
采用�q�种�Ҏ��Q�我们依赖JVM在加载这个类时候马上创建此唯一实例�Q�JVM保证在�Q何线�E�访问它之前�Q�一定先创徏�?
4. 在java1.5及以后的版本�Q�增加了volatile关键字，可以采用双重��查加锁！
public class Singleton {
private volatile static Singleton uniqueInstance;

private Singleton() {}

public static Singleton getInstance() {
  if (uniqueInstance == null) {
   synchronized (Singleton.class) {
    if (uniqueInstance == null) {
     uniqueInstance = new Singleton();
    }
   }
  }
  return uniqueInstance;
}
}
volatile关键字确保：当unigueInstance变量在被初始化成实例�Ӟ��多个�U�程能够正确的处理它�Q�（对于��x��性能的程序，�q�种做法可以大大减少时耗）

扭�{乑֝� 2008-05-04 08:38 发表评论