三级黄视频在线观看,国产日产精品一区二区三区四区的观看方式,四虎影视国产在线视频

设计模式-工厂模式

Mon, 19 Mar 2012 08:58:00 GMT

一、工厂模式主要是为创建对象提供过渡接口，以便��创建对象的具体�q�程屏蔽隔离��h��Q�达到提高灵�z�L��的目的�?/strong>

工厂模式在《Java与模式》中分�ؓ(f��)三类�Q?br />1�Q�简单工厂模式（Simple Factory�Q�：(x��)不利于��生系列��品；

2�Q�工厂方法模式（F(tu��n)actory Method�Q�：(x��)又称为多形性工厂；

3�Q�抽象工厂模式（Abstract Factory�Q�：(x��)又称为工��L(f��ng)��Q��生��品族�Q�但不利于��生新的��品；
             �q�三�U�模式从上到下逐步抽象�Q��ƈ且更具一般性�?br />             GOF在《设计模式》一书中��工厂模式分��Z��c�：(x��)工厂�Ҏ(gu��)��模式�Q�F(tu��n)actory Method�Q�与抽象工厂模式�Q�Abstract Factory�Q�。将��单工厂模式（Simple Factory�Q�看为工厂方法模式的一�U�特例，两者归��Z��c�R�?br />

二、简单工厂模�?/strong>

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

在简单工厂模式中,一个工厂类处于对��品类实例化调用的中心位置�?它决定那一个��品类应当被实例化, 如同一个交通警察站在来往的�R辆流�?军_��放行那一个方向的车辆向那一个方向流动一栗��?/div>
      先来看看它的�l�成�Q?br />
         1) 工厂�c�角�Ԍ��(x��)�q�是本模式的核心�Q�含有一定的商业逻辑和判断逻辑。在java中它往往�׃��个具体类实现�?br />
         2) 抽象产品角色�Q�它一般是具体产品�l�承的父�c�L��者实现的接口。在java中由接口或者抽象类来实现�?br />
         3) 具体产品角色�Q�工厂类所创徏的对象就是此角色的实例。在java中由一个具体类实现�?br />
三、工厂方法模�?/strong>

工厂�Ҏ(gu��)��模式是简单工厂模式的�q�一步抽象化和推�q�，工厂�Ҏ(gu��)��模式里不再只�׃��个工厂类军_��那一个��品类应当被实例化,�q�个军_��被交�l�抽象工厂的子类��d��?br />　　来看下它的组成：(x��)

       1)抽象工厂角色�Q�这是工厂方法模式的核心�Q�它与应用程序无兟뀂是具体工厂角色必须实现的接口或者必��ȝ��承的父类。在java中它由抽象类或者接口来实现�?br />
       2)具体工厂角色�Q�它含有和具体业务逻辑有关的代码。由应用�E�序调用以创建对应的具体产品的对象�?br />
       3)抽象产品角色�Q�它是具体��品��承的父类或者是实现的接口。在java中一般有抽象�c�L��者接口来实现�?br />
       4)具体产品角色�Q�具体工厂角色所创徏的对象就是此角色的实例。在java中由具体的类来实现�?br />       工厂�Ҏ(gu��)��模式使用�l�承自抽象工厂角色的多个子类来代替简单工厂模式中�?#8220;上帝�c?#8221;。正如上面所��_(d��)��q�样便分担了对象承受的压力；而且�q�样使得�l�构变得灉|��h��——当有新的产品�Q�即暴发��L(f��ng)��汽�R�Q��生时�Q�只要按照抽象��品角艌Ӏ�抽象工厂角色提供的合同来生成，那么��可以被客户使用�Q�而不必去修改��M��已有的代码。可以看出工厂角色的�l�构也是�W�合开闭原则的�Q?br />
代码�Q?
//抽象产品角色
public interface Moveable {
    void run();
}
//具体产品角色
public class Plane implements Moveable {
    @Override
    public void run() {
        System.out.println("plane....");
    }
}

public class Broom implements Moveable {
    @Override
    public void run() {
        System.out.println("broom.....");
    }
}

