20155307《Java程序设计》实验二实验报告

一、单元测试和TDD

用程序解决问题时，要学会写以下三种代码：

伪代码

产品代码

测试代码

正确的顺序应为：伪代码（思路）→ 测试代码（产品预期功能）→ 产品代码（实现预期功能），这种开发方法叫“测试驱动开发”（TDD）。TDD的一般步骤如下：

明确当前要完成的功能，记录成一个测试列表

快速完成编写针对此功能的测试用例

测试代码编译不通过（没产品代码呢）

编写产品代码

测试通过

基于TDD，可以有效避免过度开发的现象，因为我们只需要让测试通过即可。

一：

实现百分制成绩转成“优、良、中、及格、不及格”五级制成绩的功能

• 首先用伪代码理思路：
  
  如果成绩小于60，转成“不及格”
  
  如果成绩在60与70之间，转成“及格”
  
  如果成绩在70与80之间，转成“中等”
  
  如果成绩在80与90之间，转成“良好”
  
  如果成绩在90与100之间，转成“优秀”
  
  其他，转成“错误”

• 其次，选择一种语言把伪代码实现，也就成了产品代码

public class MyUtil{

public static String percentage2fivegrade(int grade){

//如果成绩小于0，转成“错误”

if ((grade < 0))

return "错误";

//如果成绩小于60，转成“不及格”

else if (grade < 60)

return "不及格";

//如果成绩在60与70之间，转成“及格”

else if (grade < 70)

return "及格";

//如果成绩在70与80之间，转成“中等”

else if (grade < 80)

return "中等";

//如果成绩在80与90之间，转成“良好”

else if (grade < 90)

return "良好";

//如果成绩在90与100之间，转成“优秀”

else if (grade <= 100)

return "优秀";

//如果成绩大于100，转成“错误”

else

return "错误";

}

}

• 测试代码不就是多次调用System.out.println()：

public class MyUtilTest {

public static void main(String[] args) {

if(MyUtil.percentage2fivegrade(55) != "不及格")

System.out.println("test failed!");

else if(MyUtil.percentage2fivegrade(65) != "及格")

System.out.println("test failed!");

else if(MyUtil.percentage2fivegrade(75) != "中等")

System.out.println("test failed!");

else if(MyUtil.percentage2fivegrade(85) != "良好")

System.out.println("test failed!");

else if(MyUtil.percentage2fivegrade(95) != "优秀")

System.out.println("test failed!");

else

System.out.println("test passed!");

}

}

二、

以TDD的方式研究学习StringBuffer

