亚洲自偷自拍另类12p,亚洲狠狠ady亚洲精品大秀,亚洲视频在线观看视频

sailor — Sat, 26 Jul 2008 00:25:00 GMT

摘要: 定义在一个方法中定义一个算法的骨架�Q�而将一些步骤�g�q�到子类中。模板方法��得子�c�d��以在不改变算法结构的情况下，重新定义��法中的某些步骤�? 钩子钩子是一�U�被声明在抽象类中的�Ҏ��Q�但只有�I?.. 阅读全文

sailor 2008-07-26 08:25 发表评论

sailor — Fri, 25 Jul 2008 02:26:00 GMT

定义
   提供了一个统一的接口，用来讉K��字系�l�中的一��接口，外观定义了一个高层接口，让子�pȝ��更容易��用�?br />
要点
     当需要简化�ƈ�l�一一个很大的接口或者一��复杂的接口�Ӟ��使用外观�?br />
    外观��客户从一个复杂的子系�l�中解耦�?/p>
    实现一个外观，需要将子系�l�组合进外观中，然后��工作委托给子系�l�执行�?br />
    外观��一��对�?#8220;包装”��h��以简化其接口�?br />
实例


例子�Q�http://www.jdon.com/designpatterns/designpattern_Facade.htm

参考资料：《First Head 设计模式�?br />                     http://www.jdon.com/designpatterns/designpattern_Facade.htm

sailor 2008-07-25 10:26 发表评论

sailor — Fri, 25 Jul 2008 01:17:00 GMT

定义
    ��一个类的接口，转换成客��h��望的另一个接口。适配器让原本不兼容的�c�d��以合作无间�?br />
    �c�适配器可以分为类适配器和对象适配�?/font>

实用�?br />     当需要私用一个现有的�c�而其接口�q�不�W�合你需要的�Ӟ��׃��用适配器；

    适配器改变接口以�W�合用户的期望；

实例

1package com.sailor.adapter;
2
3
4/**
5 * 被适配�?br /> 6 * @author sailor
7 * Jul 25, 2008 9:35:19 AM
8 */
9public class Duck {
10
11    public Duck() {
12
13    }
14
15    public void fly(){
16        System.out.println("I can fly");
17    }
18
19    public void quack(){
20        System.out.println("quake!");
21    }
22}
23

1
2package com.sailor.adapter;
3
4/**
5 * 目标接口
6 * @author sailor
7 * Jul 25, 2008 9:43:35 AM
8 */
9public interface Turkey {
10
11 public void gobble();
12 public void fly();
13}
14

1
2package com.sailor.adapter;
3
4/**
5 * 适配�?br /> 6 * @author sailor
7 * Jul 25, 2008 9:38:10 AM
8 */
9public class TurkeyAdapter implements Turkey{
10
11    private Duck duck;
12
13    public TurkeyAdapter(Duck duck) {
14        this.duck = duck;
15    }
16
17    public void gobble(){
18        duck.quack();
19    }
20
21    public void fly(){
22        duck.fly();
23    }
24
25
26}
27

1
2package com.sailor.adapter;
3
4/**
5 * 客户�?br /> 6 * @author sailor
7 * Jul 25, 2008 9:45:29 AM
8 */
9public class Client {
10
11    /**
12     * @param args
13     */
14    public static void main(String[] args) {
15
16        Duck duck = new Duck();
17
18        Turkey turkey = new TurkeyAdapter(duck);
19
20        turkey.gobble();
21        turkey.fly();
22    }
23
24}
25

参考资料：《First Head 设计模式�?/p>

sailor 2008-07-25 09:17 发表评论

sailor — Thu, 24 Jul 2008 09:20:00 GMT

定义
    ��?#8220;��h��”��装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作�?br />
要点
    命��o模式��发��求的对象和接受请求的对象解耦；

    在被解耦的两者之间是通过命��o对象�q�行沟通的。命令对象封装了接收者和一个或者一�l�对象；

    调用者通过调用命��o对象的execute()发出��h��Q�这会��得接受者的动作被调用；

    调用者可以接受命令当作参敎ͼ�甚至在运行时动态地�q�行�Q?br />
    命��o也可以实现日志和实务�pȝ��?br />