//抽象工厂
public abstract class VehicleFactory {
    abstract Moveable create();
}

//具体工厂
public class PlaneFactory extends VehicleFactory{
    public Moveable create() {
        return new Plane();
    }
}

public class BroomFactory extends VehicleFactory{
    public Moveable create() {
        return new Broom();
    }
}
//��试�c?br />public class Test {
    public static void main(String[] args) {
        VehicleFactory factory = new BroomFactory();
        Moveable m = factory.create();
        m.run();
    }
}

可以看出工厂�Ҏ(gu��)��的加入，使得对象的数量成倍增�ѝ��当产品�U�类非常多时�Q�会(x��)出现大量的与之对应的工厂对象�Q�这不是我们所希望的。因为如果不能避免这�U�情况，可以考虑使用��单工厂模式与工厂�Ҏ(gu��)��模式相结合的方式来减��工厂类�Q�即对于产品�?w��i)上�c�M��的种�c�（一般是�?w��i)的叶子中互为兄弟的�Q��用简单工厂模式来实现�?br />
四、简单工厂和工厂�Ҏ(gu��)��模式的比�?/span>

工厂�Ҏ(gu��)��模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模�? 把核心放在一个实�c�M��。工厂方法模式可以允许很多实的工厂类从抽象工厂类�l�承下来, 从而可以在实际上成为多个简单工厂模式的�l�合,从而推�q�了��单工厂模式�?
反过来讲,��单工厂模式是由工厂方法模式退化而来。设惛_��果我们非常确定一个系�l�只需要一个实的工厂类, 那么��׃��妨把抽象工厂�c�d��q�到实的工厂�c�M��厅R��而这样一�?我们��退化到��单工厂模式了�?br />
五、抽象工厂模�?/strong>

代码�Q?/div>
//抽象工厂�c?/div>
public abstract class AbstractFactory {
    public abstract Vehicle createVehicle();
    public abstract Weapon createWeapon();
    public abstract Food createFood();
}

//具体工厂�c�，其中Food,Vehicle�Q�W(xu��)eapon是抽象类�Q?/div>
public class DefaultFactory extends AbstractFactory{
    @Override
    public Food createFood() {
        return new Apple();
    }
    @Override
    public Vehicle createVehicle() {
        return new Car();
    }
    @Override
    public Weapon createWeapon() {
        return new AK47();
    }
}

//��试�c?/div>
public class Test {
    public static void main(String[] args) {
        AbstractFactory f = new DefaultFactory();
        Vehicle v = f.createVehicle();
        v.run();
        Weapon w = f.createWeapon();
        w.shoot();
        Food a = f.createFood();
        a.printName();
    }
}

在抽象工厂模式中�Q�抽象��?(AbstractProduct) 可能是一个或多个�Q�从而构成一个或多个产品�?Product Family)�?在只有一个��品族的情况下�Q�抽象工厂模式实际上退化到工厂�Ҏ(gu��)��模式�?/div>

六、�ȝ��?/strong>

