{

              int  dataValid;

              protected checkDataValid()

              {

                     check if dataValid valid

                     if (fail)

                     {     throws new RZXDataException(this, “.needValidate=”

+needValidate); }

              }

public ValidClass(int in)

              {    

setDataValid(in);    

}

              public setDataValid(int in)

              {                     
                     checkNeedValidate();

                     dataValid = in;

              }

       }

在set方法中进行合法性检查，然后在构造方法中也调用set方法设置字段值，而不直接使用类中的字段。这样做的好处很明显：不仅保证了构造方法中传入的数据必须合法，而且可以保证程序在使用的过程中不能使用非法数据，如果程序员使用了非法数据，程序运行必然出错，并且能够很快的找到错误的根源所在。

         另外，有些程序员认为，有些数据类的对象全部来自于另一个数据对象，也就是说该类的构造方法中的参数即另一个数据类对象，因此在该类中所有与被传入对象类中有相同的合法性检查的数据字段不需要再进行合法性检查了。其实这种想法是错误的，问题与上面所说的一样，你能保证传入的数据是合法的，但不能保证使用者在调用你的set方法时能100%传入合法数据。因此，程序员是不应该偷这个懒的。也许有人会说，他们的合法性检查完全一样，如果在该类中再写的话就会出现大量的重复代码了。能想到这里是对的，但是如果你有一定的经验，你就知道去建立一个专门保存合法性检查方法的类，这样你就可以在需要进行合法性检查的时候就使用该类里面的方法，如果该类中没有你所需要的方法，你就可以在里面加入你所需要的合法性检查方法，再去使用它。这样做会使得代码非常的清晰。

         我认为，应该在自己类中的所有使用“this.value = data;”字样的代码都应该使用setValue()，因为也许这个字段现在不需要进行合法性检查，但是不能保证将来也没有合法性要求。而一旦以后需要对该字段进行合法检查的时候，就需要在set方法中增加合法性检查代码，而且需要将该类中所有对该字段的赋值语句均改用set方法。一旦有某处漏掉，则很可能带来致命的错误。也许在某个运算中带来了非法数据，但是你却怎么也不会往这方面去想，因为你一直以为自己全部都作了合法性检查的。

import java.util.Enumeration;
import java.util.Vector;

public class Customer
{
 private String _name;// 姓名
 private Vector<Rental> _rentals = new Vector<Rental>();// 租借记录

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

 public String getName()
 {
  return _name;
 }

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

 public String statement()
 {
  double totalAmount = 0;// 总消费金额
  int frequentRenterPoints = 0;// 常客积点
  Enumeration rentals = this._rentals.elements();
  String result = "Rental Record for" + getName() + "\n";

  while(rentals.hasMoreElements())
  {
   double thisAmount = 0;
   Rental each = (Rental)rentals.nextElement();

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

   // add frequent renter points(累加 常客积点)
   frequentRenterPoints++;

   // add bonus for a two day new release rental
   if((each.get_movie().get_priceCode()) == Movie.NEW_RELEASE
    && each.get_dayRented() > 1)
    frequentRenterPoints++;
   // show figures for this rental(显示此笔租借数据)
   result += "\t" + each.get_movie().get_title() + "\t"
      + String.valueOf(thisAmount) + "\n";

   totalAmount += thisAmount;
  }

  // add footer lines(结尾打印)
  result += "Amount owed is " + String.valueOf(totalAmount) + "\n";
  result += "You earned " + String.valueOf(frequentRenterPoints)
     + "frequent renter points";
  return result;
 }
}

package cn.com;

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

 private String _title; // 名称
 private int _priceCode;// 价格

 public Movie(String _title, int _priceCode)
 {
  this._title = _title;
  this._priceCode = _priceCode;
 }

 /**
  * @return 返回 _priceCode。
  */
 public int get_priceCode()
 {
  return _priceCode;
 }

 /**
  * @param code
  *        要设置的 _priceCode。
  */
 public void set_priceCode(int code)
 {
  _priceCode = code;
 }

 /**
  * @return 返回 _title。
  */
 public String get_title()
 {
  return _title;
 }
}

package cn.com;

public class Rental
{
 private Movie _movie;// 影片
 private int _dayRented;// 租期

 public Rental(Movie _movie, int _dayRented)
 {
  this._movie = _movie;
  this._dayRented = _dayRented;
 }

 public int get_dayRented()
 {
  return _dayRented;
 }

 public Movie get_movie()
 {
  return _movie;
 }
}

