《大话设计模式》-读书笔记-技术-更新中

线索栏	笔记栏
写一个计算器程序	见附录1
活字印刷为何被称为中国古代四大发明之一？	如图1-1 1. 字可以被直接替换，可维护。 2. 已经完成的字可以被复用，可复用。 3.字可以随意扩充，可扩展 4. 字可以任意横向竖向排列，灵活
复制和复用的区别是什么？	复制把已经有的代码粘贴复制到其他地方，再修修改改就可以适用于新情况了。 复用是将已有的代码提取成为一个公共函数，或者公共对象，让其他地方都可以调用，免去重复写代码。【例如：我们往往会使用工具类，比如FileUtil，来将需要用到File的频繁的复杂操作提取成函数，外部直接调用。等等】
封装是什么？	封装，通俗地说，就是只对外人展示必要的东西，不必要的东西就藏起来不展示。 【比如：你家的插排，只给你露出一个双插口或者三插口，你要充电直接插到插排就可以。你不用知道这个插排是如何通电的就可以使用它。 再比如，人体，你不用知道血液如何流动，心脏如何泵血，身体内的营养物质如何消化吸收，普通的你就可以活着，人体对你藏起来了很多东西，告诉你只需要吃饭，睡觉，运动，身体一般就没啥问题。】
如何做好业务的封装	尽量只对外部提供必要的数据或者方法，不必要的藏起来。并且最好按照职责划分开来。 【例如：你的身体没有告诉你他有肾脏，肺，心脏，它都藏了起来，而且他按照职责划分，对外的吃饭的就是嘴，看东西的就是眼睛，对内也有封装，肺负责呼吸，肾脏负责过滤等】
耦合是什么？	耦合指的是东西之间的连接程度，也可以叫关系紧密程度。【例如：三个东西耦合严重，表示的就是三个关系很紧密，一个出问题很可能影响其他两个。 紧耦合表示的就是大家连接十分紧密，你可以想象是小明和他的家人，关系很紧密，一个人生病，其他人都会担心 松耦合表示的就是大家连接不是很紧密，比如你生病了，不会特别影响你的老板 -_-，扎心了嗷】
紧耦合和松耦合优缺点	紧耦合： 优点：大家联系紧密，一个改变就会影响其他，方便统一修改。 缺点：联系紧密，一个修改就会影响其他，造成不必要的影响。 松耦合： 优点：大家联系较松，一个改变不会影响其他，方便增加删除修改任意一个成员。 缺点：大家联系不紧密，如果想要统一修改，需要找到并且都进行修改，比较麻烦
简单工厂模式以及代码实现	简单工厂的好处就是，上下游之间加了一个中间层。改动主要集中在工厂以及各个子部分，对外不变。 代码如附录3 【我们将在附录2中介绍中间层以及其优缺点。】
UML图

图1

附录

1. 我第一遍，没看书写的代码：

   public class Calculate {
       SignCalculateFactory signCalculateFactory;
   
       public int calculateInt(int a, int b, char sign) {
           return signCalculateFactory.getSignCalculateBySign(sign)
                                       .calculateInt(a, b);
       }
   
       public double calculateDouble(double a, double b, char sign) {
           return signCalculateFactory.getSignCalculateBySign(sign)
                                       .calculateDouble(a, b);
       }
   }
   
   class SignCalculateFactory {
       private AddCalculate addCalculate;
       private ReduceCalculate reduceCalculate;
       private MultiplyCalculate multiplyCalculate;
       private DivCalculate divCalculate;
       private EmptyCalculate emptyCalculate;
   
       public SignCalculate getSignCalculateBySign(char sign) {
           switch (sign) {
               case '+' : return addCalculate;
               case '-' : return reduceCalculate;
               case '*' : return multiplyCalculate;
               case '/' : return divCalculate;
               default: return emptyCalculate;
           }
       }
   }
   
   public interface SignCalculate {
       int calculateInt(int a, int b);
   
       double calculateIntToDouble(int a, int b);
   
       double calculateDouble(double a, double b);
   }
   
   class EmptyCalculate implements SignCalculate {
       public int calculateInt(int a, int b) {
           throw new RuntimeException("emptyCalculate can not be use to calculate");
       }
   
       public double calculateIntToDouble(int a, int b) {
           throw new RuntimeException("emptyCalculate can not be use to calculate");
       }
   
       public double calculateDouble(double a, double b) {
           throw new RuntimeException("emptyCalculate can not be use to calculate");
       }
   }
   
   class AddCalculate implements SignCalculate {
       public int calculateInt(int a, int b) {
           return a + b;
       }
   
       public double calculateIntToDouble(int a, int b) {
           return a * 1.0 + b;
       }
   
       public double calculateDouble(double a, double b) {
           return a + b;
       }
   }
   
   class ReduceCalculate implements SignCalculate {
       public int calculateInt(int a, int b) {
           return a - b;
       }
   
       public double calculateIntToDouble(int a, int b) {
           return a * 1.0 - b;
       }
   
       public double calculateDouble(double a, double b) {
           return a - b;
       }
   }
   
   class MultiplyCalculate implements SignCalculate {
       public int calculateInt(int a, int b) {
           return a * b;
       }
   
       public double calculateIntToDouble(int a, int b) {
           return a * 1.0 * b;
       }
   
       public double calculateDouble(double a, double b) {
           return a * b;
       }
   }
   
   class DivCalculate implements SignCalculate {
       public int calculateInt(int a, int b) {
           return a / b;
       }
   
       double calculateIntToDouble(int a, int b) {
           return a * 1.0 / b;
       }
   
       public double calculateDouble(double a, double b) {
           return a / b;
       }
   }
   

2. 中间层

   中间层用处很多，我们举个例子。比如你想买海外的衣服，你找了个代理商，他帮很多人代购衣服。我们假设，有ABC三个人，分别想买123三个牌子的衣服，此时，如果有个新的衣服品牌叫4，大家都很喜欢，那么我们只需要让代理商负责去找品牌为4的衣服，然后ABC谁需要就可以直接找代理商拿。

   同样地，如果新增了一个顾客叫D，那么只需要找代理商，从那里拿衣服就可以了。

   在这其中，需要修改的只有代理商，我们无需让顾客ABCD去找海外的品牌店铺买东西，只需要让顾客找代理商就可以。

   在这里，不变的是：代理商对外提供服务，代理商只卖衣服。
   变的是：代理商找新品牌的衣服，代理商接新客户。