大话设计者模式 part2

Machine190

已于 2022-03-06 18:33:50 修改

阅读量113

点赞数

文章标签：学习 java 开发语言

于 2022-03-06 18:33:06 首次发布

本文链接：https://blog.csdn.net/weixin_64780806/article/details/123314715

版权

第五章装饰者模式

1. 特点

1. 装饰类和被装饰类都源于同一个接口或继承同一个类
2. 装饰类的左右是将父类方法重写后,在重写的方法中调用被装饰者的方法从而达到为被装饰者功能的扩展
3. 被装饰类可以被装饰类一层层包裹从而达到多种功能叠加.
4. 装饰者模式最大的好处是将类的核心职责和装饰功能分开,从而确保封闭-开放原则被很好的运用
5. 装饰类只是对被装饰类类某一功能的扩展增强,并没有改变类方法的本质

在这里插入图片描述

2. 完整代码分析

父类接口

public abstract class Person {
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public void show(){}
}

被装饰类


import com.xinma.Person;

public class User extends Person {
    public User() {
    }

    public User(String name) {
        super(name);
    }

    @Override
    public void show() {
        System.out.println("用户是:"+ super.getName());
    }
}

3.装饰类

//装饰类接口
public abstract class DecorationPerson extends Person {

    private Person person;
    public DecorationPerson() {
    }

    public DecorationPerson(Person person) {
        this.person = person;
    }

    @Override
    public void show() {
        person.show();
    }
}

//装饰类的实现类
public class DecorationPersonShirt extends DecorationPerson{

    @Override
    public void show() {
        super.show();
        addShirt();
    }

    public DecorationPersonShirt() {
    }

    public DecorationPersonShirt(Person person) {
        super(person);
    }

    public void addShirt(){
        System.out.println("add T - shirt");
    }
}

// 装饰类的实现类
public class DecorationPersonShoe extends DecorationPerson{

    @Override
    public void show() {
        super.show();
        addShe();
    }

    public DecorationPersonShoe() {
    }

    public DecorationPersonShoe(Person person) {
        super(person);
    }

    public void addShe(){
        System.out.println("add good shoe");
    }
}

第六章代理模式

1.特点

1.代理类通过控制被代理类对象从而达到对某一流程控制的目的. 代理对象并不在意被代理对象的方法功能,而是通过被代理类的功能调用而完成代理类自身功能需求
2.被代理类对象被隐藏在代理类中,所以调用者并不知道自己具体调用的是哪一个代理对象.
3.代理模式是一种控制其他对象的一种方式
4. 代理类和被代理类需要有一个共同借口

在这里插入图片描述

2. 完整代码分析

这一部分是结合装饰者模式一起进行的, 因为两个设计模式在一些情况下代码的表现形式是相同的. 如果不考虑业务逻辑,区别没有很大.看了很多大神的解说,下面这个用学生案例说明真的是非常好,在此借用一下.

// 示例：孩子会吃饭
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);

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

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

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

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

作者：Parallel_Lines
链接：https://www.jianshu.com/p/c06a686dae39
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

*/

3. 装饰者模式和代理模式区别

1. 装饰者模式着重于功能的扩展,但是被装饰类本质没有改变,所以可以多层嵌套
2. 代理模式着重于控制对象,从而调用某一方能而达到完成某一流程的目的. 当对象被代理后代理对象一般不能嵌套,本质可能会有变动.
3. 静态代理中一般会把实现类因此在代理对象中,在编译时就已经确认要调用的对象 ( public proxy(被代理类父接口 参数){
参数 = new 被代理类对象;
}) . 同时因为调用者并不知道也不关心所调用的对象,可以不向客户端暴露调用内容.但是一旦要扩展静态代理需要改变原有类,不符合封闭原则,故而动态代理又被引申出来.可以在运行时调用被代理类对象的模式,动态代理.
4. 两者有时代码变现形式可能一致,但是所代表的逻辑关系却大不相同.

象功能的加强，装饰后还是对象本身。

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

作者：Parallel_Lines
链接：https://www.jianshu.com/p/c06a686dae39
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。


#### 3. 装饰者模式和代理模式区别

```markdown
1. 装饰者模式着重于功能的扩展,但是被装饰类本质没有改变,所以可以多层嵌套
2. 代理模式着重于控制对象,从而调用某一方能而达到完成某一流程的目的. 当对象被代理后代理对象一般不能嵌套,本质可能会有变动.
3. 静态代理中一般会把实现类因此在代理对象中,在编译时就已经确认要调用的对象 ( public proxy(被代理类父接口 参数){
参数 = new 被代理类对象;
}) . 同时因为调用者并不知道也不关心所调用的对象,可以不向客户端暴露调用内容.但是一旦要扩展静态代理需要改变原有类,不符合封闭原则,故而动态代理又被引申出来.可以在运行时调用被代理类对象的模式,动态代理.
4. 两者有时代码变现形式可能一致,但是所代表的逻辑关系却大不相同.

Machine190

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
大话设计者模式 part2

第五章装饰者模式1. 特点1. 装饰类和被装饰类都源于同一个接口或继承同一个类2. 装饰类的左右是将父类方法重写后,在重写的方法中调用被装饰者的方法从而达到为被装饰者功能的扩展3. 被装饰类可以被装饰类一层层包裹从而达到多种功能叠加.4. 装饰者模式最大的好处是将类的核心职责和装饰功能分开,从而确保封闭-开放原则被很好的运用5. 装饰类只是对被装饰类类某一功能的扩展增强,并没有改变类方法的本质2. 完整代码分析父类接口public abstract class Person {
复制链接

扫一扫