大话设计模式-----(二)装饰模式、代理模式

ゝ一纸荒年。 2022-09-30 06:08 184阅读 0赞

## 装饰模式 ##

我所理解的装饰模式 就是说像穿衣服或者说是炒菜加调料又或者是煎饼果子加蛋和火腿肠的问题

先定义一个接口或者抽象类A，看她有没有初始的属性，有则用抽象类  
。然后定义一个抽象类B继承或实现。  
A中有最基本的方法调用。  
B主要是初始化，即构造方法中传入A。然后在后面的方法中用B中传入的A来调用方法。  
然后定义一系列CDEF子类继承B。这些CDEF就是生菜，鸡蛋，火腿肠。  
A是最基本的煎饼果子 B是所有添加其他东西的爸爸，他爸是最基本的A  
重要的是在CDEF中要重写B中的A的调用的方法。说是重写，其实就是添加自己特有的。  
先 Super.方法 再添加当前子类特有的方法。执行。就比如说在这个地方加上添加鸡蛋。是在原来最基本的煎饼果子的方法的基础上添加的。

然后在创建一个类E继承A 也就是说最基本的煎饼果子。  
这个煎饼果子是你的。  
然后老板问你，你要加什么。  
你说加两个鸡蛋一些辣椒  
就是将这个E类传入 CDEF中的添加鸡蛋的构造方法中。再将这个放入辣椒的构造方法中，返回的是煎饼果子B。添加了其他东西的煎饼果子  
所有的操作都是针对最基本的煎饼果子A。。后面的一个一个传入。利用多态。无论添加了鲍鱼还是海参他还是改变不了它是煎饼果子的基本身份。  
恩，具体代码参考的是  
[http://blog.csdn.net/jason0539/article/details/22713711][http_blog.csdn.net_jason0539_article_details_22713711]  
这位表哥的

package test;
    
    public class decoratortest1 { 
    
        public static void main(String[] args){
            Human person = new Person();
            Decorator decorator = new Decorator_two(
                    new Decorator_first(
                            new Decorator_zero(person)
                            )
                    );
            decorator.wearClothes();
            decorator.walkToWhere();
    
        }
    
    
    }
    
    //定义个Human接口//也就是最基本的煎饼果子
     interface Human{ 
        public void wearClothes();
        public void walkToWhere();
    
    }
    
    //抽象类实现接口//所有添加其他东西的煎饼果子
    
    abstract class Decorator implements Human{ 
        Human human;
        public Decorator(Human human){
            this.human = human;
        }
    
        public void wearClothes(){
            //因为实现接口 Human，并且传入的参数是Human接口。所以创建的对象human有这两个方法
            human.wearClothes();
    
        }
    
        public void walkToWhere(){
            human.walkToWhere();
        }
    
    }
    
    
    //继承抽象类装饰其功能//添加鸡蛋的煎饼果子。
    
    class Decorator_zero extends Decorator{ 
        //其父类是有参数的构造方法，所以要写，若父类是无参的构造方法，那么就不用写
        public Decorator_zero(Human human) {
            super(human);
    
        }
    
    public void goHome(){
        System.out.print("进房子。。");
    
    }
    public void findMap(){
        System.out.println("书房找找Map。。。。");
    }
    
    @Override
    public void wearClothes(){
        //继承抽象父类方法其实就是human调用wearClothes方法
        //然后在此基础上添加装饰就是当前继承类写的独有的方法，可以添加进去
        super.wearClothes();
        goHome();
    }
    
    @Override
    public void walkToWhere(){
        super.wearClothes();
        findMap();
    }
    
    
    }
    
    //另一个继承抽象类//添加生菜的煎饼果子。
    class Decorator_first extends Decorator{ 
    
        public Decorator_first(Human human) {
            super(human);
    
        }
    
        public void goClothespress(){
            System.out.println("去衣柜找找看..");
        }
    
        public void findPlaceOnMap(){
            System.out.println("在Map上找找");
        }
    
    @Override
    public void wearClothes(){
        super.wearClothes();
        goClothespress();
    }
    @Override
    public void walkToWhere(){
        super.walkToWhere();
        findPlaceOnMap();
    }
    
    }
    
    
    
    //添加辣椒的
    class Decorator_two extends Decorator{ 
    
        public Decorator_two(Human human) {
            super(human);
    
        }
    
        public void findClothes(){
            System.out.println("找到一件D&G");
        }
    
        public void findTheTarget(){
            System.out.println("在Map上找到神秘花园和城堡");
        }
    
        @Override
        public void wearClothes(){
            super.wearClothes();
            findClothes();
        }
        @Override
        public void walkToWhere(){
            super.walkToWhere();
            findTheTarget();
        }
    
    
    
        }
    
    //定义被装饰者。被装饰者有些自己的初始装饰//也就是老板给你做完了基本的煎饼果子，问你还要什么
    
    class Person implements Human{ 
    
        @Override
        public void wearClothes() {
            System.out.println("穿什么呢");
    
        }
    
        @Override
        public void walkToWhere() {
        System.out.println("去哪里呢");
    
        }
    
    }

![这里写图片描述][SouthEast]

每次每个添加东西的子类都会重写方法，并添加细节。  
所用的super每次都包含了上一个修饰类对其添加的细节。在此基础上再次添加。

@Override
    public void wearClothes(){
        //继承抽象父类方法其实就是human调用wearClothes方法
        //然后在此基础上添加装饰就是当前继承类写的独有的方法，可以添加进去
        super.wearClothes();
        goHome();
    }
    
    @Override
    public void walkToWhere(){
        super.wearClothes();
        findMap();
    }

Python的装饰器之前一直不是很理解。看了设计模式的装饰模式就秒懂啊  
知乎上大佬写的很好 链接  
[https://www.zhihu.com/question/26930016][https_www.zhihu.com_question_26930016]

不用重新赋值，减少语句。直接在前面@那个装饰类就可以了。还要注意执行的顺序。

每次读完一个设计模式都有一种这么写代码美到爆的感觉。  
很喜欢。一定要在以后的代码中用到设计模式。  
写代码不能只是完成了功能就结束了。而是要考虑到灵活性，扩展性。  
菜鸟初学，理解的很浅。若有错误望指出。谢谢

## 代理模式 ##

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

就像大话设计模式说的那样。就像表白一样。找个人代替你去表白。  
那个人就是代理。代替我表白的那个人和我有相同的方法。送妹子花。送妹子巧克力。表白妹子。不同的是我要表白的是那个妹子。我朋友要说是我要表白那个妹子~不然~~~

package test;
    
    public class daili { 
    
    
        public static void main(String[] args) {
            Meizi meizi  = new Meizi();
            meizi.setNameString("初恋");
            meizi.setAge(21);
            //这我很重要啊
            //朋友去找妹子，代替我去表白
            Friend friend = new Friend(meizi);
            friend.GiveFlowers();
            friend.GiveChocolate();
            friend.GiveLove();
    
    
        }
    
    }
    
    interface Man {
        public void GiveFlowers();
        public void GiveChocolate();
        public void GiveLove();
    }
    
    //我喜欢的妹子
    
    class Meizi{
        private String nameString;
        private int age;
        public String getNameString() {
            return nameString;
        }
        public void setNameString(String nameString) {
            this.nameString = nameString;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    
    }
    
    
    
    
    //我自己
    
    class Myself implements Man{
        Meizi meizi;
        //要传入我所要表白的对象就是那个妹子,写传入妹子的构造方法
        public Myself(Meizi meizi){
                this.meizi = meizi;
        }
    
        @Override
        public void GiveFlowers() {
            // TODO Auto-generated method stub
            System.out.println("给"+meizi.getNameString()+"花");
        }
    
        @Override
        public void GiveChocolate() {
            System.out.println("给"+meizi.getNameString()+"巧克力");
    
        }
    
        @Override
        public void GiveLove() {
            System.out.println("给"+meizi.getNameString()+"表白");
    
        }
    
    
    }
    //我朋友，代替我表白的那个
    
    class Friend implements Man{
        //我朋友没有自己的想法，只是将我的方法输出。
        //所以需要传入妹子。创建个我
        Myself myself;
        //对应的就要在构造方法中传入我
        public Friend(Meizi meizi){
            //传入妹子。将我初始化
            //他要代替我操作。那么他里面一定要有我啊，有我就要有
            myself = new Myself(meizi);
        }
    
    
        @Override
        public void GiveFlowers() {
            myself.GiveFlowers();
    
        }
    
        @Override
        public void GiveChocolate() {
            myself.GiveChocolate();
    
        }
    
        @Override
        public void GiveLove() {
            myself.GiveLove();
    
        }
    
    }

这就有点像我写了个情书。上面写对妹子表白。我需要的是妹子这个对象。对，我需要对象。  
然后我将这个情书交给我朋友。我要告诉他我喜欢的妹子是哪个。所以要朋友类要传入妹子。  
我朋友打开情书就是创建了我。然后读出情书的内容就是调用方法。但是只有我才能读。他把我召唤出来读。  
朋友只是做了一个代理。  
恩，比喻可能有点不恰当。还是看代码。  
开始我想的是将我传入朋友。然后在主类中创建妹子，创建我。创建朋友。传入我。  
然后发现，为什么要传入我。他认识我，我只要告诉他妹子是哪个就好了。在其内部创建我，传入妹子初始化我。让我调用我的方法。表白妹子 手动比心。

[http_blog.csdn.net_jason0539_article_details_22713711]: http://blog.csdn.net/jason0539/article/details/22713711
[SouthEast]: /images/20220708/d2cab3bb6f884c14be837f5b57fab826.png
[https_www.zhihu.com_question_26930016]: https://www.zhihu.com/question/26930016