接口-工厂模式-代理模式

    —程序1：简单的接口功能—

package com.liaojianya.chapter2;
/**
 * 编写程序实现一个usb接口，定义设备来使用这个接口，从而计算机可以调用具有usb接口的设备。
 */
public class InterfaceStandards
{
    public static void main(String[] args)
    {
        Computer com = new Computer();
        com.plugin(new Flash());//在电脑上使用U盘
        com.plugin(new Print());//在电脑上使用打印机
    }

}
//定义USB接口标准
interface USB
{
    public void work();
}
//在电脑上使用具有USB接口的设备
class Computer
{
    public void plugin(USB usb)
    {
        usb.work();
    }
}
//打印机实现USB接口标准
class Print implements USB
{
    public void work()
    {
        System.out.println("打印机用USB接口，连接开始工作");
    }
}
//U盘实现USB接口标准
class Flash implements USB
{
    public void work()
    {
        System.out.println("U盘使用USB接口，连接开始工作");
    }
}

　　运行结果：

U盘使用USB接口，连接开始工作
打印机用USB接口，连接开始工作

　　分析：

　　按照固定的USB接口标准，可以定义无数多个子类，并且这些子类可以在电脑上使用。

　—程序2：工厂模式—

package com.liaojianya.chapter2;
/**
 *
 */
public class SimpleFactoryTest
{
    public static void main(String[] args)
    {
        Animal an = Factory.getInstance("lion");
        an.behaviour();
        an = Factory.getInstance("bird");
        an.behaviour();
    }

}
//定义一个动物标准
interface Animal
{
    public void behaviour();
}

class Lion implements Animal
{
    public void behaviour()
    {
        System.out.println("狮子跑");
    }
}

class Bird implements Animal
{
    public void behaviour()
    {
        System.out.println("鸟儿飞");
    }
}
class Factory
{
    public static Animal getInstance(String className)
    {
        if("lion".equals(className))
        {
            return new Lion();
        }
        if("bird".equals(className))
        {
            return new Bird();
        }
        return null;
    }
}

　　运行结果：

狮子跑
鸟儿飞

　　分析：

　　1）根据参数的内容实例化不同的子类，参数内容为“lion”，实例化的就是Lion类，参数内容为“bird”，实例化的就是Bird类，所以输出内容也不同。

　　2）此时的程序，客户端没有呵呵具体的子类耦合在一起，这样，如果再有更多的Animal接口的子类粗线，只需要修改Factory类即可，即所有的接口对象都是通过Factory类取得。

　—程序3：代理设计模式—

package com.liaojianya.chapter2;
/**
 * 设计代理模式，用红酒厂商、代理商、客户来阐释代理的作用
 */
public class ProxyTest
{
    public static void main(String[] args)
    {
        Subject sub = new ProxySubject();//客户直接找代理，子类为接口实例化
        sub.request();
    }

}
//代理请求
abstract class Subject
{
    abstract public void request();
}
//真实角色（红酒厂商）
class RealSubject extends Subject
{
    public void request()
    {
        System.out.println("我是红酒厂商，欢迎品尝购买！");
    }
}
//代理角色（代理商）
class ProxySubject extends Subject
{
    private RealSubject realSubject;
    public void request()
    {
        preRequest();
        if(realSubject == null)
        {
            realSubject = new RealSubject();
        }
        realSubject.request();
        postRequest();
    }
    private void preRequest()
    {
        System.out.println("前期宣传活动，免费品尝");
    }
    private void postRequest()
    {
        System.out.println("结束宣传活动，付费购买");
    }
}

　　　运行结果：

前期宣传活动，免费品尝
我是红酒厂商，欢迎品尝购买！
结束宣传活动，付费购买

　　分析：代理设计模式的核心组成部分：一个接口两个子类，一个子类负责真实的业务操作功能，如红酒厂商；一个子类负责完成与真实业务相关的操作，如红酒代理商。

—工厂模式与代理模式—

        工厂模式：是提供创建接口实例逻辑的封装，目的是让其他类依赖于接口和工厂，而非具体的实现类。同样的目的可以使用依赖注入实现，如Spring之类的技术。

        代理模式：是增加中间层，从而在中间进行额外的逻辑（类似于中介租房，租房过程中所处理的事情都有中介帮你解决了），比如懒惰初始化，比如封装远程调用，比如可以增加访问控制。