重构、分支语句、虚函数、抽象函数与多态--《重构:改善既有代码设计》之读书心得

    最近在读 Marting Fowler 所著的 Refactoring  Improving the Desgin of Existing Code 一书。身体力行地完成了" a First Exmaple"--从一个现有代码的重构过程。
    我是用VS.NET 2005 beta2 来做的。虽然这个版本已经实现了不少重构的工具，诸如 Rename、Encapsulate field、Extract Method、Extract Interface、Change signature   等。但是仍然有一些重要的、有用的重构，如：Extract superclass、Move Member(from one class to another)和 Push Up Member没有实现。所以我在重构的过程中有时需要手工改代码。
    这个First Exmaple例子的最初原型是非常简单的，它是一个影碟出租商店用来计算并打印顾客账单的程序。它会显示一个客户租借了哪些影碟和多长时间，根据租借时间的长短计算费用。它还会识别：常规类、儿童类、新发布类三种不同的影碟类型。在计算租借费用的同时它还会计算客户的积分，如果租借的是新发布类的影碟会有额外的积分。
     下面是这个程序中的几个关键类：
   

public class Movie
    {
        public const int CHILDRENS = 2;
        public const int REGULAR = 0;
        public const int NEW_RELEASE = 1;

        private String _title;
        private int _priceCode;

        public Movie(String title,int priceCode)
        {
            _title = title;
            _priceCode = priceCode;
        }

        public int getPriceCode()
        {
            return _priceCode;
        }

        public void setPriceCode(int arg)
        {
            _priceCode = arg;
        }

        public String getTitle()
        {
            return _title;
        }
    }

 

 public class Rental
    {
        private Movie _movie;
        private int _daysRented;

        public Rental(Movie movie,int daysRented)
        {
            _movie = movie;
            _daysRented = daysRented;
        }

        public int getDaysRented()
        {
            return _daysRented;
        }

        public Movie getMovie()
        {
            return _movie;
        }
    }

 

public class Customer
    {
        private String _name;
        private ArrayList _rentals = new ArrayList();

        public Customer(String name)
        {
            _name = name;
        }

        public void addRental(Rental arg)
        {
            _rentals.Add(arg);
        }

        public String getName()
        {
            return _name;
        }

        public string statement()
        {
            double totalAmount = 0;
            int frequentRenterPoints = 0;
            IEnumerator rentals = _rentals.GetEnumerator();
            String result = "Rental Record for " + getName() + "\n";
            while (rentals.MoveNext())
            {
                Rental each = (Rental)rentals.Current;

                double thisAmount = 0;
            //determine amounts for each line
            switch (each.getMovie().getPriceCode())
            {
                case Movie.REGULAR:
                    thisAmount += 2;
                    if (each.getDaysRented() > 2)
                        thisAmount += (each.getDaysRented() - 2) * 1.5;
                    break;
                case Movie.NEW_RELEASE:
                    thisAmount += each.getDaysRented() * 3;
                    break;
                case Movie.CHILDRENS:
                    thisAmount += 1.5;
                    if (each.getDaysRented() > 3)
                        thisAmount += (each.getDaysRented() - 3) * 1.5;
                    break;
            }

                // add frequent renter points
                frequentRenterPoints++;
                // add bonus for a two day new release rental
                if ((each.getMovie().getPriceCode() == Movie.NEW_RELEASE) && each.getDaysRented() > 1) frequentRenterPoints++;

                // show figures for this rental
                result += "\t" + each.getMovie().getTitle() + "\t" + thisAmount + "\n";
                totalAmount += thisAmount;
            }
            // add footer lines
            result += "Amount owed is " + totalAmount + "\n";
            result += "You earned " + frequentRenterPoints + " frequent renter points";

            return result;
        }
    }

重构针对这三个类展开，先后采用了Extract Method、Move Method、Removing Temps、Replace Type Code with State/Strategy等方法，最后是Replace Conditional with Polymorphism。这个过程中产生了新类Price(abstract)以及它的三个子类RegularPrice、ChildrensPrice、RegularPrice。

 在最后的重构过程中，我先把Price类的getCharge方法改为虚拟(virtual)的，然后依次从swich语句中抽取子类的实现。
抽取前的Price类：

 public abstract class Price
    {
        public abstract int getPriceCode();

        public virtual double getCharge(int daysRented)
        {
            double thisAmount = 0;

            //determine amounts for each line
            switch (getPriceCode())
            {
                case Movie.REGULAR:
                    thisAmount += 2;
                    if (daysRented > 2)
                        thisAmount += (daysRented - 2) * 1.5;
                    break;
                case Movie.NEW_RELEASE:
                    thisAmount += daysRented * 3;
                    break;
                case Movie.CHILDRENS:
                    thisAmount += 1.5;
                    if (daysRented > 3)
                        thisAmount += (daysRented - 3) * 1.5;
                    break;
            }

            return thisAmount;
        }
    }

抽取前的RegularPrice类：

public class RegularPrice : Price
    {
        public override int getPriceCode()
        {
            return Movie.REGULAR;
        }
}

抽取后的Price和RegularPrice：

public abstract class Price
    {
        public abstract int getPriceCode();

        public virtual double getCharge(int daysRented)
        {
            double thisAmount = 0;

            //determine amounts for each line
            switch (getPriceCode())
            {
                case Movie.REGULAR:
                    break;
                case Movie.NEW_RELEASE:
                    thisAmount += daysRented * 3;
                    break;
                case Movie.CHILDRENS:
                    thisAmount += 1.5;
                    if (daysRented > 3)
                        thisAmount += (daysRented - 3) * 1.5;
                    break;
            }

            return thisAmount;
        }
    }

 public class RegularPrice : Price
    {
        public override int getPriceCode()
        {
            return Movie.REGULAR;
        }

        public override double getCharge(int daysRented)
        {
            double result = 2;
            if (daysRented > 2)
                result += (daysRented - 2) * 1.5;

            return result;
        }
    }

 

   继续抽取直至所有实现都转移到子类中, 这时候Price类变成：

    public abstract class Price
    {
        public abstract int getPriceCode();

        public virtual double getCharge(int daysRented)
        {
            double thisAmount = 0;

            //determine amounts for each line
            switch (getPriceCode())
            {
                case Movie.REGULAR:
                    break;
                case Movie.NEW_RELEASE:
                    break;
                case Movie.CHILDRENS:
                   break;
            }

            return thisAmount;
        }
    }

       实际上Price类的getPrice方法已经没有任何计算了，这时候也没有子类尚未实现getCharge方法，所以把这个类改为抽象的就顺其自然了。改完后Price变成：

 public abstract class Price
    {
        public abstract int getPriceCode();

        public abstract double getCharge(int daysRented);
    }

       从这个过程中你可以看到getPrice是如何从一个普通的方法变成virtual、最后变成abstract的。从一定程度上来说abstract方法就是virtual方法的一个特殊形式，只不过这个修饰符约定了所有继承具体类都实现了这个方法，因而这个方法中不需要再有任何实现了。
      有时候花一点时间干点体力活是有好处的！