2018-2019-2-20175303 实验二 《Java开发环境的熟悉》实验报告

2018-2019-2-20175303 实验二 《Java开发环境的熟悉》实验报告

姓名：柴轩达       学号：20175303     班级：1753       实验课程：JAVA程序设计

实验名称：Java面向对象程序设计      实验时间：2019.4.14/15/16         指导老师：娄嘉鹏

一、实验内容及步骤

面向对象程序设计-1

下载JUnitGenerator V2.0插件用Junit生成Test类来检测MyUtil代码的是否正确，因为在做结对项目的时候已经需要用JUnit来监测代码的正确性了，所以这一任务比较熟练，完成也比较快。

1.MyUtil.java代码：

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

2.测试代码：

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));
    }
    @Test
    public void testExceptions() {
        assertEquals("错误",MyUtil.percentage2fivegrade(-80));
        assertEquals("错误",MyUtil.percentage2fivegrade(125));
    }
    @Test
    public void testBoundary() {
        assertEquals("不及格",MyUtil.percentage2fivegrade(0));
        assertEquals("及格",MyUtil.percentage2fivegrade(60));
        assertEquals("中等",MyUtil.percentage2fivegrade(70));
        assertEquals("良好",MyUtil.percentage2fivegrade(80));
        assertEquals("优秀",MyUtil.percentage2fivegrade(90));
        assertEquals("优秀",MyUtil.percentage2fivegrade(100));
    }
}

3.测试成功截图（正常情况，错误情况，边界情况都通过）：

面向对象程序设计-2

以TDD的方式研究学习StringBuffer：

1.TDD的测试步骤如下：

•明确当前要完成的功能，记录成一个测试列表
•快速完成编写针对此功能的测试用例
•测试代码编译不通过（没产品代码呢）
•编写产品代码
•测试通过
•对代码进行重构，并保证测试通过（重构下次实验练习）
•循环完成所有功能的开发

2.老师给出的StringBuffer的例子：

public class StringBufferDemo{
   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.indexOf("tring"));
       System.out.println("buffer = " + buffer.toString());
  }
}    

3.当前要完成的功能：
•charAt（int i）：得到字符串中第i个位置的字符，考虑到数组下标从0开始，字符串的位置也从0开始记。
•capacity（）：返回当前容量。容量指可用于最新插入的字符的存储量，超过这一容量就需要再次进行分配。
•length()：得到字符串长度
•indexOf（String buf）：得到buf字符串第一次出现的位置，该位置为buf中第一个字符的位置

4.对老师博客中给出的代码进行改写，测试charAt（int i），对测试的方法要加上返回值：

public class StringBufferDemo{
    StringBuffer buffer = new StringBuffer();
    public StringBufferDemo(StringBuffer buffer){
        this.buffer = buffer;
    }
    public Character charAt(int i){
        return buffer.charAt(i);
    }
}

5.测试代码：

import org.junit.Test;
import junit.framework.TestCase;

public class StringBufferDemoTest extends TestCase {
    StringBuffer a = new StringBuffer("StringBuffer12345");
    StringBuffer b = new StringBuffer("StringBufferStringBuffer123");
    StringBuffer c = new StringBuffer("StringBufferStringBufferStringBufferStringBuffer");
    @Test
    public void testcharAt() throws Exception {
        assertEquals('S',a.charAt(0));
        assertEquals('B',b.charAt(6));
        assertEquals('i',c.charAt(15));
    }
}

6.测试成功截图（charAt（int i）、capacity（）、length（）、indexOf（））

7.继续完善代码，测试charAt（int i），对测试的方法要加上返回值：

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

8.测试代码

import org.junit.Test;
import junit.framework.TestCase;

public class StringBufferDemoTest extends TestCase {
    StringBuffer a = new StringBuffer("StringBuffer12345");
    StringBuffer b = new StringBuffer("StringBufferStringBuffer123");
    StringBuffer c = new StringBuffer("StringBufferStringBufferStringBufferStringBuffer");
    @Test
    public void testcharAt() throws Exception {
        assertEquals('S',a.charAt(0));
        assertEquals('B',b.charAt(6));
        assertEquals('i',c.charAt(15));
    }
    @Test
    public void testcapacity() throws Exception {
        assertEquals(33,a.capacity());
        assertEquals(43,b.capacity());
        assertEquals(64,c.capacity());
    }
}

9.测试成功截图charAt（int i）、capacity（）

10.依次写对应功能的代码，一次测试……

11.改写完成的代码

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 str) {
        return buffer.indexOf(str);
    }
}

12.改写完成代码的测试代码

import org.junit.Test;
import junit.framework.TestCase;

