《重构--改善既有代码的设计》--处理概括关系(11)

一、Pull Up Field（字段上移）

两个子类拥有相同的字段。将该字段移至超类。

二、Pull Up Method（函数上移）

有些函数，在各个子类中产生完全相同的结果。将该函数移至父类。

1、检查待提升函数，确定它们是完全一致的。

2、如果特提升函数名不同，修改与父类相同的函数名。

3、在父类新建一个函数，将待提升的函数代码复制到到新函数中。

4、编译。

5、移除子类中的函数。

6、编译、测试。

7、逐一移除子类中的函数，直到只剩下父类中的函数。

8、编译、测试。

重构后：

三、Pull Up Constructor Body（构造函数本体上移）

你在各个子类中拥有一些构造函数，它们的本体几乎完全一致。在父类中新建一个构造函数，并在子类构造函数中调用它。

1、在父类定义一个构造函数。

2、将子类共同代码搬移到父类中构造函数中。

3、将子类构造函数共同代码删除，改用父类中的构造函数。

4、编译、测试。

class Employee
    {
        protected string _name;
        protected string _id;

        public Employee(string name, string id)
        {
            _name = name;
            _id = id;
        }
    }

 

class Manager : Employee
    {
        private int _grade;
        public Manager(string name, string id, int grade)            
        {
            _name = name;
            _id = id;
            _grade = grade;
        }
    }

重构后：

class Manager : Employee
    {
        private int _grade;
        public Manager(string name, string id, int grade)    
            :base(name,id)
        {            
            _grade = grade;
        }
    }

四、Push Down Method（函数下移）

父类中的某个函数只与部分（而非全部）子类有关。将这个函数移到相关的那些子类去。

五、Push Down Field（字段下移）

父类中某个字段只被部分（而非全部）子类用到。将这个字段移到需要它的那些子类中。

六、Extract Subclass（提炼子类）

类中的某些特性只被某些（而非全部）实例用到。新建一个子类，将上面所说的那一部分特性移到子类中。

1、为源类定义一个新的子类。

2、为这个新的子类提供构造函数。

3、找出父类的构造函数，如果是需要子类的构造函数，请替换之。

4、逐一使用Push Down Method和Push Down Field将源类的特性移到子类。

5、编译、测试。

class JobItem
    {
        private int _unitPrice;
        private int _quantity;
        private bool _isLabor;
        private Employee _employee;

        public JobItem(int unitPrice, int quantity, bool isLabor, Employee employee)
        {
            _unitPrice = unitPrice;
            _quantity = quantity;
            _isLabor = isLabor;
            _employee = employee;
        }

        public int GetTotalPrice()
        {
            return GetUnitPrice() * _quantity;
        }

        public int GetUnitPrice()
        {
            return (_isLabor) ?
                _employee.GetRate() : _unitPrice;
        }

        public int Quantity
        {
            get { return _quantity; }
        }

        public Employee Employee
        {
            get { return _employee; }
        }
    }

 

class Employee
    {       
        protected int _rate;

        public Employee(int rate)
        {
            _rate = rate;   
        }

        public int GetRate()
        {
            return _rate;
        }
    }

 

class Program
    {
        static void Main(string[] args)
        {
            Employee kent = new Employee(3600);
            JobItem j1 = new JobItem(0, 5, true, kent); 
        }    
    }

创建一个子类，重构后：

class JobItem
    {
        private int _unitPrice;
        private int _quantity;
        private bool _isLabor;
        protected Employee _employee;

        protected JobItem(int unitPrice, int quantity, bool isLabor)
        {
            _unitPrice = unitPrice;
            _quantity = quantity;
            _isLabor = isLabor;         
        }

        public JobItem(int unitPrice, int quantity)
            : this(unitPrice, quantity, false)
        {
        }     

        public int GetTotalPrice()
        {
            return GetUnitPrice() * _quantity;
        }

        public virtual int GetUnitPrice()
        {
            return _unitPrice;
        }

        public int Quantity
        {
            get { return _quantity; }
        }

        protected virtual bool IsLabor()
        {
            return false;
        }
    }

 

class LaborItem:JobItem
    {
        public LaborItem(int unitPrice, int quantity, bool isLabor)
            : base(unitPrice, quantity, isLabor)
        {
        }

        public LaborItem(int quantity, Employee employee)
            : base(0, quantity, true)
        {
            _employee = employee;
        }

        public Employee Employee
        {
            get { return _employee; }
        }

        protected override bool IsLabor()
        {
            return true;
        }

        public override int GetUnitPrice()
        {
            return _employee.GetRate();
        }
    }

 

