重构学习day01 类型码 类型码的上层建筑 与类型码相关的重构方法 1.使用子类代替类型码 2.使用状态或策略模式代替类型码

名词：类型码 类型码的上层建筑 重构方法 1.使用子类代替类型码 2.使用状态/策略模式代替类型码

类中存在方法把某个字段当作条件，根据字段值的不同，进行不同的处理。（自定义概念）
则这个字段叫做：类型码。（重构-改善既有代码的设计中的概念）
这个方法叫做：类型码的上层建筑。（自定义概念）
（这种判断方法不是绝对正确，但是一般可行，类型码是重构-改善既有代码的设计的概念，但是类型码的上层建筑是自定义概念）

例子1：
Movie对象中存在影片类型字段，根据影片类型和租期计算金额的getCharge()方法和计算用户积分的getRentPoints()
getCharge()方法和getRentPoints()都以影片类型字段为条件，进行不同的处理。
所以根据上面的解释：
类型码=影片类型
类型码（影片类型）的上层建筑2个：getCharge()方法和getRentPoints()方法

 package refactor;

 public class Movie {
     public static final int NEW_RELEASE = 0;
     public static final int REGULAR = 1;
     public static final int CHILDREN = 2;

     private int priceCode;
     private String title;

     public Movie() {
     }

     public Movie(String title, int priceCode) {
         this.priceCode = priceCode;
         this.title = title;
     }

     public double getCharge(int daysRent){
         double result = 0;
         switch(priceCode){
             case Movie.REGULAR:
                 result += 2;
                 if(daysRent > 2){
                     result += (daysRent - 2) * 1.5;
                 }
                 break;
             case Movie.NEW_RELEASE:
                 result += daysRent * 3;
                 break;
             case Movie.CHILDREN:
                 result += 1.5;
                 if(daysRent > 3){
                     result += (daysRent - 3) * 1.5;
                 }
                 break;
         }
         return result;
     }

     public int getRentPoints(int daysRent){
         int rentPoints = 1;
         if(priceCode == Movie.NEW_RELEASE
                 && daysRent > 1){
             rentPoints++;
         }
         return rentPoints;
     }
 }

Movie直接使用类型码

当影片类型不多，分支逻辑不复杂，上层建筑不多，并且以后变化也不大时，直接使用类型码和使用多态重构区别不太大。

直接使用类型码的问题：
可是随着影片类型的迅速扩张，分支逻辑的复杂性升高，上层建筑的增多，直接使用类型码将导致
1.如果影片类型增加的非常多时，则条件语句将会非常长，并且每个上层建筑都会对应一个这样的条件语句。
2.如果影片类型增加，上层建筑增多，而此时分支逻辑复杂度也很高，则需要为了防止上层建筑过长，需要抽取每个分支逻辑为方法，将可能导致本类方法迅速膨胀。
所以：当影片类型，分支逻辑，上层建筑发生的变化较大时，则直接使用类型码会导致类过大，上层建筑过长或者产生过多的方法，条件语句随着上层建筑重复等问题，
总之就是导致代码难逻辑和结构的越来越不清晰，越来越难理解，越来越难修改，越来越容易出错。

使用重构则是较好的解决方案：
1.replace type code with subclass 对象类型码的值在生命期间不会发生变化
2.replace type code with state/strategy 对象类型码的值可能在生命期间发生变化。
好处：
1.不管原来的上层建筑有多少，重构后，只需要维护一个产生子类或者状态/策略的条件语句。
2.与类型码相关的处理都被放到相应的类中。代码结构和逻辑更清晰。
每个子类（状态/策略）与类型码的值一一对应，每个与类型码值对应的处理逻辑都被放在与该类型码值相对应的子类（状态/策略）中，代码的结构和逻辑非常清晰。

每个子类（状态/策略）与类型码的值一一对应，每个与类型码值对应的处理逻辑都被放在与该类型码值相对应的子类（状态/策略）中，代码的结构和逻辑非常清晰。

每个子类（状态/策略）与类型码的值一一对应，每个与类型码值对应的处理逻辑都被放在与该类型码值相对应的子类（状态/策略）中，代码的结构和逻辑非常清晰。

 package shop;

 public class Movie {
     public static final int NEW_RELEASE = 0;
     public static final int REGULAR = 1;
     public static final int CHILDREN = 2;

     private String title;
     private Price price;

     public Movie() {
     }

     public Movie(String title, int priceCode) {
         setPriceCode(priceCode);
         this.title = title;
     }

     public int getPriceCode() {
         return price.getPriceCode();
     }

     //有2个上层建筑，但是程序只需要维护一个根据类型码产生state对象的条件语句
     public void setPriceCode(int priceCode) {
         switch (priceCode){
             case Movie.NEW_RELEASE:
                 price = new NewPrice();
                 break;
             case Movie.REGULAR:
                 price = new RegularPrice();
                 break;
             case Movie.CHILDREN:
                 price = new ChildrenPrice();
                 break;
             default:
                 throw new IllegalArgumentException("非法的影片类型：" + priceCode);
         }
     }

     public double getCharge(int daysRent){
         return price.getCharge(daysRent);
     }

     public int getRentPoints(int daysRent){
         return price.getRentPoints(daysRent);
     }
 }

Movie使用状态模式重构类型码

 package shop;
 //子类或状态与类型码一一对应，相应的逻辑也全部集中在这个类中。代码的结构和逻辑更清晰
 public class ChildrenPrice extends Price {
     @Override
     public int getPriceCode(){
         return Movie.CHILDREN;
     }

     @Override
     public double getCharge(int daysRent) {
         double result = 1.5;
         if(daysRent > 3){
             result += (daysRent - 3) * 1.5;
         }
         return result;
     }
 }

ChildrenPrice子类或状态与类型码一一对应

 package shop;
 //子类或状态与类型码一一对应，相应的逻辑也全部集中在这个类中。代码的结构和逻辑更清晰
 public class NewPrice extends Price{
     @Override
     public int getPriceCode() {
         return Movie.NEW_RELEASE;
     }

     @Override
     public double getCharge(int daysRent) {
         return daysRent * 3;
     }

     @Override
     public int getRentPoints(int daysRent) {
         return daysRent > 1 ? 2 : 1;
     }
 }

NewPrice 子类或状态与类型码一一对应

 package shop;
 //子类或状态与类型码一一对应，相应的逻辑也全部集中在这个类中。代码的结构和逻辑更清晰
 public class RegularPrice extends Price {
     @Override
     public int getPriceCode() {
         return Movie.REGULAR;
     }

     @Override
     public double getCharge(int daysRent) {
         double result = 2;
         if(daysRent > 2){
             result += (daysRent - 2) * 1.5;
         }
         return result;
     }
 }

RegularPrice 子类或状态与类型码一一对应

类型码：类的一个字段，该类中存在方法把这个字段当作条件，根据字段值的不同，进行不同的处理。
类型码的上层建筑：某个方法，根据类型码不同的值进行不同处理。
当类型码的上层建筑有多个，则每个上层建筑都需要维护着条件判断。导致总体上基于类型码的条件判断有多个。
重构方法：
1.replace type code with subclass
2.replace type code with state/strategy
和直接使用类型码的区别：
2个重构手法避免了多个基于类型码的条件判断的产生，使基于类型码的条件判断始终只有一个。
上层建筑通过多态