所涉及的角�Ԍ��
1.客户�Q�Client�Q�角�Ԍ��创徏一个具体对象及其确定接收�?
2.命��o�Q�Command�Q�角�?声明了一个给所有具体命令类的抽象接口�?br /> 3.具体命��o(ConcreteCommand)角色:定义一个接收者与行�ؓ之间的弱耦合�Q�实现exceute()�Ҏ��Q�负责调用接收者的相应操作�?br /> 4.��h��?Invoker)角色:负责调用命��o对象执行��h��?br /> 5.接收者（Recevice�Q�角�?负责具体实施与执行一个请求�?br />
优点�Q?br /> 解耦了发送者和接受者之间联�p�R�?发送者调用一个操作，接受者接受请求执行相应的动作�Q�因��Z��用Command模式解耦，发送者无需知道接受者�Q何接口�?br />
命��o模式创徏的一般步�?/strong>�Q?br /> 1.客户端创��Z��个ConcreteCommand对象�Q��ƈ指明接收者�?br /> 2.��h��对象保持ConcreteCommand对象�?br /> 3.��h��对象通过调用action�Ҏ��发出��h��Q�若命��o是可撤消,则ConcreteCommand保存execute()�Ҏ��执行前的状态�?br /> 4.ConcreteCommand对象调用接收的方法执行请求�?br />
实例
抽象命��o接口�Q?br />

package command;
public interface Command{
    //执行�Ҏ��
     void execute();
}

具体命��o

package command;
public class ConcreteCommand implements Command{
    //接收�?/span>
    private Receiver receiver;
    //构造方�?/span>
    public ConcreteCommand(Receiver receiver){
        this.receiver=receiver;
    }
    //执行�Ҏ��
    public void execute(){
        receiver.action();
    }
}

接收者：

package command;
public  class Receiver {
    //构造方�?/span>
    public Receiver(){};
    //行�ؓ�Ҏ��
    public void action(){
        System.out.println("Action is taken here");
    }
}

��h��者：

package command;
public class Invoker{
    //命��o
    private Command command;
    //构造方�?/span>
    public Invoker(Command command){
        this.command=command;
    }
    //行�ؓ�Ҏ��
    public void action(){
        command.execute();
    }
}

客户端：

package command;
public class Client{
    public static void main(String[] args){
        Receiver receiver=new Receiver();
        Command concreteCommand=new ConcreteCommand(receiver);
        Invoker invoker=new Invoker(concreteCommand);
        invoker.action();
    }
}

命��o模式与责任链模式区别�Q?br /> 责�Q链模式��一个特定的��h��接收对象对请求与命��o的执行变得不��定�?而命令模式��得一个特定的对象对命令的执行变得明显与确�?

参考资料：《First Head 设计模式�?br />                         设计模式学习�W�记(十五)--------命��o(Command)模式

sailor 2008-07-24 17:20 发表评论

sailor — Wed, 23 Jul 2008 01:51:00 GMT

定义
    ��保一个类只有一个实例，�q�提供全局讉K��?br />
设计原则
    在JAVA中实现单件模式需要一个私有的构造器、一个静态方法和一个静态变量；
    ��定在性能和资源上的限�Ӟ��然后��心地选择适当的方案来实现单�g�Q�以解决多线�E�的问题�Q?br />     如果不是采用�W�五版的java 2�Q�双重检查锁实现会失效；

实现
    1、lazy singleton

1public class Singleton{
2
3 private static Singleton uniqueInstance;
4
5 private Singleton(){}  //�U�有构造器
6
7 public static Singleton getInstance(){
8
9  if(uniqueInstance == null){
10
11   uniqueInstance = new Singleton();
12  }
13
14  return uniqueSingleton
15 }
16}


    2、处理多�U�程
             �q�是保证可行的最直接做法�Q�对于性能如果没有考虑�Q�可以直接用�q�个�Ҏ��?/p>
1public class Singleton{
2
3 private static Singleton uniqueInstance;
4
5 private Singleton(){}  //�U�有构造器
6
7 public static synchronized Singleton getInstance(){
8
9  if(uniqueInstance == null){
10
11   uniqueInstance = new Singleton();
12  }
13
14  return uniqueSingleton
15 }
16}

    3、急切实例�?br />