• 自己写JUnit测试用例：
  
  public static void main(String [] args){
  
  StringBuffer buffer = new StringBuffer();
  
  buffer.append('S');
  
  buffer.append("tringBuffer");
  
  System.out.println(buffer.charAt(1));
  
  System.out.println(buffer.capacity());
  
  System.out.println(buffer.length());
  
  System.out.println(buffer.indexOf("tring"));
  
  System.out.println("buffer = " + buffer.toString());

• 对于这个程序，有有四个方面来测试，charAt()、capacity()、length()、indexOf产品代码如下：

public class StringBufferDemo{

StringBuffer buffer = new StringBuffer();

public StringBufferDemo(StringBuffer buffer){

this.buffer = buffer;

}

public Character charAt(int i){

return buffer.charAt(i);

}

public int capacity(){

return buffer.capacity();

}

public int length(){

return buffer.length();

}

public int indexOf(String buf) {

return buffer.indexOf(buf);

}

}

• 接下来我们需要对调用各种方法的返回值进行猜测：
  
  public class StringBufferDemoTest extends TestCase {
  
  StringBuffer a = new StringBuffer("StringBuffer");//测试12个字符（<=16）
  
  StringBuffer b = new StringBuffer("StringBufferStringBuffer");//测试24个字符（>16&&<=34）
  
  StringBuffer c = new StringBuffer("StringBufferStringBufferStringBuffer");//测试36个字符（>=34）
  
  @Test
  
  public void testcharAt() throws Exception{
  
  assertEquals('S',a.charAt(0));
  
  assertEquals('g',a.charAt(5));
  
  assertEquals('r',a.charAt(11));
  
  }
  
  @Test
  
  public void testcapacity() throws Exception{
  
  assertEquals(28,a.capacity());
  
  assertEquals(40,b.capacity());
  
  assertEquals(52,c.capacity());
  
  }
  
  @Test
  
  public void testlength() throws Exception{
  
  assertEquals(12,a.length());
  
  assertEquals(24,b.length());
  
  assertEquals(36,c.length());
  
  }
  
  @Test
  
  public void testindexOf() throws Exception{
  
  assertEquals(0,a.indexOf("Str"));
  
  assertEquals(5,a.indexOf("gBu"));
  
  assertEquals(10,a.indexOf("er"));
  
  }
  
  }

三、对MyDoc类进行扩充，让其支持Short类，初步理解设计模式。

• OCP是OOD中最重要的一个原则，要求软件实体（类，模块，函数等）应该对扩充开放，对修改封闭。同时，模块的源代码是不可改动的，任何人都不许修改已有模块的源代码。已有的支持Int型的代码如下：
  
  abstract class Data{
  
  public abstract void DisplayValue();
  
  }
  
  class Integer extends Data {
  
  int value;
  
  Integer(){
  
  value=100;
  
  }
  
  public void DisplayValue(){
  
  System.out.println(value);
  
  }
  
  }
  
  class Document {
  
  Data pd;
  
  Document() {
  
  pd=new Integer();
  
  }
  
  public void DisplayData(){
  
  pd.DisplayValue();
  
  }
  
  }
  
  public class MyDoc {
  
  static Document d;
  
  public static void main(String[] args) {
  
  d = new Document();
  
  d.DisplayData();
  
  }
  
  }

• 要求支持Short类，Document类要修改构造方法，这还违反了OCP原则。封装、继承、多态解决不了问题了，这时需要设计模式了：

abstract class Data {

abstract public void DisplayValue();

}

class Integer extends Data {

int value;

Integer() {

value=100;

}

public void DisplayValue(){

System.out.println (value);

}

}

// Pattern Classes

abstract class Factory {

abstract public Data CreateDataObject();

}

class IntFactory extends Factory {

public Data CreateDataObject(){

return new Integer();

}

}

• 只需要class Short extends Data、class ShortFactory extends Factory即可使系统支持Short类型，测试代码如下:

public class MyDoc {

static Document d;

public static void main(String[] args) {

d = new Document(new ShortFactory());

d.DisplayData();

}

}

四、以TDD的方式开发一个复数类Complex：

• TDD的编码节奏是：增加测试代码，JUnit出现红条 - 修改产品代码 - JUnit出现绿条，任务完成

• 测试代码：
  
  public class ComplexTest extends TestCase {
  
  Complex c1 = new Complex(0, 3);
  
  Complex c2 = new Complex(-1, -1);
  
  Complex c3 = new Complex(2,1);
  
  @Test
  
  public void testgetRealPart() throws Exception {
  
  assertEquals(-1.0, Complex.getRealPart(-1.0));
  
  assertEquals(5.0, Complex.getRealPart(5.0));
  
  assertEquals(0.0, Complex.getRealPart(0.0));
  
  }
  
  @Test
  
  public void testgetImagePart() throws Exception {
  
  assertEquals(-1.0, Complex.getImagePart(-1.0));
  
  assertEquals(5.0, Complex.getImagePart(5.0));
  
  assertEquals(0.0, Complex.getImagePart(0.0));
  
  }
  
  @Test
  
  public void testComplexAdd() throws Exception {
  
  assertEquals("-1.0+2.0i", c1.ComplexAdd(c2).toString());
  
  assertEquals("2.0+4.0i", c1.ComplexAdd(c3).toString());
  
  assertEquals("1.0", c2.ComplexAdd(c3).toString());
  
  }
  
  @Test
  
  public void testComplexSub() throws Exception {
  
  assertEquals("1.0+4.0i", c1.ComplexSub(c2).toString());
  
  assertEquals("-2.0+2.0i", c1.ComplexSub(c3).toString());
  
  assertEquals("-3.0 -2.0i", c2.ComplexSub(c3).toString());
  
  }
  
  @Test
  
  public void testComplexMulti() throws Exception {
  
  assertEquals("3.0 -3.0i", c1.ComplexMulti(c2).toString());
  
  assertEquals("-3.0+6.0i", c1.ComplexMulti(c3).toString());
  
  assertEquals("-1.0 -3.0i", c2.ComplexMulti(c3).toString());
  
  }
  
  @Test
  
  public void testComplexComplexDiv() throws Exception {
  
  assertEquals("-1.5 -1.5i", c1.ComplexDiv(c2).toString());
  
  assertEquals("1.2+0.6i", c1.ComplexDiv(c3).toString());
  
  assertEquals("-0.6 -0.6i", c2.ComplexDiv(c3).toString());
  
  }
  
  }

• 产品代码:

public class Complex{

private double r;

private double i;

public Complex(double r, double i) {
    this.r = r;
    this.i = i;
}

public static double getRealPart(double r) {
    return r;
}

public static double getImagePart(double i) {
    return i;
}

public Complex ComplexAdd(Complex c) {
    return new Complex(r + c.r, i + c.i);
}
public Complex ComplexSub(Complex c) {
    return new Complex(r - c.r, i - c.i);
}
public Complex ComplexMulti(Complex c) {
    return new Complex(r * c.r - i * c.i, r * c.i + i * c.r);
}
public Complex ComplexDiv(Complex c) {
    return new Complex((r * c.i + i * c.r)/(c.i * c.i + c.r * c.r), (i * c.i + r * c.r)/(c.i * c.i + c.r * c.r));
}

public String toString() {
    String s = " ";
    if (i > 0)
        s =  r + "+" + i + "i";
    if (i == 0)
        s =  r + "";
    if (i < 0)
        s = r + " " + i + "i";
    return s;
}

}

五、使用StarUML对实验二中的代码进行建模