设计模式之命令模式

1.概念：命令模式属于对象的行为模式，把外围设备、或者第三方的api、或者命令，把他们封装成一个对象，供外部调用，达到发出命令者和接收者对象的完全解耦

2.类图

3.组成部分：

    Command类：是一个抽象类，类中对需要执行的命令进行声明，一般来说要对外公布一个execute方法用来执行命令。
    ConcreteCommand类：Command类的实现类，对抽象类中声明的方法进行实现。
    Client类：最终的客户端调用类。
    Invoker类：调用者，负责调用命令。
    Receiver类：接收者，负责接收命令并且执行命令。

4.通用代码

/**
 *  @Author: fc
 *  @Date: 16:33 2017/10/16
 */
interface Command {
    fun execute()
}

class ConcreteCommand(receiver: Receiver) :Command {

    //持有接收者对象
    private var mReceiver :Receiver ?= receiver

    override fun execute() {
        //通常会转调接收者对象的相应方法，让接收者来真正执行功能
        mReceiver?.action()
    }
}

/**
 *  @Author: fc
 *  @Date: 16:32 2017/10/16
 *
 *  接收者，负责接收命令并且执行命令。
 */
class Receiver {
    fun action(){
        println("执行操作")
    }
}

/**
 *  @Author: fc
 *  @Date: 16:40 2017/10/16
 *
 *  调用者，负责调用命令。
 */
class Invoker(command:Command) {
    private var mCommand:Command ?= command

    fun action(){
        mCommand?.execute()
    }
}

fun main(args: Array<String>) {

    //创建接收者
    val receiver = Receiver()
    //创建命令对象，设定它的接收者
    val command:Command = ConcreteCommand(receiver)
    //创建调用者，把命令对象设置进去
    val invoker = Invoker(command)
    //执行方法
    invoker.action()

}

运行结果：

   执行操作

可以看出，命令模式其实是把一个命令分为了三个步骤去执行，使发出命令者和接收者对象完全不关心对方是怎么操作的

5.优点：
    1、封装性好：每个命令都被封装起来，对于客户端来说，需要什么功能就去调用相应的命令，而无需知道命令具体是怎么执行的
    2、扩展性好：只需要实现新的命令对象，然后在装配的时候，把具体的实现对象设置到命令对象中，然后就可以使用这个命令对象，已有的实现完全不用变化。

6.缺点：
    命令如果很多，特别是很多简单的命令，实现起来就几行代码的事，而使用命令模式的话，不用管命令多简单，都需要写一个命令类来封装。

7.demo延伸
   比如一个人要去深圳湾，他只需要发送命令，不用关心怎么实施，只要最后到达深圳湾就好了，他只负责发送命令，整个过程是交由外部去负责实施的

/**
 *  @Author: fc
 *  @Date: 8:56 2017/11/2
 *  
 *  接受对象
 */
class VehicleReceiver {
    fun running(){
        println("跑步去")
    }
    fun rideBike(){
        println("骑单车去")
    }
}

interface Command {
    fun execute()
}

class RunningCommand (vehicleReceiver:VehicleReceiver):Command{

    private val mVehicleReceiver:VehicleReceiver ?= vehicleReceiver
    override fun execute() {
        mVehicleReceiver?.running()
    }

}

class BicycleCommand (vehicleReceiver:VehicleReceiver):Command{

    private val mVehicleReceiver:VehicleReceiver ?= vehicleReceiver
    override fun execute() {
        mVehicleReceiver?.rideBike()
    }

}

class People {

    private var runningCommand: RunningCommand? = null
    private var bicycleCommand: BicycleCommand? = null

    fun setRunningCommand(command: RunningCommand) {
        runningCommand = command
    }

    fun setBicycleCommadn(command: BicycleCommand) {
        bicycleCommand = command
    }

    fun run() {
        runningCommand?.execute()
    }

    fun bicycle() {
        bicycleCommand?.execute()
    }
}

fun main(args: Array<String>) {

    //创建接受者对象
    val vehicleReceiver = VehicleReceiver()
    //创建命令对象
    val runningCommand = RunningCommand(vehicleReceiver)
    val bicycleCommand = BicycleCommand(vehicleReceiver)
    //创建执行者对象
    val people = People()
    people.setRunningCommand(runningCommand)
    people.setBicycleCommadn(bicycleCommand)
    //执行命令
    people.run()
    people.bicycle()

}

执行结果：

    跑步去
    骑单车去