�Q?�Q?/span>��单工厂模式是�׃��个具体的�c�d��创徏其他�cȝ��实例�Q�父�c�L��相同的，父类是具体的�?
�Q?�Q�工厂方法模式是有一个抽象的父类定义公共接口�Q�子�c�负责生成具体的对象�Q�这样做的目的是��类的实例化操作延迟到子�c�M��完成�?
�Q?�Q�抽象工厂模式提供一个创��Z��p�d��相关或相互依赖对象的接口�Q�而无��L��定他们具体的�c�R��它针对的是有多个��品的�{��l�构。而工厂方法模式针对的是一个��品的�{��l�构�?/span>

计明�?/a> 2012-03-19 16:58 发表评论

设计模式-代理模式

Mon, 19 Mar 2012 03:42:00 GMT

�ȝ��Q?�Q�代理对象��承真实对象�?�Q�代理对象的�Ҏ(gu��)��跟真实对象的�Ҏ(gu��)��名一栗��?�Q�代理对象的�Ҏ(gu��)��调用�Q�是引用了真实对象再调用真实对象的方�?/span>

1、代理模�?/font>

所谓代理，��是一个�h或者一个机构代表另一个�h或者另一个机构采取行动。在一些情况下�Q�一个客户不��x��者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之前起到中介的作用�?br />代理模式�l�某一个对象提供一个代理对象，�q�由代理对象控制对原对象的引用�?/font>

生活中的例子�Q�过�q�加班比较忙�Q�没�I�去买火车票�Q�这时可以打个电(sh��)话到附近的票务中心，叫他们帮你买张回家的火�R��，当然�q�会(x��)附加额外的劳务费。但要清楚票务中心自己�ƈ不卖��，只有火�R站才真正卖票�Q�票务中心卖�l�你的票其实是通过火�R站实现的。这点很重要�Q?/font>

上面�q�个例子�Q�你��是“客户”�Q�票务中心就�?#8220;代理角色”�Q�火车站�?#8220;真实角色”�Q�卖��称�?#8220;抽象角色”�Q?/font>

代理模式JAVA代码�C�Z��Q?br /> //抽象角色�Q�抽象类或接�?br />

源代�?/font>复制打印

interface Business
{
    void doAction();
}
interface Business { void doAction(); }
//真实角色�Q�真正实��C��业务逻辑接口

//代理角色�Q�自己�ƈ未实��C��务逻辑接口�Q�而是调用真实角色来实�?

源代�?/font>复制打印

class BusinessImplProxy implements Business
{
    private BusinessImpl bi;
    public void doAction()
    {
        if (bi==null)
        {
            bi = new BusinessImpl();
        }
        doBefore();
        bi.doAction();
        doAfter();
    }
    public void doBefore()
    {
        System.out.println("前置处理�Q?);
    }
    public void doAfter()
    {
        System.out.println("后置处理�Q?);
    }
}
//��试�c?/span>
class Test
{
    public static void main(String[] args)
    {
        //引用变量定义为抽象角色类�?/span>
        Business bi = new BusinessImplProxy();
        bi.doAction();
    }
}
class BusinessImplProxy implements Business { private BusinessImpl bi; public void doAction() { if (bi==null) { bi = new BusinessImpl(); } doBefore(); bi.doAction(); doAfter(); } public void doBefore() { System.out.println("前置处理�Q?); } public void doAfter() { System.out.println("后置处理�Q?); } } //��试�c? class Test { public static void main(String[] args) { //引用变量定义为抽象角色类�? Business bi = new BusinessImplProxy(); bi.doAction(); } }

所以，借助于JVM的支持，可以在运行时动态生成代理类�Q?#8220;代理角色”�Q�，我们��可以解决上�q�C��理模式中代码膨胀的问题，使用了动态代理后�Q?#8220;代理角色”��不用手动生成，而由JVM在运行时�Q�通过指定�c�d��载器、接口数�l�、调用处理程序这3个参数来动态生成�?/font>

动态代理模式JAVA代码�C�Z��Q?br />

源代�?/font>复制打印

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Method;
//抽象角色�Q�java动态代理的实现目前只支持接口，不支持抽象类
interface BusinessFoo
{
     void foo();
}
interface BusinessBar
{
    String bar(String message);
}
//真实角色�Q�真正实��C��务逻辑�Ҏ(gu��)��
class BusinessFooImpl implements BusinessFoo
{
    public void foo()
    {
        System.out.println("BusinessFooImpl.foo()");
    }
}
class BusinessBarImpl implements BusinessBar
{
    public String bar(String message)
    {
        System.out.println("BusinessBarImpl.bar()");
        return message;
    }
}
//动态角�Ԍ��(x��)动态生成代理类
class BusinessImplProxy implements InvocationHandler
{
    private Object obj;
    BusinessImplProxy() {
    }
    BusinessImplProxy(Object obj) {
        this.obj = obj;
    }
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable
    {
        Object result = null;
        doBefore();
        result = method.invoke(obj,args);
        doAfter();
        return result;
    }
    public void doBefore(){
        System.out.println("do something before Business Logic");
    }
    public void doAfter(){
        System.out.println("do something after Business Logic");
    }
    public static Object factory(Object obj)
    {
        Class cls = obj.getClass();
        return Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new BusinessImplProxy(obj));
    }
}
//��试�c?/span>
public class DynamicProxy
{
    public static void main(String[] args) throws Throwable
    {
        BusinessFooImpl bfoo = new BusinessFooImpl();
        BusinessFoo bf = (BusinessFoo)BusinessImplProxy.factory(bfoo);
        bf.foo();
        System.out.println();

        BusinessBarImpl bbar = new BusinessBarImpl();
        BusinessBar bb = (BusinessBar)BusinessImplProxy.factory(bbar);
        String message = bb.bar("Hello,World");
        System.out.println(message);
    }
}
import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; import java.lang.reflect.Method; //抽象角色�Q�java动态代理的实现目前只支持接口，不支持抽象类 interface BusinessFoo { void foo(); } interface BusinessBar { String bar(String message); } //真实角色�Q�真正实��C��务逻辑�Ҏ(gu��)�� class BusinessFooImpl implements BusinessFoo { public void foo() { System.out.println("BusinessFooImpl.foo()"); } } class BusinessBarImpl implements BusinessBar { public String bar(String message) { System.out.println("BusinessBarImpl.bar()"); return message; } } //动态角�Ԍ��(x��)动态生成代理类 class BusinessImplProxy implements InvocationHandler { private Object obj; BusinessImplProxy() { } BusinessImplProxy(Object obj) { this.obj = obj; } public Object invoke(Object proxy,Method method,Object[] args) throws Throwable { Object result = null; doBefore(); result = method.invoke(obj,args); doAfter(); return result; } public void doBefore(){ System.out.println("do something before Business Logic"); } public void doAfter(){ System.out.println("do something after Business Logic"); } public static Object factory(Object obj) { Class cls = obj.getClass(); return Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new BusinessImplProxy(obj)); } } //��试�c? public class DynamicProxy { public static void main(String[] args) throws Throwable { BusinessFooImpl bfoo = new BusinessFooImpl(); BusinessFoo bf = (BusinessFoo)BusinessImplProxy.factory(bfoo); bf.foo(); System.out.println(); BusinessBarImpl bbar = new BusinessBarImpl(); BusinessBar bb = (BusinessBar)BusinessImplProxy.factory(bbar); String message = bb.bar("Hello,World"); System.out.println(message); } }

�E�序��程说明�Q?br />       new BusinessFooImpl();创徏一�?#8220;真实角色”�Q�传递给工厂�Ҏ(gu��)��BusinessImplProxy.factory()�Q�进而初始化“调用处理�?#8221;——卛_��现InvocationHandler的类。�ƈ�q�回一个动态创建的代理�c�d��例，�׃��“代理角色”也必然实��C��“抽象角色”提供的业务逻辑�Ҏ(gu��)��Q�故可向下�{型�ؓ(f��)BusinessBar�Q��ƈ赋值给指向B(t��i)usinessBar�c�d��的引用bb�?br />       newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)�Ҏ(gu��)��q��序员来指定参数动态返回需要的代理�c�，而invoke(Object proxy, Method method, Object[] args) �Ҏ(gu��)��则是由JVM在运行时动态调用的。当执行“bb.bar("Hello,World");”�Ҏ(gu��)��Ӟ��JVM动态指�z?#8220;调用处理�?#8221;�Q�向外层 invoke传递参敎ͼ��q�调用method.invoke(obj,args)真正执行�Q?/font>

BusinessImplProxy.Factory静态方法用来动态生成代理类�Q?#8220;代理角色”�Q�，在运行时�Ҏ(gu��)��不同的业务逻辑接口BusinessFoo和BusinessBar�Q�在�q�行时分别动态生成了代理角色�?#8220;抽象角色”�?“代理角色”以及调用处理器（实现InvocationHandler接口的类�Q�这三者都可以改变�Q�所以说JAVA的动态代理十分强大�?/font>

计明�?/a> 2012-03-19 11:42 发表评论