20145207《Java程序设计》实验二（Java面向对象程序设计）实验报告

《Java程序设计》实验二（Java面向对象程序设计）实验报告

目录

• 改变
• Java面向对象程序设计实验要求
• 实验成果
• 课后思考

改变

   看了下之前实验二的整体，很搞笑，大图+代码，没了。。。整体重改

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 "错误";
    }
}

产品代码是为用户提供的，为了保证正确性，我们需要对自己的程序进行测试，考虑所有可能的情况，来判断结果是否合乎要求。这是我们就需要写测试代码。

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!");
    }
}

如果输出test passed!，那就代表通过测试咯~

输出test failed!即为不通过，Java中有单元测试工具JUnit来辅助进行TDD，我们用TDD的方式把前面百分制转五分制的例子重写一次，体会一下有测试工具支持的开发的好处。鼠标放在需要测试的类上单击，出现一个黄色灯泡，点击选择“Create Test”即可。软件还算比较智能

测试代码：

import org.junit.Test;
import junit.framework.TestCase; //注意导包！！！
public class MyUtilTest extends TestCase {
    @Test
    public void testNormal() {
        assertEquals("不及格", MyUtil.percentage2fivegrade(55));
        assertEquals("及格", MyUtil.percentage2fivegrade(65));
        assertEquals("中等", MyUtil.percentage2fivegrade(75));
        assertEquals("良好", MyUtil.percentage2fivegrade(85));
        assertEquals("优秀", MyUtil.percentage2fivegrade(95));
    }
}

如果出现问题，IDEA就会提示我们具体是哪一步出错了。比如：

可以看出，IDEA提示我们究竟实际的结果以及预期的结果。

任务二：以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());

首先我们需要对这个程序进行改写，写成上面的产品代码那种类型的，以便于我们进行测试。

产品代码如下：

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"));
    }
}

可以看到，出现了“green bar”，说明测试通过了，我们对StringBuffer也有了更加深刻的认识

任务三：使用StarUML对实验二中的代码进行建模

UML是一种通用的建模语言，可以非常直观地表现出各个结构之间的关系。

基于以上学习，我们在UML中实现了类，继承和接口的组合：

当然，UML还可以实现更多更复杂的功能，只做了要求的，时间不大够

面向对象三要素是“封装、继承、多态”，任何面向对象编程语言都会在语法上支持这三要素。如何借助抽象思维用好三要素特别是多态还是非常困难的，S.O.L.I.D类设计原则是一个很好的指导：

• SRP(Single Responsibility Principle,单一职责原则)
• OCP(Open-Closed Principle,开放-封闭原则)
• LSP(Liskov Substitusion Principle,Liskov替换原则)
• ISP(Interface Segregation Principle,接口分离原则)
• DIP(Dependency Inversion Principle,依赖倒置原则)

任务四：对MyDoc类进行扩充，让其支持Long类，初步理解设计模式

OCP是OOD中最重要的一个原则，要求软件实体（类，模块，函数等）应该对扩充开放，对修改封闭。也就是说，软件模块的行为必须是可以扩充的，在应用需求改变或需要满足新的应用需求时，我们要让模块以不同的方式工作；同时，模块的源代码是不可改动的，任何人都不许修改已有模块的源代码。OCP可以用以下手段实现：

（1）抽象和继承，

（2）面向接口编程。

以这道题为例，已有的支持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();      
    }   
}

如果要求支持Long类，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 Long extends Data、class LongFactory extends Factory即可使系统支持Long类型，测试代码如下：

public class MyDoc {
    static Document d;
    public static void main(String[] args) {
        d = new Document(new LongFactory());
        d.DisplayData();
    }
}

我们看到，通过增加了一层抽象层使代码符合了OCP原则，使代码有良好的可扩充性、可维护性。不过，设计模式也不能过度使用，具体在哪些场合应用还要看实际问题。

课后思考

@Test或者import junit.framework.TestCase为什么是红的？

当时做出了这样的问题，查了下其他同学的博客想起了解决方式

进入之后，根据你的IDEA安装地址导入这两个包就可以了。

学习反思及总结

   平时写的博客确实不够认真，实验全部重新修改，以上。

标签: Java学习笔记