之前学习的是单例模式。但里模式就是只有一个对象被实例化，如注册表等。单例模式有几种实现方式
一是用同步锁创建一个私有的构造器，和一个同步的公开的方法。这种方式简便，但是性能不是很好，使用的是同步锁（重量级的）。
二是创建一个静态产量直接new一个对象。也是有私有的构造器不让对象创建。通过公开的方法返回静态常量new的对象，保证对象只有一个。这种方法在jvm创建的时候就会产生对象，如果不使用该对象，则会产生浪费
三是用volatile创建静态属性。用私有构造器不让对象创建，通过公开的get方法获取对象，获取的时候判断对象是否存在，如果不存在则用同步锁防止多线程出现错误。最后返回对象。这种是常用的方法。
一、对于命令模式的理解
一个命令创建一个对象。每个命令都是一个操作。不用去关心对象是怎么做的，只需要发送命令即可。就像传菜员一样。
二、 代码实现
创建一个命令接口
// 命令接口
public interface Command {
public void execute(); // 执行
public void undo(); // 撤销
}
在创建一个电视
// 电视
public class TV {
public void on() {
System.out.println("开电视");
}
public void off() {
System.out.println("关电视");
}
}
创建一个开电视命令
// 开电视
public class TVOnCommand implements Command{
TV tv;
public TVOnCommand(TV tv) {
this.tv = tv;
}
@Override
public void execute() {
tv.on();
}
@Override
public void undo() {
System.out.println("开电视撤销准备。。。");
tv.off();
}
}
创建一个关电视命令
public class TVOffCommand implements Command{
TV tv;
public TVOffCommand(TV tv) {
this.tv = tv;
}
@Override
public void execute() {
tv.off();
}
@Override
public void undo() {
System.out.println("关电视撤销准备。。。");
tv.on();
}
}
创建一个简单的远程控制器（遥控器）
// 简单远程控制
public class SimpleRemoteController {
Command command;
Command undoCommand;
public SimpleRemoteController(){};
// 利用有参构造器初始化命令
public void setCommand(Command command) {
this.command = command;
}
public void start() {
command.execute();
this.undoCommand = this.command;
}
public void undo() {
this.undoCommand.undo();
}
}
main方法实现
public static void main(String args[]) {
// 创建远程控制器
SimpleRemoteController simpleRemoteController = new SimpleRemoteController();
TV tv = new TV(); // 创建电视
TVOnCommand tvon = new TVOnCommand(tv); // 创建关电视命令
simpleRemoteController.setCommand(tvon); // 通过远程控制器设置关电视的命令
simpleRemoteController.start(); // 按开始按钮
simpleRemoteController.undo();
TVOffCommand tvoff = new TVOffCommand(tv); // 创建关电视命令
simpleRemoteController.setCommand(tvoff); // 通过远程控制器设置关电视的命令
simpleRemoteController.start(); // 按开始按钮
simpleRemoteController.undo();
}
运行结果
开电视
开电视撤销准备。。。
关电视
关电视
关电视撤销准备。。。
开电视
实现宏命令（实现一组命令）
创建宏命令
// 宏命令
public class MacroCommand implements Command{
Command[] commands;
public MacroCommand(Command[] command){
this.commands = command;
}
@Override
public void execute() {
for(Command c : this.commands ){
c.execute();
}
}
@Override
public void undo() {
for(Command c : this.commands ){
c.undo();
}
}
}
创建宏的远程控制
// 遥控器
public class RemoteController {
Command[] onCommands;
Command[] offCommands;
public RemoteController () {
this.onCommands = new Command[2];
this.offCommands = new Command[2];
}
public void setCommand(int index, Command on,Command off) {
this.onCommands[index] = on;
this.offCommands[index] = off;
}
public void on(int index) {
this.onCommands[index].execute();
}
public void off(int index) {
this.offCommands[index].execute();
}
}
创建一个电脑操作类
public class Computer {
public void on() {
System.out.println("开电脑");
}
public void off() {
System.out.println("关电脑");
}
}
关电脑命令
public class ComputerOffCommand implements Command{
Computer computer;
public ComputerOffCommand(Computer com) {
this.computer = com;
}
@Override
public void execute() {
this.computer.off();
}
@Override
public void undo() {
System.out.println("关电脑撤销准备。。。");
this.computer.on();
}
}
开电脑命令
public class ComputerOnCommand implements Command{
Computer computer;
public ComputerOnCommand(Computer computer) {
this.computer = computer;
}
@Override
public void execute() {
this.computer.on();
}
@Override
public void undo() {
System.out.println("开电脑撤销准备。。。");
this.computer.off();
}
}
main方法运行
Computer computer = new Computer();
RemoteController remoteController = new RemoteController();
ComputerOffCommand coffc = new ComputerOffCommand(computer);
ComputerOnCommand conc = new ComputerOnCommand(computer);
// 实现宏命令
Command[] on = {tvon, conc};
Command[] off = {tvoff,coffc};
MacroCommand onmc = new MacroCommand(on);
MacroCommand offmc = new MacroCommand(off);
remoteController.setCommand(0, onmc, offmc);
System.out.println("宏命令结束");
remoteController.on(0);
System.out.println("单独执行");
remoteController.off(0);
运行结果
宏命令结束
开电视
开电脑
单独执行
关电视
关电脑
三、UML类图
命令模式
命令模式+run
四、笔记
封装变化
多用组合少用继承
针对接口编程，不针对实现编程
为交互对象之间的松耦合设计而努力
对扩展开放、对修改关闭
依赖抽象，不依赖具体类
命令模式定义：
将请求封装成对象，这可以让你使用不同的请求、队列，或者日志请求来参数化其它对象。命令模式也可以支持撤销操作。