方法的注释 :

1.         清楚地表述出方法的功能，即该方法做什么。不用表述怎么做（怎么做是算法层面的东西，如果算法有一定的复杂度，在其它文档表述，如流程图、算法、序列图等）。注意点是：方法可能实现多个相关功能，要表述每个功能的激活条件（即输入参数的特征），及相应的功能。

若该方法与其它若干个方法相关，要将它们的关联性表述出来，这对于理解整个类的行为很关键。特别是，当对象有状态时，这时该方法的调用可能要依赖于其它方法的先行调用（即对象的当前状态），对象的状态改变及方法的依赖关系是必须描述清楚的。

方法的功能点是指外部可观察的行为：如方法的返回值；方法做的日志；如果有输入参数，方法的输入 — 〉返回的对应关系；产生的异常及其原因；方法的前置依赖；方法造成的对象状态改变（后置状态）等。

输入参数的有效性要表述吗？异常需要表述吗 ? 视情况而定，如果情况复杂，特别是异常的产生的原因复杂，需要较多的话才能表述清楚，就需要表述。

2.         输入参数：包括参数的含义，及有效性格式。如果某个参数的有效性方法内部不作检查，要清晰地说明，这意味着调用者自己要保证参数的有效性，不然会造成不确定的错误。通常，这种情况出现在从外部传入大量的数据，并且对数据有效性检查很烦琐，这时可以在系统入口进行有效性检查，系统内部的方法就不再进行检查了。

3.         返回参数：包括参数的含义，可能会有多个不同的返回值，通常是一个有效返回和一个异常返回，对于异常返回，要表述其对应的输入参数。

4.         抛出异常：表述产生各个异常产生的原因。

表述的清晰性检查：

1．  用举例来辅助说明一些文字表述较困难的思想

2．  要注意分段，跟写文章一样，当注释很长时，要有分段。

3．  与单元测试对应性，方法的每个功能点都应该有相应的单元测试对应

4．  方法之间的依赖关系也是功能点，应该有相应的单元测试。

单元测试的注释：

1 ．测试函数名： test+ 方法名 + 分类 + 数字编号，分类是 Right-Correct 的全称，数字编号是该分类的测试用例编号。如测试 mutiple 的一个测试函数可命名为 testMultipleRight1 。

2 ． 描述：测试哪个功能点？测试哪个参数有效性格式？测试哪个方法依赖性？测试哪个异常？（这些与方法的注释对应）

       输入参数：

输出结果：

 当被测试方法的输入、输出不那么明显时，也就是说可能没有输入参数或者没有返回值时，输入、输出中则视情况而写。

输入：为测试准备的前提条件（可以是事件）。
输出： 测试期望得到的结果，不一定是返回值。

import junit.framework.TestCase;

public class TestMoney extends TestCase {
 public void testMultiplication() {
  Money five = Money.dollar(5);
  assertEquals(Money.dollar(10), five.times(2));
  assertEquals(Money.dollar(15), five.times(3));
 }

 public void testEqualsObject() {
  assertTrue(Money.dollar(5).equals(Money.dollar(5)));
  assertFalse(Money.dollar(5).equals(Money.dollar(6)));
  assertFalse(Money.franc(5).equals(Money.dollar(5)));
 }

 public void testCurrency() {
  assertEquals("USD", Money.dollar(1).currency());
  assertEquals("CHF", Money.franc(1).currency());
 }

 public void testSimpleAddition() {
  Money five = Money.dollar(5);
  Expression result = five.plus(five);
  Sum sum = (Sum) result;
  Bank bank = new Bank();
  Money reduced = bank.reduce(sum, "USD");
  assertEquals(Money.dollar(10), reduced);
 }

 public void testPlusReturnSum() {
  Money five = Money.dollar(5);
  Expression result = five.plus(five);
  Sum sum = (Sum) result;
  assertEquals(five, sum.augend);
  assertEquals(five, sum.addend);
 }

