swift设计模式学习 - 装饰模式代码大全

装饰模式

在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能。它是通过创建一个包装对象,也就是装饰来包裹真实的对象。

装饰模式的特点

  1. 装饰对象和真实对象有相同的接口。这样客户端对象就能以和真实对象相同的方式和装饰对象交互。
  2. 装饰对象包含一个真实对象的引用(reference)
  3. 装饰对象接受所有来自客户端的请求。它把这些请求转发给真实的对象。
  4. 装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时,不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中,通常是通过继承来实现对给定类的功能扩展。

装饰模式的基本实现

上图是最基本的装饰模式的结构图,下面将用Swift代码来实现一个基本装饰模式:

1).先写一个Component接口

protocol Component {
    func operation()
}
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

2).写一个具体的Component对象

class ConcreteComponent: Component {
    func operation() {
        // 具体操作的实现
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5

3).写一个装饰抽象类

class Decorator: Component {
    var component: Component?
    func operation() {
        component?.operation()
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

4).写具体的装饰对象

// 装饰对象A
class ConcreteDecoratorA: Decorator {
    private var addedState: String?
    override func operation() {
        super.operation()
        addedState = "ConcreteDecoratorA独有的功能,用来区分ConcreteDecoratorB"
        // 具体装饰对象A的操作
    }
}
// 装饰对象B
class ConcreteDecoratorB: Decorator {
    override func operation() {
        super.operation()
        addedBehavior()
        // 具体装饰对象B的操作
    }
    // ConcreteDecoratorB独有的方法,用来区分ConcreteDecoratorA
    private func addedBehavior() {

    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

通过以上代码我们就能简单了解装饰模式的基本实现于过程,它的主要的目的就是:在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能,就像以上示例代码一样,通过ConcreteDecoratorAConcreteDecoratorB去扩展ConcreteComponent这个对象的功能,这样不用去改变ConcreteComponent这个类的源文件,也可以达到扩展的效果。

用装饰模式解决实际问题(买车选配的问题)

下面通过一个实际的例子来看看,比如我们在买车的时候一般会选配很多配件,下面我们通过策略模式来实现这一过程,下上个结构图:

下面贴上代码:

// Component
protocol Car {
    // 多少钱
    func howMuch()-> Int
    // 展示装配的配件
    func showParts()
}

// ConcreteComponents
class Suv: Car {
    init(owner: String) {
        print("\(owner)买了一辆Suv,10W")
    }

    func howMuch() -> Int {
        return 10
    }

    func showParts() {}
}

class Mpv: Car {
    init(owner: String) {
        print("\(owner)买了一辆Mpv,15W")
    }
    func howMuch() -> Int {
        return 15
    }
    func showParts() {}
}

// Decorator
class CarParts: Car {
    var car: Car?
    func howMuch() -> Int {
        return car?.howMuch() ?? 0
    }
    func showParts() {
        car?.showParts()
    }
    func decorator(_ car: Car) -> Car {
        self.car = car
        return self
    }
}

// ConcreteDecorators
class Sofa: CarParts {
    override func howMuch() -> Int {
        return super.howMuch() + 1
    }
    override func showParts() {
        super.showParts()
        print("选配了真皮沙发,1W")
    }
}

class Safety: CarParts {
    override func howMuch() -> Int {
        return super.howMuch() + 3
    }

    override func showParts() {
        super.showParts()
        print("选配了全套安全系统,3W")
    }
}

class Engine: CarParts {
    override func howMuch() -> Int {
        return super.howMuch() + 5
    }
    override func showParts() {
        super.showParts()
        print("选配了V8发动机,5W")
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77

下面我们使用一下以上代码看看:

//wcl买一辆suv
var suv: Car = Suv(owner: "wcl")
//装配沙发
suv = Sofa().decorator(suv)
//装配发动机
suv = Engine().decorator(suv)
//装配安全系统
suv = Safety().decorator(suv)
suv.showParts()
print("一共花了\(suv.howMuch())W")
print("\n")
//wcl买一辆mpv
var mpv: Car = Mpv(owner: "wcl")
//装配发动机
mpv = Engine().decorator(mpv)
//装配安全系统
mpv = Safety().decorator(mpv)
mpv.showParts()
print("一共花了\(mpv.howMuch())W")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

以下是代码打印的结果:

wcl买了一辆Suv,10W
选配了真皮沙发,1W
选配了V8发动机,5W
选配了全套安全系统,3W
一共花了19W

wcl买了一辆Mpv,15W
选配了V8发动机,5W
选配了全套安全系统,3W
一共花了23W
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

这样就用装饰模式简单了实现了一下这个过程,在不改变SuvMpv这两个类的源文件的情况下对它进行操作。

总结

我们先看看装饰模式的优点:

  1. 可以将类中装饰功能从类中搬出移除,这样可以简化原有的类
  2. 有效的将核心职责和装饰功能区分开来,而且可以除去相关类中重复的装饰逻辑

装饰模式的缺点:

  1. 装饰模式虽然扩展性较高,类的数量略多,如何取舍可扩展性和简洁性是个问题,有所选择就要有所牺牲
  2. 很难搞清楚一个类究竟被装饰了多少层,可能是1层,也可能是100层
时间: 2024-10-29 19:05:53

swift设计模式学习 - 装饰模式代码大全的相关文章

swift设计模式学习 - 装饰模式

移动端访问不佳,请访问我的个人博客 装饰模式 在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能.它是通过创建一个包装对象,也就是装饰来包裹真实的对象. 装饰模式的特点 装饰对象和真实对象有相同的接口.这样客户端对象就能以和真实对象相同的方式和装饰对象交互. 装饰对象包含一个真实对象的引用(reference) 装饰对象接受所有来自客户端的请求.它把这些请求转发给真实的对象. 装饰对象可以在转发这些请求以前或以后增加一些附加功能.这样就确保了在运行时,不用修改给定对象的结构就可以在外

设计模式学习-装饰模式

1.什么是装饰模式 装饰模式,在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能.它是通过创建一个包装对象,也就是装饰来包裹真实的对象.动态地给一个对象添加一些额外的职责.这样是能够把类中的装饰功能从类中搬移出去,这样可以简化原有的类.有效地把类的核心功能和装饰功能区分开了. 2.装饰模式的实现 在本例子中,举例最常见的人穿衣服的例子,首先我们定义这样一个Person的基类,如下: #include <cstdio> #include <string> #include

《代码大全》学习摘要(五)软件构建中的设计(下)

这次的学习内容主要是设计过程中的启发式方法和设计实践中的一些经验. 对于具体的编程工作来说,期待确定性的行为是很正常的,由于软件设计是非确定性的,灵活熟练地运用一组有效的启发方法(试探法),便成了合理的软件设计的核心工作. 1.在确定设计方案时,首选且最流行的方法是面向对象的方法,此方法的要点是辨别现实世界中的对象以及人造的对象.这个过程分为以下几步:辨识对象及其属性.确定可以对各个对象进行的操作.确定各个对象能对其他对象进行的操.确定对象的哪些部分对其他对象可见.定义每个对象的公开接口. 2.

Java设计模式学习记录-装饰模式

前言 装饰模式也是一种结构型模式,主要是目的是相对于类与类之间的继承关系来说,使用装饰模式可以降低耦合度.JDK中有不少地方都使用到了装饰模式,例如Java的各种I/O流,javax.swing包中一些图形界面构件功能的增强等地方都运用了装饰模式. 装饰模式 定义 装饰模式的定义是:在不改变原类文件以及不使用继承的情况下,动态的扩展一个对象的功能.装饰模式是通过创建一个包装对象来实现的,也就是用装饰来包裹真实的对象. 举例 还是老规矩,举例说明,在给亲朋好友过生日时会买生日蛋糕,然后生日蛋糕又有

《代码大全》学习摘要(四)伪代码编程过程

今天阅读的是<代码大全>的第9章--"伪代码编码过程".看罢本章,我对于编程的方式方法又有了新的认识,可谓是我觉得收获最大的一章,决心按书中的方法去自己实践一下. 正如作者在这一章末尾提到的,"这本书的一个目的就是告诉你怎样脱离那种先东拼西凑,然后通过运行来看代码是否工作的怪圈"(就我自己写代码的过程来看,与这种方式非常相似),在没有完全想好类和子程序的具体功能和流程就开始编码的结果就是做出一个勉强能运行的程序,它可能漏洞百出,但你不知道问题究竟出在哪里

代码大全学习笔记(什么是构建)

  构建有时也被认为是"coding"或者"programing".编码算不上是最贴切的词,因为它有一种"把已经存在的设计机械化的翻译成计算机语言"的意味,而构建并不是机械化的,需要可观的创造力和判断力,人们常常用编程代替构建.   构建的步骤: 1.验证前面的工作已经完成(如定义问题,需求分析). 2.确定如何去测试所写的代码. 3.设计并编写类或者子程序. 4.创建并命名变量和具名常量. 5.选择控制结构,组织语句块. 6.对你的代码进行单元

学习大话设计模式06_装饰模式

装饰模式(Decorator): 动态地给一个对象添加一些额外的职责,就增加功能来说,装饰模式比生成子类更为灵活. 1 /** 2 * Component 是定义一个对象接口,可以给这些对象动态地添加职责 3 * @author Monica 4 * 5 */ 6 public abstract class Component { 7 public abstract void Operation(); 8 } 9 10 11 /** 12 * ConcreteComponent 是定义了一个具体

《从零开始学Swift》学习笔记(Day 64)——Cocoa Touch设计模式及应用之目标与动作

原创文章,欢迎转载.转载请注明:关东升的博客 目标(Target)与动作(Action)是iOS和OS X应用开发的中事件处理机制.   问题提出 如图所示是一个ButtonLabelSample案例设计原型图,其中包含一个标签和一个按钮,当点击按钮的时候,标签文本会从初始的Label替换为HelloWorld. ButtonLabelSample案例首先要解决的问题是:按钮点击事件后有谁负责响应事件?谁进行事件处理?要答这个问题,可以打开ButtonLabelSample案例故事板文件Main

设计模式学习总结系列应用实例

1.单例模式 应用实例:1.一个党只能有一个主席.2.Windows是多进程多线程的,在操作一个文件的时候,就不可避免地出现多个进程或线程同时操作一个文件的现象,所以所有文件的处理必须通过唯一的实例来进行.3.一些设备管理器常常设计为单例模式,比如一个电脑有两台打印机,在输出的时候就要处理不能两台打印机打印同一个文件. 2.工厂模式 应用实例:1.你需要一辆汽车,你可以直接从工厂里面提货,而不用去管这辆汽车是怎么做出来的,以及这个汽车里面的具体实现 2.Hibernate换数据库只需换方言和驱动