客户端：

class Program
    {
        static void Main(string[] args)
        {
            Employee kent = new Employee(3600);
            JobItem j1 = new LaborItem(10, 5, true);
            JobItem j2 = new JobItem(10, 15);
        }    
    }

 七、Extract Superclass（提炼超类）

两个类有相似特性。为这两个类建立一个父类，将相同特性移至父类。

1、建立一个抽象父类。

2、运用Pull Up Field,Pull Up Method,Pull Up Constructor Boday逐一将子类共同元素上移到父类。

3、编译、测试。

八、Extract Interface（提炼接口）

若干客户使用类接口中的同一子集，或者两个类的接口有部分相同。将相同的子集提炼到一个独立接口中。

1、新建一个接口。

2、在接口中声明待提炼类的共通操作。

3、让相关的类实现其接口。

4、调整客户端的类型声明，令其使用该接口。

 class Employee 
    {
        private int _rate;
        private bool _isSpecialSkill;

        Employee(int rate, bool isSpecialSkill)
        {
            _rate = rate;
            _isSpecialSkill = isSpecialSkill;
        }

        public int GetRate()
        {
            return _rate;
        }

        public bool HasSpecialSkill()
        {
            return _isSpecialSkill;
        }
    }

 

class TimeSheet
    {
        double Charge(Employee employee, int days)
        {
            int basic = employee.GetRate() * days;
            return (employee.HasSpecialSkill()) ? (basic * 1.05) : basic;         
        }
    }

重构后：

interface IBillable
    {
        int GetRate();
        bool HasSpecialSkill();
    }

 

class TimeSheet
    {
        double Charge(<span style="color:#ff0000;">IBillable </span>employee, int days)
        {
            int basic = employee.GetRate() * days;
            return (employee.HasSpecialSkill()) ? (basic * 1.05) : basic;         
        }
    }

九、Collapse Hierarchy（折叠继承体系）

父类与子类之间无太大区别，将它们合为一体。

1、选择你想移除的类：父类或子类。

2、使用Pull Up Field,Pull Up Method或Push Dwon Field,Push Down Method，把想移除的行为和属性搬移到另一个类中。

3、编译、测试。

4、调整原类的引用点，改为新类的引用。

5、移除源空类。

6、编译、测试。

十、Form Template Method（塑造模板函数）

你有一些子类，其中相应的函数以相同的顺序执行类的操作，但各个操作的细节上有所不同。将这些操作分别放进独立函数中，并保持它们都有相同的签名，于是原函数也就变得相同了。然后将原函数上移至父类。

1、在各个子类中分解目标函数，使分解后的各个函数不完全相同。

2、运用Pull Up Method将各个子类完全相同的函数上移父类。

3、对于那些完全不同的函数，实施Rename Method，使这些函数的签名完全相同。

4、编译、测试。

5、运用Pull Up Method将所有函数逐一上移到父类，并声明为抽象函数。

6、编译、测试。

7、移除子类中的原函数，编译、测试。

重构后：

十一、Replace Inheritance with Delegation（以委托取代继承）

某个子类只使用父类接口中的一部分，或是根本不需要继承而来的数据。在子类中新建一个字段用以保存父类，调整子类函数，令它改而委托父类，然后去掉两者之间的继承关系。

1、在子类型新建一个字段，引用父类的一个实例。

2、修改子类所有函数，让它们不使用父类，转而使用字段。

3、编译、测试。

4、去除继承关系。

5、编译、测试。

十二、Replace Delegation with Inheritance（以继承取代委托）

你在两个类之间使用委托关系，并经常为整个接口编写许多极简单的委托函数。让委托类继承受托类。

1、让委托端成为受托端的子类。

2、编译。

3、将受托字段设为该字段所处对象本身。

4、去掉简单的委托函数。

5、编译、测试。

6、把调用委托的代码改为对象本身。

7、移除受托字段。

 class Person
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        public string GetLastName()
        {
            return _name.SubString(_name.LastIndexOf(' ') +1);
        }
    }

 

class Employee
    {
        Person _person = new Person();

        public override string ToString()
        {
            return "Emp:" + _person.GetLastName();
        }
    }

重构后：

class Employee : Person
    {
        public override string ToString()
        {
            return "Emp:" + GetLastName();
        }
    }