1public class Singleton{
2
3 private static uniqueInstance = new Singleton();
4
5 private Singleton(){}
6
7 public static Singleton getInstance(){
8
9   return uniqueInstance;
10 }
11
12}

    4、用“双重��查加�?#8221;�Q�在getInstance( )中减��用同�?br />     �׃��没有性能上考虑�Q�所以这个方法似乎杀鸡用了牛刀。另外这个方法还得确定��用的是java5以上的版本�?br />

1package com.sailor.singleton;
2
3/** *//**
4 * @author sailor
5 * Jul 23, 2008 9:46:17 AM
6 */
7public class Singleton {
8
9    private volatile static Singleton uniqueInstance;
10
11    private Singleton(){}
12
13    public static Singleton getInstance(){
14        if(uniqueInstance == null){
15            synchronized(Singleton.class){
16                if(uniqueInstance == null){
17                    uniqueInstance = new Singleton();
18                }
19            }
20        }
21        return uniqueInstance;
22    }
23}

sailor 2008-07-23 09:51 发表评论

模式�Q�四-3�Q�：抽象工厂(Abstract Factory)模式

sailor — Tue, 22 Jul 2008 09:22:00 GMT
定义
    提供一个接口，用于创徏相关或相依赖对象的家族，而不需要明��指定具体类�?br />
原则
    依赖抽象�Q�而不要依赖具体类


实用�?br />
　　1�Q�一个系�l�应当不依赖于��品类实例被创立，�l�成�Q�和表示的细节。这对于所有�Ş态的工厂模式都是重要的�?

　　2�Q�这个系�l�的产品有多于一个的产品�?/span>�?

　　3�Q?span style="color: #ff0000">同属于同一个��品族的��品是设计成在一起��?/span>的。这一�U�束必须得在�pȝ��的设计中体现出来�?

角色

　　　　　　　�?. 抽象工厂模式的类囑֮��?

　　从上囑֏�以看出，��单工厂模式涉及到以下的角�?

　　　抽象工厂(AbstractFactory)�c�L��接口

　　　担�Q�q�个角色的是工厂�Ҏ��模式的核心，它是与应用程序无关的。�Q何在模式中创立对象的工厂�c�d��d��现这个接口，或��承这个类�?

　　　实工厂类 (Conrete Factory)

　　　担�Q�q�个角色的是与应用程序紧密相关的�Q�直接在应用�E�序调用下，创立产品实例的那样一些类�?

　　　抽象产品 (Abstract Product)

　　　担�Q�q�个角色的类是工厂方法模式所创立的对象的父类�Q�或它们共同拥有的接口�?

　　　实��?(Concrete Product)

　　　担�Q�q�个角色的类是工厂方法模式所创立的�Q何对象所属的�c�R�?/span>

实例

