设计模式（四）

4.4 代理模式

为其他对象提供一种代理以控制对这个对象的访问。

使用场景：

• 远程代理：为一个对象在不同的地址空间提供局部代表，这样可以隐藏一个对象存在于不同地址空间的事实。
• 虚拟代理：根据需要创建开销很大的对象，通过它来存放实例化需要很长时间的真实对象。（浏览器打开html网页，里面有很多的文字以及图片，文字是可见的，图片则是一张一张下载后才能看到的，未打开的图片框，就是通过虚拟代理来代替了真实的图片，代理存储了图片的路劲以及尺寸）。
• 安全代理：用来控制真实对象访问时的权限。
• 智能指引：当调用真实的对象时，代理处理另外一些事（如：计算真实对象的引用次数，这样当该对象没有引用时，可以自动释放它）

代理模式就是在访问对象时，引入一定程度的间接性，因为这种间接性，可以附加多种用途。

public class Test {
    public static void main(String[] args) {
        Proxy proxy = new Proxy();
        proxy.request();
        System.out.println("***********");
        Girl mm = new Girl();
        mm.setName("B");
        Helper helper = new Helper(mm);
        helper.GiveDolls();
        helper.GiveFlowers();
        helper.GiveChocolate();

    }
}

abstract class Subject {
    public abstract void request();
}

class RealSubject extends Subject {

    @Override
    public void request() {
        System.out.println("真实类");
    }
}

class Proxy extends Subject {

    private RealSubject realSubject;

    @Override
    public void request() {
        System.out.println("代理：");
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        realSubject.request();
    }
}

//代理模式场景模拟：A追求B，通过C给B送礼物
class Girl {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

interface GiveGift {
    void GiveDolls();

    void GiveFlowers();

    void GiveChocolate();
}

class Pursuit implements GiveGift {

    private Girl mm;

    public Pursuit(Girl mm) {
        this.mm = mm;
    }

    @Override
    public void GiveDolls() {
        System.out.println(mm.getName() + "，A送你洋娃娃");
    }

    @Override
    public void GiveFlowers() {
        System.out.println(mm.getName() + "，A送你鲜花");
    }

    @Override
    public void GiveChocolate() {
        System.out.println(mm.getName() + "，A送你巧克力");
    }
}

class Helper implements GiveGift {

    private Pursuit gg;

    public Helper(Girl mm) {
        gg = new Pursuit(mm);
    }

    @Override
    public void GiveDolls() {
        System.out.println("C帮助：");
        gg.GiveDolls();
    }

    @Override
    public void GiveFlowers() {
        System.out.println("C帮助：");
        gg.GiveFlowers();
    }

    @Override
    public void GiveChocolate() {
        System.out.println("C帮助：");
        gg.GiveChocolate();
    }
}

4.5 建造者模式

将一个复杂对象的构建与它的表示分离，使得同样的构建流程可以创建不同的表示。使用建造者模式，那么用户就只需要指定需要建造的类型就可以得到它们，而具体建造的过程和细节就不需要知道。（将产品的内部表象和产品生成过程分割）。建造者模式当在创建复杂对象的算法应该独立于对象的组成部分以及它们的装配方式时适用的模式。

使用场景：用于创建一些复杂的对象，这些对象内部构建间的构造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。

建造者隐藏该产品如何组装，所以如果需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。

各个类的作用：

1. Builder建造产品的各个部件指定的抽象接口；

2. ConcreteBuilder具体的建造者，实现Builder接口，构造和装配各个部件；

3. Director构建一个使用Builder接口的对象。

public class Test {
    public static void main(String[] args) {
        Director director = new Director();
        Builder b1 = new ConcreteBuilder1();
        Builder b2 = new ConcreteBuilder2();
        director.construct(b1);
        Product p1 = b1.getResult();
        p1.show();

        director.construct(b2);
        Product p2 = b2.getResult();
        p2.show();
    }
}

class Product {
    List<String> parts = new ArrayList<>();

    public void add(String part) {
        parts.add(part);
    }

    public void show() {
        System.out.println("产品 创建：");
        for (String part : parts) {
            System.out.println(part);
        }
    }
}

//抽象建造者
abstract class Builder {
    public abstract void buildPartA();

    public abstract void buildPartB();

    public abstract Product getResult();
}

//具体建造者
class ConcreteBuilder1 extends Builder {

    private Product product = new Product();

    @Override
    public void buildPartA() {
        product.add("部件A");
    }

    @Override
    public void buildPartB() {
        product.add("部件B");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

class ConcreteBuilder2 extends Builder {

    private Product product = new Product();

    @Override
    public void buildPartA() {
        product.add("部件X");
    }

    @Override
    public void buildPartB() {
        product.add("部件Y");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

//指挥者，用来指挥建造过程
class Director {
    public void construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
    }
}