设计模式(二) | 装饰模式---穿什么有这么重要?

category: 大话设计模式

装饰模式

装饰模式之前的面向对象原则介绍

  • 单一职责原则:就一个类而言,应该仅有一个引起它变化的原因。也就是说功能要单一。

  • 优点: 灵活性,可复用性。

  • 如果一个类承担的职责太多,就等于把这些职责耦合在一起,一个职责的变化可能会削弱或者阻碍其他职责能力,这种耦合会导致脆弱的设计,当变化发生时,设计会发生意想不到的变化。

  • 开放封闭原则:软件应该可以扩展,但不可以修改。对于扩展是开放的,对于更改是封闭的。

  • 面对需求,对程序的改动是通过增加新代码进行的,而不是更改现有代码,这就是开放封闭原则的精神所在。

  • 优点:可扩展 可复用 灵活性好

  • 依赖倒转原则:抽象不应该依赖细节,细节不应该依赖抽象。针对对接口编程,不要对实现编程。即高层模块不依赖底层模块,底层模块不依赖高层模块。

  • 其实就是谁也不依赖谁,除了约定的接口,大家都可以灵活自如。 0?wx_fmt=png

  • 里氏代换原则:子类型必须能够替换掉他们的父类型,只有当子类可以替换掉父类,软件单位功能不受影响时,父类才能真正倍复用。

装饰模式

  • 装饰模式:动态地给一个对象添加一些额外的职责,就增加功能来说,装饰模式比生成子类更为灵活。

  • 装饰模式是为已有功能动态的添加更多功能的一种方式。0?wx_fmt=png

  • 代码实现:

  1.    //需要被装饰的对象

  2.    public class Person {

  3.        private String name;

  4.        public Person(String name) {

  5.            super();

  6.            this.name = name;

  7.        }

  8.        public Person() {

  9.            super();

  10.        }

  11.        public void show(){

  12.            System.out.println("装扮的"+name);

  13.        }

  14.    }

  15.    //功能的抽象类

  16.    public class Finery extends Person{

  17.        protected Person component;

  18.        //打扮

  19.        public void Decorate(Person component){

  20.            this.component = component;

  21.        }

  22.        @Override

  23.        public void show(){

  24.            if(component != null){

  25.                component.show();

  26.            }

  27.        }

  28.    }

  29.    //继承功能类

  30.    public class BigTrouser extends Finery {

  31.        @Override

  32.        public void show(){

  33.            System.out.println("垮裤");

  34.            super.show();

  35.        }

  36.    }

  37.    //继承功能类

  38.    public class TShirts extends Finery {

  39.        @Override

  40.        public void show(){

  41.            System.out.println("大T恤");

  42.            super.show();

  43.        }

  44.    }

  45.    //继承功能类

  46.    public class WearSneakers extends Finery {

  47.        @Override

  48.        public void show(){

  49.            System.out.println("破球鞋");

  50.            super.show();

  51.        }

  52.    }

  53.    //继承功能类

  54.    public class WearSuit extends Finery{

  55.        @Override

  56.        public void show(){

  57.            System.out.println("西装");

  58.            super.show();

  59.        }

  60.    }

  61.    //动态给对象添加功能

  62.    public class Test {

  63.        public static void main(String[] args) {

  64.            Person xc = new Person("小菜");

  65.            System.out.println("第一种装扮:");

  66.            WearSneakers w = new WearSneakers();

  67.            WearSuit ws = new WearSuit();

  68.            BigTrouser bt = new BigTrouser();

  69.            /*

  70.             * 首先实例化person对象

  71.             * 再用WearSneakers类包装person

  72.             * 再用WearSuit类来包装WearSneakers对象

  73.             * 再用BigTrouser类包装WearSuit对象

  74.             * 最终执行BigTrouser的show方法。

  75.             *

  76.             */

  77.            w.Decorate(xc);  

  78.            ws.Decorate(w);

  79.            bt.Decorate(ws);

  80.            bt.show();

  81.        }

  82.    }

输出结果:

  1.    第一种装扮:

  2.    垮裤

  3.    西装

  4.    破球鞋

  5.    装扮的小菜

  6. 什么时候使用装饰模式:

当系统需要新功能时,是向旧的类中添加新的代码,这些新代码通常装饰了原有的核心职责或主要行为。

把每个要装饰的功能放在单独的类中,并让这个类包装它所有装饰的对象。

优点:

把类的核心职责和装饰功能区分开来,去除相关类中重复的装饰逻辑。

简化原有类。

往期回顾

设计模式(一) | 啥是工厂模式和策略模式?

注:若手机上部分代码显示不清楚,可以选择点击左下角“阅读原文”。

0?wx_fmt=png

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值