抽象工厂模式应用于小花果园系�l�中。三�U�不同的背景颜色可以区分工厂�c�，蔬菜�c?�W�一产品�?�Q�和水果�cȝ��c�d��(�W�二产品�?

sailor 2008-07-22 17:22 发表评论

sailor — Tue, 22 Jul 2008 02:49:00 GMT

定义

    定义了一个创建对象的接口�Q�但由子�c�d��定要实例化的�c�L��哪一个。工厂方法让�c�L��实例化推�q�到子类�?br />

原则

    依赖抽象�Q�不依赖具体实现�Q�依赖倒装�Q?br />             工厂�Ҏ��使用�l�承�Q�把对象的创建委托给子类�Q�子�c�d��现工厂方法来创徏对象。这个原则说明了不能让高层组件依赖底层组�Ӟ��而且�Q�高层组件和底层�l��g都应该依赖于抽象�?br />
角色

从上囑֏�以看出，工厂�Ҏ��模式涉及��C��下的角色

抽象工厂接口(Creator)
     担�Q�q�个角色的是工厂�Ҏ��的核心，它是与应用程序无养I��创徏的工厂类必须实现该接口�?br /> 实工厂类 (Conrete Creator)
     担�Q�q�个角色的是与应用程序紧密相关的�Q�直接在�E�序的调用下创徏具体的��品�?br /> 产品 (Product)
     担�Q�q�个角色的是工厂�Ҏ��模式所创徏对象的父�c�，或者是必须实现的接口�?br /> 实��?(Concrete Product)
   担�Q�q�个角色的是工厂�Ҏ��模式所创徏对象所属的�c�R�?br />
   工厂�Ҏ��模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模�? 把核心放在一个实�c�M��。工厂方法模式可以允许很多实的工厂类从抽象工厂类�l�承下来, 从而可以在实际上成为多个简单工厂模式的�l�合,从而推�q�了��单工厂模式�?br />     反过来讲,��单工厂模式是由工厂方法模式退化而来。设惛_��果我们非常确定一个系�l�只需要一个实的工厂类, 那么��׃��妨把抽象工厂�c�d��q�到实的工厂�c�M��厅R��而这样一�?我们��退化到��单工厂模式了�?
   工厂�Ҏ��模式又叫多�Ş性工厂模式，昄��是因为实工厂�c�都有共同的接口�Q�或者都有共同的抽象父类�?br />
实例�Q?�?

参考资料：《First Head 设计模式�?br />                     �?a id="viewpost1_TitleUrl" href="http://www.tkk7.com/flying/archive/2006/07/12/57731.html">菜鸟学设计模�?------工厂�Ҏ��(Factory Method)模式 �?br />

sailor 2008-07-22 10:49 发表评论

模式目录

sailor — Tue, 22 Jul 2008 02:47:00 GMT
模式�Q�一�Q�：�{�略�Q�Strategy�Q�模�?/a>

模式�Q�二�Q�：观察者（Observer�Q�模�?/a>

模式�Q�三�Q�：装饰者（Decorator�Q�模�?/a>

模式�Q�四-1�Q�：��?Simple Factory)工厂模式

 模式�Q�四-2�Q�：工厂�Ҏ��Q�Factrory Method�Q�模�?/a>

模式�Q�四-3�Q�：抽象工厂(Abstract Factory)模式

 模式�Q�五�Q�：单�g�Q�singleton�Q�模�?/a>

模式�Q�六�Q�：命��o�Q�Command�Q�模�?/a>

模式�Q�七�Q�：适配器（Adapter�Q�模�?/a>

模式�Q�八�Q�：外观�Q�Facade�Q�模�?/a>

模式�Q�九�Q�：模板�Ҏ��Q�Template Method�Q�模�?/a>

sailor 2008-07-22 10:47 发表评论

sailor — Tue, 22 Jul 2008 02:03:00 GMT
工厂模式是专门负责将大量有共同接口的�c�d��例化,而且不必事先知道每次是要实例化哪一个类的模式�?br />
一、工厂模式有三种形�?/strong>
    ��单工�?Simple Factory)模式 �Q�又�U�静态工厂模�?br /> 　工厂�Ҏ��(Factory Method)模式,又称多�Ş性工�?Polymorphic Factory)模式
　抽象工厂(Abstract Factory)模式,又称工具��?Kit或Toolkit)模式

二、简单工厂模�?/h4>
        《Head First 设计模式》认为它不是一个设计模式，更像一�U�编�E�习惯，优点是可以将客户端程序从具体�c�M��解耦，不失��Z��个简单的�Ҏ��?br />
1、定�?br />     ��单工厂模式是�׃��个工厂对象决定创建出那一�U��品类的实例，它是�׃��个工厂类�Ҏ��传入的参量决定创建出哪一�U��品类的实例�?

2、角�?/strong>
    ��单工厂模式涉及到工厂角色、抽象角色以及具体��品角色等

    工厂�c�（Creator�Q�角�Ԍ��担�Q�q�个角色的是工厂�Ҏ��模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客��L��的直接调用下创徏产品对象�Q�它往往�׃��个具体的JAVA�c�d��现�?br />
    抽象产品�Q�Product�Q�角�Ԍ��担�Q�q�个角色的类是工厂方法模式所创徏的对象的父类�Q�或他们共同拥有的接口。抽象��品角色可以用一个java接口或者Java抽象�c�d��现�?br />
    具体产品�Q�Concrete Product�Q�角�Ԍ��工厂�Ҏ��模式所创徏的�Q何对象是�q�个角色的实例，具体产品角色�׃��个具体java�c�d��现�?br />
