当我们用equals比较两个对象是否相等的时候，还需要对左边的对象进行判空，不然可能会报空指针异常，我们可以用java.util包下Objects封装好的比较是否相等的方法:
Objects.equals(strA, strB);
源码:
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
apache commons是最强大的，也是使用最广泛的工具类库，里面的子库非常多，下面介绍几个最常用的
commons-lang，java.lang的增强版 建议使用commons-lang3，优化了一些api，原来的commons-lang已停止更新:
maven 的依赖:
org.apache.commons commons-lang3 3.12.0
传参CharSequence类型是String、StringBuilder、StringBuffer的父类，都可以直接下面方法判空，以下是源码：
public static boolean isEmpty(final CharSequence cs) {
return cs == null || cs.length() == 0;
}
public static boolean isNotEmpty(final CharSequence cs) {
return !isEmpty(cs);
}
// 判空的时候，会去除字符串中的空白字符，比如空格、换行、制表符
public static boolean isBlank(final CharSequence cs) {
final int strLen = length(cs);
if (strLen == 0) {
return true;
}
for (int i = 0; i < strLen; i++) {
if (!Character.isWhitespace(cs.charAt(i))) {
return false;
}
}
return true;
}
public static boolean isNotBlank(final CharSequence cs) {
return !isBlank(cs);
}
####1.1.2.2 首字母转大写 （这里可以查询源码看其他stringUtils 提供的其他源码，提供的新的特性）
String str = "yideng";
String capitalize = StringUtils.capitalize(str);
System.out.println(capitalize); // 输出Yideng
String str = StringUtils.repeat("ab", 2);
System.out.println(str); // 输出abab
再也不用手写SimpleDateFormat格式化了
// Date类型转String类型
String date = DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss");
System.out.println(date); // 输出 2021-05-01 01:01:01
// String类型转Date类型
Date date = DateUtils.parseDate("2021-05-01 01:01:01", "yyyy-MM-dd HH:mm:ss");
// 计算一个小时后的日期
Date date = DateUtils.addHours(new Date(), 1);
当一个方法需要返回两个及以上字段时，我们一般会封装成一个临时对象返回，现在有了Pair和Triple就不需要了
// 返回两个字段
ImmutablePair<Integer, String> pair = ImmutablePair.of(1, "yideng");
System.out.println(pair.getLeft() + "," + pair.getRight()); // 输出 1,yideng
// 返回三个字段
ImmutableTriple<Integer, String, Date> triple = ImmutableTriple.of(1, "yideng", new Date());
System.out.println(triple.getLeft() + "," + triple.getMiddle() + "," + triple.getRight()); // 输出 1,yideng,Wed Apr 07 23:30:00 CST 2021
1.1.3 commons-collections 集合工具类
封装了集合判空的方法，以下是源码：
public static boolean isEmpty(final Collection<?> coll) {
return coll == null || coll.isEmpty();
}
public static boolean isNotEmpty(final Collection<?> coll) {
return !isEmpty(coll);
}
// 两个集合取交集
Collection<String> collection = CollectionUtils.retainAll(listA, listB);
// 两个集合取并集
Collection<String> collection = CollectionUtils.union(listA, listB);
// 两个集合取差集
Collection<String> collection = CollectionUtils.subtract(listA, listB);
Maven依赖：
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.9.4</version>
</dependency>
public class User {
private Integer id;
private String name;
}
设置对象属性
User user = new User();
BeanUtils.setProperty(user, "id", 1);
BeanUtils.setProperty(user, "name", "yideng");
System.out.println(BeanUtils.getProperty(user, "name")); // 输出 yideng
System.out.println(user); // 输出 {"id":1,"name":"yideng"}
对象和map互转
// 对象转map
Map<String, String> map = BeanUtils.describe(user);
System.out.println(map); // 输出 {"id":"1","name":"yideng"}
// map转对象
User newUser = new User();
BeanUtils.populate(newUser, map);
System.out.println(newUser); // 输出 {"id":1,"name":"yideng"}
Maven依赖:
commons-io commons-io 2.8.0
文件处理
File file = new File("demo1.txt");
// 读取文件
List<String> lines = FileUtils.readLines(file, Charset.defaultCharset());
// 写入文件
FileUtils.writeLines(new File("demo2.txt"), lines);
// 复制文件
FileUtils.copyFile(srcFile, destFile);
maven 依赖:
com.google.guava guava 30.1.1-jre
List<String> list = Lists.newArrayList();
List<Integer> list = Lists.newArrayList(1, 2, 3);
// 反转list
List<Integer> reverse = Lists.reverse(list);
System.out.println(reverse); // 输出 [3, 2, 1]
// list集合元素太多，可以分成若干个集合，每个集合10个元素
List<List<Integer>> partition = Lists.partition(list, 10);
Map<String, String> map = Maps.newHashMap();
Set<String> set = Sets.newHashSet();
使用Collection.size() 来检测是否为空在逻辑上没有问题，但是使用Collection.isEmpty() 使得代码更易读，并且可以获得更好的性能；除此之外，任何Collection.isEmpty() 实现的时间复杂度都是O(1) ，不需要多次循环遍历，但是某些通过Collection.size() 方法实现的时间复杂度可能是O(n)。O(1)纬度减少循环次数 例子
反例：
LinkedList<Object> collection = new LinkedList<>();
if (collection.size() == 0){
System.out.println("collection is empty.");
}
正例
LinkedList<Object> collection = new LinkedList<>();
if (collection.isEmpty()){
System.out.println("collection is empty.");
}
//检测是否为null 可以使用CollectionUtils.isEmpty()
if (CollectionUtils.isEmpty(collection)){
System.out.println("collection is null.");
尽量在初始化时指定集合的大小，能有效减少集合的扩容次数，因为集合每次扩容的时间复杂度很可能时O(n)，耗费时间和性能。
反例：
//初始化list，往list 中添加元素反例：
int[] arr = new int[]{1,2,3,4};
List<Integer> list = new ArrayList<>();
for (int i : arr){
list.add(i);
}
正例：
//初始化list，往list 中添加元素正例：
int[] arr = new int[]{1,2,3,4};
//指定集合list 的容量大小
List<Integer> list = new ArrayList<>(arr.length);
for (int i : arr){
list.add(i);
}
在Java 集合类库中，List的contains 方法普遍时间复杂度为O(n)，若代码中需要频繁调用contains 方法查找数据则先将集合list 转换成HashSet 实现，将O(n) 的时间复杂度将为O(1)。
反例:
//频繁调用Collection.contains() 反例
List<Object> list = new ArrayList<>();
for (int i = 0; i <= Integer.MAX_VALUE; i++){
//时间复杂度为O(n)
if (list.contains(i))
System.out.println("list contains "+ i);
}
正例：
//频繁调用Collection.contains() 正例
List<Object> list = new ArrayList<>();
Set<Object> set = new HashSet<>();
for (int i = 0; i <= Integer.MAX_VALUE; i++){
//时间复杂度为O(1)
if (set.contains(i)){
System.out.println("list contains "+ i);
}
}
对于集合类型的静态成员变量，应该使用静态代码块赋值，而不是使用集合实现来赋值。
反例:
//赋值静态成员变量反例
private static Map<String, Integer> map = new HashMap<String, Integer>(){
{
map.put("Leo",1);
map.put("Family-loving",2);
map.put("Cold on the out side passionate on the inside",3);
}
};
private static List<String> list = new ArrayList<>(){
{
list.add("Sagittarius");
list.add("Charming");
list.add("Perfectionist");
}
};
正例：
//赋值静态成员变量正例
private static Map<String, Integer> map = new HashMap<String, Integer>();
static {
map.put("Leo",1);
map.put("Family-loving",2);
map.put("Cold on the out side passionate on the inside",3);
}
private static List<String> list = new ArrayList<>();
static {
list.add("Sagittarius");
list.add("Charming");
list.add("Perfectionist");
}
工具类是一堆静态字段和函数的集合，其不应该被实例化；但是，Java 为每个没有明确定义构造函数的类添加了一个隐式公有构造函数，为了避免不必要的实例化，应该显式定义私有构造函数来屏蔽这个隐式公有构造函数。
反例：
public class PasswordUtils {
//工具类构造函数反例
private static final Logger LOG = LoggerFactory.getLogger(PasswordUtils.class);
public static final String DEFAULT_CRYPT_ALGO = "PBEWithMD5AndDES";
public static String encryptPassword(String aPassword) throws IOException {
return new PasswordUtils(aPassword).encrypt();
}
正例:
public class PasswordUtils {
//工具类构造函数正例
private static final Logger LOG = LoggerFactory.getLogger(PasswordUtils.class);
//定义私有构造函数来屏蔽这个隐式公有构造函数
private PasswordUtils(){}
public static final String DEFAULT_CRYPT_ALGO = "PBEWithMD5AndDES";
public static String encryptPassword(String aPassword) throws IOException {
return new PasswordUtils(aPassword).encrypt();
}
### 1.2.7 **删除多余的异常捕获并抛出 ** (需补充)
用catch 语句捕获异常后，若什么也不进行处理，就只是让异常重新抛出，这跟不捕获异常的效果一样，可以删除这块代码或添加别的处理。
//多余异常反例
private static String fileReader(String fileName)throws IOException{
try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
String line;
StringBuilder builder = new StringBuilder();
while ((line = reader.readLine()) != null) {
builder.append(line);
}
return builder.toString();
} catch (Exception e) {
//仅仅是重复抛异常 未作任何处理
throw e;
}
}
正例：
//多余异常正例
private static String fileReader(String fileName)throws IOException{
try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
String line;
StringBuilder builder = new StringBuilder();
while ((line = reader.readLine()) != null) {
builder.append(line);
}
return builder.toString();
//删除多余的抛异常，或增加其他处理：
/*catch (Exception e) {
return "fileReader exception";
}*/
}
}
把其它对象或类型转化为字符串时，使用String.valueOf(value) 比 “”+value 的效率更高。
反例：
//把其它对象或类型转化为字符串反例：
int num = 520;
// "" + value
String strLove = "" + num;
正例：
//把其它对象或类型转化为字符串正例：
int num = 520;
// String.valueOf() 效率更高
String strLove = String.valueOf(num);
BigDecimal(double) 存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。
反例：
// BigDecimal 反例
BigDecimal bigDecimal = new BigDecimal(0.11D);
正例：
// BigDecimal 正例
BigDecimal bigDecimal1 = bigDecimal.valueOf(0.11D);
装饰模式又称，包装模式。装饰模式是以客户端透明的方式扩展对象的功能 是一种继承的替代方案。
- 动态给对象增加新的功能
- 装饰模式是一种用于替代，继承的技术，无需通过继承增加子类就能扩展 对象的功能。使用对象的关联关系，替代继承关系 更加灵活，同时避免了体系的膨胀。
Component 抽象构建角色 ：真是对象（对应上图 ConcreteOperation() 对象）和装饰对象具有相同的接口
。这样客户端对象就能以与 真是对象相同的方式同装饰对象交互了。
ConcreteComponent 具体构建的角色（真是对象） ：定义一个接收附加责任的类。
Decorator装饰角色 持有构建角色的引用。装饰对象接收客户端的请求，并把这些请求转发给真是的对象。这样，就能在真是对象调用前后增加新的功能。
ConcreteDecorate 具体的装饰角色：负责给构建对象增加新的功能。
举一个简单的汽车例子，创造每一种汽车都需要继承父类进行实现，如下图 那么当我们需要，既能路上行驶，又能水上行驶，又得继承父类。
以后每增加一种新功能的汽车都需要增一个类，这样的话会创建大量的类。这时候就能使用装饰类了。
代码示例:
抽象构件
public interface AbstractCar {
void move();
}
具体构建
public class Car implements AbstractCar{
public void move() {
System.out.println("路上行驶");
}
}
装饰角色
public class SuperCar implements AbstractCar{
protected AbstractCar car;
public SuperCar(AbstractCar car){
this.car=car;
}
public void move() {
car.move();
}
}
具体装饰 角色
/**
* 飞行汽车
*/
ublic class FlyCar extends SuperCar{
public FlyCar(AbstractCar car) {
super(car);
}
public void fly() {
System.out.println("空中行驶汽车");
}
@Override
public void move() {
super.move();
fly();
}
}
/**
* 水上汽车
*/
public class WaterCar extends SuperCar{
public WaterCar(AbstractCar car) {
super(car);
}
public void swim() {
System.out.println("水上行驶汽车");
}
@Override
public void move() {
super.move();
swim();
}
}
客户端
public class Client {
public static void main(String[] args) {
Car car=new Car();
car.move();
System.out.println("------增加新功能,飞行------");
FlyCar flyCar=new FlyCar(car);
flyCar.move();
System.out.println("------新增加功能，水上行驶-----");
WaterCar waterCar=new WaterCar(car);
waterCar.move();
System.out.println("-----新增加两个功能，飞行与水上行驶-----");
WaterCar waterCar2=new WaterCar(flyCar);
waterCar2.move();
}
}
//输出结果
路上行驶
------增加新功能,飞行------
路上行驶
空中行驶汽车
------新增加功能，水上行驶-----
路上行驶
水上行驶汽车
-----新增加两个功能，飞行与水上行驶-----
路上行驶
空中行驶汽车
水上行驶汽车
- 咖啡类型 espresso（意大利咖啡），shortblack,LongBlack(美食咖啡)，Decaf(无因咖啡)
- 调料 Milk ,Soy(豆浆)，Chocolate
- 费用 不同的咖啡价格是不同的，而且有 咖啡+调料的类型组合 每个咖啡，都有自己的单价，咖啡+调料也有自己的单价。
- 要求 扩展咖啡的种类的时候，具有很好的扩展性，改动方便，维护方便。
- 总结：看到需求，首先是问题的抽象能力，将问题抽象出来，这个抽象能力非常重要。
- 看到每个咖啡，都有自己的cost（花费）和description（描述）可以知道咖啡共有的属性和行为。
- 看到问题后，手动画图或者用软件画出类图 ，遇到问题，首先是下手，做软件行业，就是要下手设计，大家都能想到的如下类图设计
咖啡类型就像是构件，调料就是具体的装饰类，给构件增加新的功能；
装饰者模式，更像俄罗斯的套娃，一层一层的嵌套
看到类图后你会发现，其实就 当前类A 中 含有A属性。
类图如下：
代码: 见idea
- 扩展对象功能，比继承灵活，不会导致类个数急剧增加。
- 可以对一个对象进行多次装饰，创造出不同行为的组合，得到功能更加强大的对象。
- 具体构 件 类和具体装饰类可以独立变化，用户可以根据需要自己增加新的 具体构件子类和具体装饰子类。
- 产生很多小对象。大量小的对象占据内存，一定程度上影响性能。
- 装饰模式易出错，调试排查比较麻烦。
商城中常见的模式 ，以电脑分类，如何处理商品分类销售问题
我们可以使用多层继承实现关系如下
代码省略： 存在的问题，
扩展问题
- 如果要增加新的电脑类型：如平板电脑，则要增加 各个品牌下面的类。
- 如果新增加品牌，也要增加各个电脑下的类。
- 违反了单一职责原则
一个类：如联想笔记本电脑，有两个引起这个类变化的原因：品牌及电脑的类型。
总结：某些由于自身的逻辑，它具有两个或者多个维度的变化，为了应对这种“多维度变化”，并且利用面向对象 的技术来，使得该类能轻松的沿着多个方向变化，而有不引入额外的复杂度。引入bridge模式。
概念：把抽象（abstraction)和行为实现分开（implement）从而保持各部分的独立性以及对功能的扩展
上面场景中有两个变化的维度，电脑类型和电脑品牌，将上面的代码通过桥接模式实现:
电脑品牌维度
/**
* 电脑品牌维度接口
*/
public interface Brand {
void nane();
}
class Lenovo implements Brand{
@Override
public void nane() {
System.out.println("联想电脑");
}
}
class Dell implements Brand{
@Override
public void nane() {
System.out.println("戴尔电脑");
}
}
电脑类型维度
/**
* 电脑类型维度
*/
public class Computer{
protected Brand brand;
public Computer(Brand brand){
this.brand=brand;
}
public void sale(){
brand.nane();
}
}
class Desktop extends Computer{
public Desktop(Brand brand) {
super(brand);
}
@Override
public void sale() {
super.sale();
System.out.println("销售台式机");
}
}
class Laptop extends Computer{
public Laptop(Brand brand) {
super(brand);
}
@Override
public void sale() {
super.sale();
System.out.println("销售笔记本");
}
}
客户端
/**
* 客户端
*/
public class Client {
public static void main(String[] args) {
Computer len=new Desktop(new Lenovo());
len.sale();
}
}
//输出结果
联想电脑
销售台式机
总结：这样将 电脑品牌和电脑类型两个维度，分离开并且组合使用，这样在增加品牌或类型更加简单。
处理多层继承结构，处理多维度变化的场景，将更维度设计成独立的继承模块，使各个维度可以独立扩展在抽象层。
适用性
- 如果一个系统需要在构件的抽象化角色和具体化角色之间，增加更多的灵活性，避免在两个层次之间建立静态的关系。
- 设计要求实现化角色的任何改变不应该影响客户端，或者说实现化角色的改变对客户端是完全透明的。
- 一个构件多余一个抽象化角色和实现化角色，系统需要它们之间互相解耦。
- 虽然系统中使用继承没有问题，但由于抽象化角色和具体化角色需要独立化，设计要求独立管理两者。
- 两个模式都是为了解决过多子类对象的问题。但他们的诱因不同，桥接模式是对象自身现有机制沿着多个维度变化，是既有部分不稳定。装饰模式是为了增加新的功能
场景： 是一种 一对多的关系，进一步理解为 消息订阅模式
Subject 被观察者 也叫做 主题 Observer 观察者 也叫订阅者 理解：被观察者 通知观察者自己的状态变化 被观察者中注册了，多个观察者对象。
将复杂对象的构建和它的表示，使得同样的构建过程有不同的创建方式。
概念 把部分和整体用树形结构来表示 ，从而使客户端可以使用统一的方式对，部分对象和整体对象就行管理。
抽象构件（Conponent） 角色： 所有类共有接口，定义叶子节点和容器共同点
叶子（Leaf）构件角色：在组合中表示叶子节点对象，叶子节点五子节点。
容器(Composite)构件角色: 有容器特征，可以用来存储子节点，在Component接口中实现与子节点有关操作，如增加(add)和删除(remove)等。
- 组合模式为处理树形结构，提供了完美的解决方案，描述了如何将容器和叶子节点进行递归组合，使得用户在使用时， 可以一致性的对待容器和叶子。
- 当容器对象的指定方法被调用时，将遍历整个树形结构，寻找包含这个方法的成员，并调用执行。其中使用递归调用机制对整个机构进行处理。
下面是通过简单秒杀的例子，使用组合
抽象构建
public interface AbstractFile {
void killVirus();//杀毒
}
叶子构件
class ImageFile implements AbstractFile{
private String name;
public ImageFile(String name){
this.name=name;
}
public void killVirus() {
System.out.println("---对图像文件"+name+"杀毒");
}
}
class TextFile implements AbstractFile{
private String name;
public TextFile(String name){
this.name=name;
}
public void killVirus() {
System.out.println("---对文本文件"+name+"杀毒");
}
}
容器构建
class Folder implements AbstractFile{
private String name;
private ArrayList<AbstractFile> list=new ArrayList<AbstractFile>();
public Folder(String name){
this.name=name;
}
public void add(AbstractFile file){
list.add(file);
}
public void remove(AbstractFile file){
list.remove(file);
}
public AbstractFile getChild(int index){
return list.get(index);
}
public void killVirus() {
System.out.println("---对文件夹"+name+"杀毒");
for(AbstractFile file:list){
file.killVirus();
}
}
}
客户端
public class Client {
public static void main(String[] args) {
Folder f1;
AbstractFile f2,f3;
f1=new Folder("我的收藏");
f2=new ImageFile("my.jpg");
f3=new TextFile("my.txt");
f1.add(f2);
f1.add(f3);
f1.killVirus();
}
}
//输出结果：
---对文件夹我的收藏杀毒
---对图像文件my.jpg杀毒
---对文本文件my.txt杀毒
组合关系
- 外观模式（也称门面模式）定义了一个高层接口，为子系统中的一组接口提供了，一致的界面，从而使子系统更加容易使用。
将一个请求封装为对象，从而使我们可用不同的请求，对客户进行参数化；对请求排队或者记录请求日志，以及支持撤销操作，以及支持撤销操作。也称为：动作（Action)模式，事务（transaction）模式。
Conmmand 抽象命令类: 声明执行操作接口
ConcreteCommand 具体命令类：通常持有 一个接收者对象并绑定一个动作，调用接收者相应的动作，以实现execute方法。
invoker 调用者/请求者：请求的发送者，它通过命令对象来执行请求。一个调用者并不需要在设计时确定其接收者，因此它只与抽象命令类之间存在关联。在程序运行时，将调用命令对象的execute() 间接调用接收者的相关工作。
Receiver接收者：接受者执行与请求相关的操作，具体实现对请求业务的处理。
Receiver接受者
/**
* 真正的命令执行者
*/
public class Receiver {
public void action(){
System.out.println("执行命令----");
}
public void unAction(){
System.out.println("撤销命令----");
}
}
command 抽象命令类
/**
* 抽象命令接口
*/
public interface Command {
void execute();//执行命令
void cancel();//取消命令
}
ConcreteCommand具体命令类
/**
* 具体命令类
*/
public class ConcreteCommand implements Command{
private Receiver receiver;
public ConcreteCommand(Receiver receiver) {
super();
this.receiver = receiver;
}
public void execute() {
//可进行执行命令前相关操作
receiver.action();//执行命令
//可进行执行命令后相关操作
}
public void cancel() {
receiver.unAction();
}
}
Invoke 调用者/请求者
public class Invoker {
private Command command; //可以是多个命令
public Invoker(Command command) {
super();
this.command = command;
}
//执行命令
public void runCommand(){
command.execute();
}
//取消命令
public void cancelCommand(){
command.cancel();
}
}
客户端
public class Client {
public static void main(String[] args) {
//创建接收者
Receiver receiver=new Receiver();
//创建命令对象，并设置接收者
Command command=new ConcreteCommand(receiver);
//创建调用者，设置命令
Invoker invoker=new Invoker(command);
invoker.runCommand();
invoker.cancelCommand();
}
}
//输出结果
执行命令----
撤销命令----
应用 ：模拟对电视机的操作有开机、关机、换台命令。代码如下
//执行命令的接口
public interface Command {
void execute();
}
//命令接收者Receiver
public class Tv {
public int currentChannel = 0;
public void turnOn() {
System.out.println("The televisino is on.");
}
public void turnOff() {
System.out.println("The television is off.");
}
public void changeChannel(int channel) {
this.currentChannel = channel;
System.out.println("Now TV channel is " + channel);
}
}
//开机命令ConcreteCommand
public class CommandOn implements Command {
private Tv myTv;
public CommandOn(Tv tv) {
myTv = tv;
}
public void execute() {
myTv.turnOn();
}
}
//关机命令ConcreteCommand
public class CommandOff implements Command {
private Tv myTv;
public CommandOff(Tv tv) {
myTv = tv;
}
public void execute() {
myTv.turnOff();
}
}
//频道切换命令ConcreteCommand
public class CommandChange implements Command {
private Tv myTv;
private int channel;
public CommandChange(Tv tv, int channel) {
myTv = tv;
this.channel = channel;
}
public void execute() {
myTv.changeChannel(channel);
}
}
//可以看作是遥控器Invoker
public class Control {
private Command onCommand, offCommand, changeChannel;
public Control(Command on, Command off, Command channel) {
onCommand = on;
offCommand = off;
changeChannel = channel;
}
public void turnOn() {
onCommand.execute();
}
public void turnOff() {
offCommand.execute();
}
public void changeChannel() {
changeChannel.execute();
}
}
//测试类Client
public class Client {
public static void main(String[] args) {
// 命令接收者Receiver
Tv myTv = new Tv();
// 开机命令ConcreteCommond
CommandOn on = new CommandOn(myTv);
// 关机命令ConcreteCommond
CommandOff off = new CommandOff(myTv);
// 频道切换命令ConcreteCommond
CommandChange channel = new CommandChange(myTv, 2);
// 命令控制对象Invoker
Control control = new Control(on, off, channel);
// 开机
control.turnOn();
// 切换频道
control.changeChannel();
// 关机
control.turnOff();
}
}
执行结果
The televisino is on.
Now TV channel is 2
The television is off.
- 优点
- 降低对象的耦合度。
- 新的命令很容易加入到系统中。
- 可以很容易的设计一套命令。
- 调用同一个方法不同功能
- 缺点
- 使用命令模式可能会导致某些系统有很多具体的命令类，因为针对每一个命令需要设计一个命令类，因此某些系统可能需要大量的命令类，将影响命令模式的使用。
总结
- 命令模式本质是对，命令进行封装，将发出命令的责任和执行命令的责任分割开。
- 每一个命令都是一个操作，请求一方发出命令，要求执行一个动作；接收方收到请求，并执行请求。
- 命令模式允许请求的一方和接收的一方，独立开来，使得请求方不知道接收方的接口，更不知道请求是怎么被接收，以及是否被执行，何时被执行，以及怎么被执行。
- 命令模式使请求本身成为对象，这个对象和其他对象可以被存储和传递。
- 命令模式的关键在于引入抽象接口，且发送者针对抽象接口编程，只有实现了抽象命令接口的具体命令才能与接收者相关联。