public class StringBufferDemoTest extends TestCase {
    StringBuffer a = new StringBuffer("StringBuffer12345");
    StringBuffer b = new StringBuffer("StringBufferStringBuffer123");
    StringBuffer c = new StringBuffer("StringBufferStringBufferStringBufferStringBuffer");
    @Test
    public void testcharAt() throws Exception {
        assertEquals('S',a.charAt(0));
        assertEquals('B',b.charAt(6));
        assertEquals('i',c.charAt(15));
    }
    @Test
    public void testcapacity() throws Exception {
        assertEquals(33,a.capacity());
        assertEquals(43,b.capacity());
        assertEquals(64,c.capacity());
    }
    @Test
    public void testlength() throws Exception {
        assertEquals(17,a.length());
        assertEquals(27,b.length());
        assertEquals(48,c.length());
    }
    public void testindexOf() throws Exception {
        assertEquals(1,a.indexOf("tri"));
        assertEquals(6,a.indexOf("Bu"));
        assertEquals(-1,a.indexOf("456"));
    }
}

13.测试成功截图（charAt（int i）、capacity（）、length（）、indexOf（））

面向对象程序设计-3

对老师给出的代码进行扩充，体会OCP原则和DIP原则的应用，初步理解设计模式

我的的学号为20175303，3%6=3，所以我需要做的是让系统支持Long类，并在MyDoc类中添加测试代码表明添加正确，提交测试代码和运行结的截图，加上学号水印

1.补充long类后的代码如下（添加Long1类，LongFactory1类，在主函数内）：

abstract class Data {
    abstract public void DisplayValue();
}
class Integer1 extends  Data {
    int value;
    Integer1() {
        value=100;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
}
class Long1 extends Data{
    long value;
    Long1(){
        value=201750303;
    }
    public void DisplayValue(){
        System.out.println(value);
    }
}
abstract class Factory {
    abstract public Data CreateDataObject();
}
class IntFactory1 extends Factory {
    public Data CreateDataObject(){
        return new Integer1();
    }
}
class LongFactory1 extends Factory{
    public Data CreateDataObject(){
        return new Long1();
    }
}
class Document {
    Data pd;
    Document(Factory pf){
        pd = pf.CreateDataObject();
    }
    public void DisplayData(){
        pd.DisplayValue();
    }
}
//Test class
public class MyDoc {
    static Document d,e;
    public static void main(String[] args) {
        d=new Document(new IntFactory1());
        d.DisplayData();
        e=new Document(new LongFactory1());
        e.DisplayData();
    }
}

2.测试结果的截图：

面向对象程序设计-4

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

1.明确要开发的功能：
在Complex类中设置构造方法public myComplex(double R,double I),设置实部与虚部
实现加法myComplex ComplexAdd(myComplex a)
实现减法myComplex ComplexSub(myComplex a)
实现乘法myComplex ComplexMulti(myComplex a)
实现除法myComplex ComplexDiv(myComplex a)
重写equals（）方法
重写toString（）方法

2.一个一个功能的实现，并每写完一个功能测试一个功能，最后代码为：

public class myComplex {
        // 定义属性并生成getter,setter
        double RealPart;
        double ImagePart;
        // 定义构造函数
        myComplex(double R,double I){
            RealPart=R;
            ImagePart=I;
        }
        // 定义公有方法:加减乘除
        myComplex ComplexAdd(myComplex a){
            return new myComplex(RealPart+a.RealPart,ImagePart+a.ImagePart);
        }
        myComplex ComplexSub(myComplex a){
            return new myComplex(RealPart-a.RealPart,ImagePart-a.ImagePart);
        }
       myComplex ComplexMulti(myComplex a){
            return new myComplex(RealPart*a.RealPart-ImagePart*a.ImagePart,RealPart*a.ImagePart+a.RealPart*ImagePart);
        }
        myComplex ComplexDiv(myComplex a){
            return new myComplex((RealPart*a.RealPart+ImagePart*a.ImagePart)/(a.RealPart*a.RealPart+a.ImagePart*a.ImagePart),(-RealPart*a.ImagePart+a.RealPart*ImagePart)/(a.RealPart*a.RealPart+a.ImagePart*a.ImagePart));
        }
    //Override Object
     public boolean equals(Object obj){
            if(obj==null)
         return false;
     else {
         myComplex m = (myComplex) obj;
         if (m.RealPart == RealPart && m.ImagePart == ImagePart)
             return true;
         else return false;
     }
        }