3、实�?br />

1package com.sailor.simpleFactory;
2
3public abstract class Product {
4
5    public void produce(){
6        System.out.println("生��产品");
7    }
8
9    public abstract void category();
10
11
12    public abstract int salePrice();
13
14}
15

1/** *//**
2 *
3 */
4package com.sailor.simpleFactory;
5
6/** *//**
7 * 具体产品
8 * @author sailor
9 * Jul 22, 2008 10:15:14 AM
10 */
11public class Car extends Product{
12
13    @Override
14    public void category() {
15        System.out.println("生�񔞮�汽�?/span>");
16    }
17
18    @Override
19    public int salePrice() {
20        return new Integer(10000);
21    }
22
23}
24

1package com.sailor.simpleFactory;
2
3/** *//**
4 * 具体产品
5 * @author sailor
6 * Jul 22, 2008 10:17:12 AM
7 */
8public class Pizza extends Product{
9
10    @Override
11    public void category() {
12        System.out.println("生��Pizza");
13    }
14
15    @Override
16    public int salePrice() {
17        return 20;
18    }
19
20}

1/** *//**
2 * 工厂
3 * @author sailor
4 * Jul 22, 2008 10:13:23 AM
5 */
6public class SimpleFactory {
7
8    public static Product createProduct(String product){
9        if("car".equals(product))
10            return new Car();
11        else if("pizza".equals(product))
12            return new Pizza();
13        else
14            return null;
15    }
16}

1package com.sailor.simpleFactory;
2
3/** *//**
4 * 客户�?br /> 5 * @author sailor
6 * Jul 22, 2008 10:20:59 AM
7 */
8public class Client {
9
10    /** *//**
11     * @param args
12     */
13    public static void main(String[] args) {
14
15        Product product1 = SimpleFactory.createProduct("car");
16        product1.category();
17        product1.produce();
18        System.out.println("销售额�Q?nbsp;" + product1.salePrice());
19
20
21        Product product2 = SimpleFactory.createProduct("pizza");
22        product2.category();
23        product2.produce();
24        System.out.println("销售额�Q?nbsp;" + product2.salePrice());
25    }
26}

sailor 2008-07-22 10:03 发表评论

sailor — Mon, 21 Jul 2008 04:15:00 GMT
1、定�?br />     动态地��责任附加到对象上。若要扩展功能，装饰着提供了比�l�承者更有弹性的替代�Ҏ��?br />
2、原�?/strong>
    ��Z��互对象之间的耦合设计而努�?br />     �Ҏ��展开放，对修改关�?br />
3、适用环境
    在不影响其他对象的情况下�Q�以动态、透明的方式给单个对象��d��职责�?br />     处理那些可以撤消的职责�?br />     当不能采用生成子�cȝ��Ҏ��q�行扩充时。一�U�情冉|��Q�可能有大量独立的扩展，为支持每一�U�组合将产生大量的子�c�，使得子类数目呈爆炸性增�ѝ��另一�U�情况可能是因�ؓ�c�d��义被隐藏�Q�或�c�d��义不能用于生成子�c�R�?br />
4、本模式中的角色

    抽象构�g(Component):�l�出一个抽象接口，以规范准备接攉��加责�ȝ��对象�?br />     具体构�g(Concrete Component)�Q?/strong>定义一个接收到附加责�Q的类�?br />     装饰�Q�Decorator�Q?持有一个构件对象的实例�Q��ƈ定义与抽象构件一致的接口�?br />     具体装饰�Q�Concrete Decorator�Q?负责�l�构件对象脓上附加的责�Q�?br />

�Q�图例）

具体例子�Q?br /> 先定义抽象构�Ӟ��

package decorator;
//抽象构�g接口
public interface Component{
    public void sampleOperation();
}

一个具体构�?---门：

package decorator;
//具体构�g-----�?/span>
public class  Door implements Component{
    //实现�Ҏ��
    public void sampleOperation(){
        System.out.println("build a door");
    }
}