 public void testReduceSum() {
  Expression sum = new Sum(Money.dollar(3), Money.dollar(4));
  Bank bank = new Bank();
  Money result = bank.reduce(sum, "USD");
  assertEquals(Money.dollar(7), result);
 }
 public void testReduceMoney(){
  Bank bank = new Bank();
  Money result = bank.reduce(Money.dollar(1), "USD");
  assertEquals(Money.dollar(1),result);
 }
}

				
						读完TDD（测试驱动开发），发现其中主要就是在反复说了这么两件事情（也就是两个简单的规则）：一、在写任何代码之前，写一个会失败的自动测试程序，即单元测试；二、消除重复设计，优化设计结构，即重构。整本书都围绕着这两个规则来进行说明，告诉读者到底要如何这样做？又如何分阶段应用这些规则？这两条简单的规则可以运用多深？
				
		

				
						第一部分通过一个简单的实例来告诉读者如何使用TDD，如何反复通过“不可运行/可运行/重构/不可运行/可运行/重构”来进行开发；第二部分告诉读者如何使用单元测试，怎样组织单元测试；第三部分则是将TDD分解成较小的步骤来进行详细说明，根据我对本书的理解，我认为需要完全将TDD运用到日常的开发行为中，则要按照以下非常细小的步骤进行：
				
		

1.       获得任务。即项目经理安排的任务。任务往往不止一项。将它们写入周工作计划表或者月工作计划表。

2.       选择任务。每天开始工作之前，将今天将要解决的问题写入工作计划列表。并选择自己最有把握完成的任务作为当前任务。

3.       分析并分解任务。将当前任务分解成一个个相对简单的问题，分解的问题最好是能在十多分钟之内能完成，并将它们写入工作列表。如：若要实现多币种相加，则可以分解为：实现相同币种之间的相加，不同币种之间的互换，最后才能实现不同币种之间的相加。

4.       写测试列表。将分解后的问题所对应的测试写入测试列表。

5.       选择测试。从测试列表中选择自己认为最有把握实现的一项。如：“同币种相加”对我来说是最有把握实现的一项，因此我最先来实现它，即先从它的测试程序开始编写。

6.       编写测试数据。写一个容易让人理解的必须实现的测试数据列表，尽量使用显然数据。如：用 String 表示 IP 地址 "255.255.255.255" 转换为 int ，在我们写测试数据时应这样写： (255 << 24) + (255 << 16) + (255 << 8) + 255 ，而不是写“ -1 ”。

7.       编写测试。选择一项最容易让测试通过的测试数据加入测试方法。断言优先，然后加入为了让断言通过编译的一切准备条件。

8.       运行测试，不可运行状态。

9.       编写方法注释，把所有想到的该方法要实现的功能写上。

10.   编写功能代码，使之达到可运行状态。

11.   重构，消除重复设计。

12.   往测试方法中增加一个新的小测试。

13.   运行测试，不可运行状态。

14.   修改功能代码，使之达到可运行状态。

15.   重构。消除重复设计。

16.   重复 12-15 。

17.   当无论如何也不能让该测试通过的时候，认真想一想是不是哪里出大问题了，如果实在想不出来的话，就将现有代码扔掉，重新开始。

18.   所有测试都运行通过之后，仔细检查所有代码，看是否还有值得重构的地方，并重构。

19.   提交 (check in) 。

20.   再选择测试列表中的下一个测试。重复以上步骤。