    public String toString(){
        String output;
        if(ImagePart==0){
            return output=RealPart+"";
        }
        else if(RealPart==0 && ImagePart!=0){
            return output=ImagePart+"i";
        }
        else if(ImagePart>0) {
            return output=RealPart+"+"+ImagePart+"i";
        }
        else return output=RealPart+""+ImagePart+"i";
    }
    }

3.总的测试代码为：

import junit.framework.TestCase;
import org.junit.Test;

public class myComplexTest extends TestCase {
    myComplex a = new myComplex(6,2);
    myComplex b = new myComplex(5,1);
    myComplex c = new myComplex(4,-2);
    myComplex d = new myComplex(3,1);
    myComplex e = new myComplex(6,2);
    //myComplex e = new myComplex(2,4);
    @Test
    public void testEquals() {
        assertEquals(false,a.equals(b));
        assertEquals(true,a.equals(e));
    }
    @Test
    public void testComplexAdd() throws Exception {
        assertEquals("11.0+3.0i",b.ComplexAdd(a).toString());
        assertEquals("10.0",a.ComplexAdd(c).toString());
        assertEquals("9.0-1.0i",b.ComplexAdd(c).toString());
    }
    @Test
    public void testComplexSub() {
        assertEquals("-1.0-1.0i",b.ComplexSub(a).toString());
        assertEquals("2.0+4.0i",a.ComplexSub(c).toString());
        assertEquals("2.0",b.ComplexSub(d).toString());

    }
    @Test
    public void testComplexMulti() {
        assertEquals("28.0+16.0i",b.ComplexMulti(a).toString());
        assertEquals("28.0-4.0i",a.ComplexMulti(c).toString());
        assertEquals("14.0+8.0i",b.ComplexMulti(d).toString());
    }
    @Test
    public void testComplexDiv() {
        assertEquals("2.0",a.ComplexDiv(d).toString());
        assertEquals("1.0+1.0i",a.ComplexDiv(c).toString());
        }
}

4.测试成功截图

面向对象程序设计-5

使用StarUML对实验二中的代码进行建模，发类图的截图，加上学号水印

1.打开StarUML，选择Default Approach：

2.在view里边选择toolbox弹出工具箱，没法截图，所以照了个相：

3.工具箱里有画UML图的各种表示：

4.一般规范

•类的UML图使用一个长方形描述一个类的主要构成，将长方形垂直地分为三层。第一层是名字层，常规字型则是具体类，斜体字形则是抽象类。（实验二-3补充long类，中有虚拟类Factory和Data类，但我找不到怎么画一个虚拟类的UML图，网上也搜不到）；第二层是变量层；第三层是方法层。

•关联关系，若A关联B（A类中的成员变量是用B类声明的对象），用一个起始端是A，终点端是B的实线加一个指向B的方向箭头表示；

•依赖关系，若A依赖于B（A类中某个方法的参数是用B类声明的对象或某个方法返回的数据类型是B类对象），用用一个起始端是A，终点端是B的虚线加一个指向B的方向箭头表示；

•继承关系，A类继承B类，用实线加一个空心三角形来表示，实线的起始端是子类的UML图，终点端是父类的UML图。

•当A类继承了抽象类B类，用虚线加一个空心三角形来表示，实线的起始端是子类的UML图，终点端是抽象类的UML图。

5.实验二-3代码UML图：

二、实验中遇到的问题

问题1.实验二-3最开始看不懂题（老师连接中有好些图加载失败）；

问题1解决方法：问了问同学，知道要干嘛了就不难了；

问题2：实验二-4实现自己的复数类在测试时，总是测试一行，测试第二行，会受第一行测试结果的影响，找好半天找不着问题，问学长也不知道问题出在哪

问题2解决方法：不知道哪错就在有可能错的地方瞎改，把代码的构造方法时访问修饰符public，去掉了就可以正常测试了；

问题3：abstract类UML图类名应该是斜体表示，但是不会用StarUML，不会用斜体来表示abstract类；

问题3解决方法：最后只好在普通类类名前加一个abstract来表示这是abstract类（后续改进）；

问题4：在做UML图时，画Long类UML图时，写类名为Long说是"Name Confict"(名字矛顿冲突)，Integer类也一样；

问题4解决方法：改成了Long1，Integer1

三、实验感想

本次实验，若只是完成其实也并不难，但要真正的理解并在以后运用TDD方式编程，同时遵从OCP开放封闭原则和DIP依赖倒置原则等S.O.I.L.D这五大原则，并不是一件简单的事，以后要熟记这五大原则，写代码时时刻刻的想着怎么应用这五大原则。

步骤	耗时	百分比
需求分析	30min	8%
设计	30min	8%
代码实现	180min	48%
测试	120min	32%
分析总结	15min	4%