装饰(抽象�c?�Q?br />
package decorator;

public abstract class Decorator implements Component{
    //持有一个构件对象的实例
    private Component component;
    //构造方�?/span>
    public Decorator(Component component){
        this.component=component;
    }
    //�Ҏ��的具体实�?/span>
    public  void sampleOperation(){
        component.sampleOperation();
    }
}

具体装饰�Q?br />
package decorator;
//具体装饰----把手
public class Knob extends Decorator{

    public Knob(Component component){
        super(component);
    }

    public void sampleOperation(){
        super.sampleOperation();
        //附加�?责�Q"
        System.out.println("add a knob");
    }
}

package decorator;
//具体装饰----�?/span>
public class Lock extends Decorator{

    public Lock(Component component){
        super(component);
    }
    public void sampleOperation(){
        super.sampleOperation();
        //附加"责�Q"
        System.out.println("add a lock");
    }
}
�q�行�c�：

package decorator;

public class DecoratorPattern{
    public static void main(String[] args){
        Component door=new Door();
        Component lock=new Lock(door);
        Component knob=new Knob(lock);
        knob.sampleOperation();
    }
}

�q�行�l�果�Q?br /> build a door
add a lock
add a knob
Press any key to continue...

参考资料：《Head First 设计模式�?br />                     设计模式学习�W�记�Q�十�Q?-------装饰(Decorator)模式

sailor 2008-07-21 12:15 发表评论

sailor — Sat, 19 Jul 2008 06:58:00 GMT
1、定�?br />
    在对象之间定义一对多的依赖，�q�样一来，当一个对象改变时状态，依赖他的对象会收到通知�Q��ƈ自动更新。这�U�模式以松耦合方式在一些列对象之间改变状态。MVC模式��是观察者模式的一个代表�?br />
2、实用�?br />
    当一个抽象模型有两个斚w��, 其中一个方面依赖于另一斚w��。将�q�二者封装在独立的对象中以��它们可以各自独立地改变和复用�?nbsp;
    当对一个对象的改变需要同时改变其它对�? 而不知道具体有多��对象有待改变�?br />     当一个对象必��通知其它对象�Q�而它又不能假定其它对象是谁。换�a��? 你不希望�q�些对象是紧密耦合的�?br />
3、设计原�?br />
    扑և��E�序中会变化的方面，然后��其和固定不变的斚w��相分��?/strong>
        在观察者模式中�Q�会改变的是主题的状态，以及观察者的数目和类型。用�q�个模式�Q�你可以依赖于主题状态的对象�Q�却不必改变主题。这��叫提前规划�?br />
    针对接口�~�程�Q�不针对实现�~�程
        主题与观察者都使用接口�Q�观察者利用主题的接口�Q�向主题注册�Q�而主题利用观察者的接口通知接口。这样可以让两者之间运作正常，又同事具有松耦合的优炏V�?br />
    多用�l�合�Q�少用��?/strong>
        观察者模式利�?#8220;�l�合”�Q�将许多观察者组合进主题中。对象之间的�q�种关系不是通过�l�承产生的，而是在运行时利用�l�合的方式而��生的�?br />
4、实�?br />

sailor 2008-07-19 14:58 发表评论

sailor — Sat, 19 Jul 2008 06:53:00 GMT
    定义�Q�定义了��法族，分别��装��h��Q�让他们之间可以�怺�交换�Q�此模拟��法的变化独立于使用��法的客戗��?br />
    设计原则�Q?br />         1、多用组合，��用�l�承�Q?br />         2、针�Ҏ��口编�E�，而不是针对实现编�E�；

     实现�Q?br />

        Context(应用场景):
l         需要��?/span>ConcreteStrategy提供的算法�?/span>

l         内部�l�护一�?/span>Strategy的实例�?/span>

l         负责动态设�|�运行时Strategy具体的实现算法�?/span>

l         负责�?/span>Strategy之间的交互和数据传递�?br />

        Strategy(抽象�{�略�c?�Q?/span>

l         定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，Context使用�q�个接口调用不同的算法，一般��用接口或抽象�c�d��现�?/span>


        ConcreteStrategy(具体�{�略�c?�Q?/span>

l         实现�?/span>Strategy定义的接口，提供具体的算法实现�?br />

    参考资料：《Head First设计模式�?br />                         �?span style="font-family: 宋体">鸭子-�{�略模式�Q?/span>Strategy�Q?/span>�?/a>

sailor 2008-07-19 14:53 发表评论