21.   当一天的工作结束时，若有某个任务未完成，则留下一个不完整测试，以便于次日能迅速回忆起当时写该代码时的想法，并接着写下去。

				
						以下是我对本书中某些观点的看法：
				
		

				
						
								1.
								     
						
				
				
						本书旨在培训我们具有按照极小的步骤进行开发，并寻找Bug的能力，并不是说一定要按如此小的步骤进行。
				
		

				
						
								2.
								     
						
				
				
						书中所反复强调的“测试优先”，“断言优先”是说在功能代码之前先写测试，先写断言，可是反过头来，以第一个测试来说：
				
		

				
						public void testMutiplication()
				
		

				
						{
				
		

				
						Dollar five = new Dollar(5);
				
		

				
						five.times(2);
				
		

				
						assertEquals(10,five.amount);
				
		

				
						}
				
		

				
						就这个测试来说，其实作者在写测试的时候也想了很多的问题：把这个测试放哪？总不可能拿记事本来写吧！至少该给这个测试方法先建立一个测试类吧！同样在建立这个测试类的时候，是不是也在想着为该类命什么样的名？再进一步，我要写测试方法，在为测试方法命名的时候实际上也是在为我们所要写的方法命名，不是么？因此，我觉得，在我还没有达到Kent Beck的水平之前，我还是会在写测试之前先想一想即将要编写的方法应归于哪个类，并先将该类创建好，再把下一步要编写的方法写好（当然此时肯定也是一个空方法），同时把自己所能想到的方法将要实现的功能（可以是比较粗略的）全部写入方法注释中，此时的注释可以是比较随意的，因为在把方法写完之后还要进行重构嘛！然后按照注释中的功能来编写一个一个的测试方法并完善功能代码。
				
		

				
						
								3.
								     
						
				
				
						如果按照本书所说的，开发过程中几乎没有事先的设计，因为作者认为良好的设计会在重构中逐渐浮出水面的。但是我很清楚，我不是Kent Beck，如果没有事先设计的话，以我现在的水平，重构时的工作量一定会非常大；因此如果在写代码之前花一定的时间设计一下代码结构，可以在一定程度上减小重构时的工作量。并且我认为良好的事先设计会为重构工作减少很大的工作量，当然事先设计也不应该占有太多的时间，否则，还不如先写完之后慢慢来重构。
				
		

				
						
								4.
								     
						
				
				
						书中所说的关注当前工作这一点非常好，因为在现实工作中，常常会因为想到与当前工作相关的事情可能会比较多，而往往我们会丢下手上的工作，先去完成另外一项工作，可是等回到刚才丢下的工作前时又要花很长的一段时间来回忆当时的情形。因此，我们应该学习书中的方法，把新想法记录下来，等完成当前工作后再去考虑。也许有些时候会出现这种情况，如果另外一件事情未完成，当前工作无法进行的情况不得不打断当前工作，那就不得不将注意力全部转移到另外一件事情上去。但是，如果这种打断出现多次的时候，就应该认真思考自己的分析问题的粒度是不是太大了，然后重新去分解问题。等问题分析到可以不依赖未编写过的方法时再继续工作也不迟。这样只会提高工作效率和自信心。否则，不停地从当前工作中跳出，不仅为影响工作效率，而且会影响自信心，为什么还有这么多没有完成呢？因为在你不断地跳出当前工作后，你就会留下一个个未完成的工作。你的脑子里就会想着还有多少个未完成的工作在等着自己去完成。
						
								
								
						
				
		

				
						
								5.
								     
						
				
				
						留下一个不完整测试是在编程期间结束工作的最好办法。因为当测试运行时没出现绿色状态条时，会很容易找到明显的地方重新开始。这一点实现起来可能有点困难，但是却是一个非常有效的办法，当工作任务繁多的时候常常会忘记昨天做到哪了，今天该从哪做起。
						
								
								
						
				
		

				
						
								6.
								     
						
				
				
						当编写功能代码时，为了让测试通过可以采取的措施有：显明实现，伪实现，三角法，从一到多。当自己让该测试通过有把握的时候，即使用显明实现；若在显明实现的过程中，无法达到可运行状态，则返回到之前的可运行状态，采用伪实现的方法使测试达到可运行状态；当需要为集合编写测试的时候，采用从一到多的方法。如：数组求和则可以先测试该数组中只有一个元素，再逐渐增加元素进行测试。
				
		

				
						
								7.
								     
						
				
				
						相互独立的测试。即每个测试之间必须互不干扰。如果一个测试失败必须只对应一个问题；两个失败就对应两个问题。测试之间都不依赖与运行顺序，一个测试不要因为前面的测试不存在而失败。这一点实现起来其实也相当的困难，因为当一个底层函数的测试失败时，其上层函数（即调用了它的那些函数）的测试程序都可能会失败，因此很难做到一个失败的测试对应一个问题。
				
		

				
						
								8.
								     
						
				
				
						当在编写代码时，当第一次准备使用某个包内的某项新功能时，为其编写测试，即学习测试。看它是否满足我们期望的要求。并且必须在其符合我们的期望要求时我们才可以在程序中使用它。
				
		

				
						
								9.
								     
						
				
				
						当每新建一个包时，即新建一个AllTests类用于测试该包中所有测试类。在每写一个测试类时，先将public static Test suite()写好，并把该测试类加入到包中的AllTests中，随时确保包AllTests中包含了包中的所有测试程序。
				
		

				
						
								10.
								  
						
				
				
						需要重点掌握的重构方法（即常用的重构）有：重命名，提取方法，添加参数，删除参数，方法内联，提炼方法对象，消除临时变量，提取匿名类，分离内部类等等。
				
		

				
						
								11.
								  
						
				
				
						在我们工作的过程中，很多时候会遇到一些很困难的问题，在反反复复思考许多遍还是想不到解决的办法，往往这样的情况是我们的思维陷入了错误的陷阱里，在这个时候我们可以选择休息一会，喝一杯茶，走动一下。抛开那些刚才所做的事情。如果在休息了多次之后还没有想到解决方案，就扔掉这些代码，重新开始。