代理模式和装饰器模式的区别

代理模式和装饰器模式非常相近，本文通过举例，针对俩者的区别进行探讨。

示例：孩子会吃饭

public interface IChild {

    void eat();
}

创建孩子类，实现吃饭接口：

public class Child implements IChild{

    @Override
    public void eat() {

        Log.e("TAG","孩子吃饭");
    }
}

如果孩子太小，不会做饭，连吃饭都需要引导，这时候就需要一个代理帮助孩子正确处理吃饭流程：

创建父母(代理)类：

public class Parent implements IChild{

    private Child child;

    private Parent(Child child){

        this.child = child;
    }

    @Override
    public void eat() {

        Log.e("TAG","父母做饭");
        child.eat();
        Log.e("TAG","父母收拾餐具");
    }
}

其中有些孩子长大了，学会了自己做饭、自己吃饭，生活独立自主：

创建孩子扩展(装饰)类：

public class ChildWrapper implements IChild{

    private Child child;

    public ChildWrapper(Child child){

        this.child = child;
    }

    @Override
    public void eat() {

        Log.e("TAG","孩子做饭");
        child.eat();
        Log.e("TAG","孩子收拾餐具");
    }
}

以上是代理和装饰的简化写法，如果不探究其表达的意义，俩者是没有区别的。

但是从实际意义出发，就可以看出俩者的区别：

代理，偏重因自己无法完成或自己无需关心，需要他人干涉事件流程，更多的是对对象的控制。
装饰，偏重对原对象功能的扩展，扩展后的对象仍是是对象本身。

这样说有些抽象，继续接着上例：

孩子长大了，需要去上学读书，新增学生接口：

public interface IStudent {

    void readBook();
}

孩子多了一重身份--学生，故要实现学生接口：

public class Child implements IChild, IStudent {

    @Override
    public void eat() {

        Log.e("TAG", "孩子吃饭");
    }


    @Override
    public void readBook() {

        Log.e("TAG", "孩子读书");
    }
}

此时，上述部分独立自主的孩子（装饰类），因为身份的增加，也要相应的扩展：

public class ChildWrapper implements IChild, IStudent {

    private Child child;

    public ChildWrapper(Child child) {

        this.child = child;
    }

    @Override
    public void eat() {

        Log.e("TAG", "孩子做饭");
        child.eat();
        Log.e("TAG", "孩子收拾餐具");
    }

    @Override
    public void readBook() {

        child.readBook();
    }
}

孩子成为了学生，但读书不是宅家里自学这么简单，需要有人教学，这显然不是父母的任务，而是学校的事情。于是新增学校代理：

public class School implements IStudent {

    private ArrayList<IStudent> students;

    public void addStudent(IStudent student) {

        students.add(student);
    }

    @Override
    public void readBook() {

        for (IStudent student : students) {
            
            student.readBook();
        }
    }
}

学校招收学生入学，独立自主的孩子作为装饰类，本质还是孩子，肩负学生这一身份，可以作为学生入学，而原先的父母作为代理类不能入学：

Child child = new Child();
ChildWrapper wrapper = new ChildWrapper(child);
Parent parent = new Parent(child);

School school = new School();
school.addStudent(wrapper);

通过上述例子，相信可以直观的看出：

孩子有吃饭和学习俩件任务，父母作为代理类之一，只能指导吃饭；学校作为代理类之一，只能指导学习。
对于某些独立自主的孩子（装饰类），它可能学习更加主动，吃完饭会主动收拾碗筷，但这些本来就是它原有功能的加强，它的本质仍然是孩子，依然可以享受父母、学校的代理帮助。

所以：
代理模式，注重对对象某一功能的流程把控和辅助。它可以控制对象做某些事，重心是为了借用对象的功能完成某一流程，而非对象功能如何。
装饰模式，注重对对象功能的扩展，它不关心外界如何调用，只注重对对象功能的加强，装饰后还是对象本身。

对于代理类，如何调用对象的某一功能是思考重点，而不需要兼顾对象的所有功能；
对于装饰类，如何扩展对象的某一功能是思考重点，同时也需要兼顾对象的其它功能，因为再怎么装饰，本质也是对象本身，要担负起对象应有的职责。

从上述例子也可以看出：
被装饰者一旦身份增加，作为装饰类，也需要相应的扩展，这必然造成编码的负担。

设计模式本身是为了提升代码的可扩展性，灵活运用即可，不必生搬硬套，非要分出个所以然来，装饰器模式和代理模式的区别即是如此。