20165230 《Java程序设计》实验二（Java开发环境的熟悉）实验报告

Posted 2020-10-31 tiankunye

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

一、实验报告封面

课程：Java程序设计 班级：1652班 姓名：田坤烨 学号：20165230 成绩：

指导教师：娄嘉鹏 实验日期：2018年4月16日
实验时间：15:45 - 17:20

实验序号：实验二 实验名称：Java面向对象程序设计

实验内容：

1. 初步掌握单元测试和TDD
2. 理解并掌握面向对象三要素：封装、继承、多态
3. 初步掌握UML建模
4. 熟悉S.O.L.I.D原则
5. 了解设计模式

实验要求：

1. 没有Linux基础的同学建议先学习《Linux基础入门（新版）》《Vim编辑器》 课程；
2. 完成实验、撰写实验报告，注意实验报告重点是运行结果，遇到的问题(工具查找，安装，使用，程序的编辑，调试，运行等)、解决办法（空洞的方法如“查网络”、“问同学”、“看书”等一律得0分）以及分析（从中可以得到什么启示，有什么收获，教训等）；
3. 实验报告中统计自己的PSP(Personal Software Process)时间；
4. 严禁抄袭。

二、实验内容及步骤

（一）单元测试

(1) 三种代码

• 伪代码

如果成绩小于0，转成“错误”
如果成绩小于60，转成“不及格”
如果成绩在60与70之间，转成“及格”
如果成绩在70与80之间，转成“中等”
如果成绩在80与90之间，转成“良好”
如果成绩在90与100之间，转成“优秀”
如果成绩大于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 "错误";
    }
}

• 测试代码

import junit.framework.TestCase;
import org.junit.Test;
import static org.junit.Assert.*;
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 testException(){
        assertEquals("错误",MyUtil.percentage2fivegrade(-55));
        assertEquals("不及格",MyUtil.percentage2fivegrade(55));
    }
    @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));
    }
}

• 测试代码截图
  

（二）以TDD的方式研究学习StringBuffer

• 伪代码

测试charAt方法：字符串中指定索引处的字符与原序列是否匹配
测试capacity方法：StringBuffer的容器容量
测试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(){//StringBuffer的容器容量
        return buffer.capacity();
    }
    public int length(){//字符串长度
        return buffer.length();
    }
    public int indexOf(String buf) {//子字符串的第一个字母在母字符串的位置
        return buffer.indexOf(buf);
    }
}

• 测试代码

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

import static org.junit.Assert.*;
public class StringBufferDemoTest extends TestCase {
    StringBuffer string1 = new StringBuffer("tiankunye");//测试9个字符
    StringBuffer string2 = new StringBuffer("tiankunye is learning");//测试21个字符
    StringBuffer string3 = new StringBuffer("tiankunye is learning java");//测试26个字符
    @Test
    public void testCharAt(){//测试字符串中指定索引处的字符与原序列是否匹配
        assertEquals(\'t\',string1.charAt(0));
        assertEquals(\'k\',string2.charAt(4));
        assertEquals(\'y\',string3.charAt(7));
    }
    @Test
    public void testCapacity(){//测试StringBuffer的容器容量
        assertEquals(25,string1.capacity());
        assertEquals(37,string2.capacity());
        assertEquals(42,string3.capacity());
    }
    @Test
    public void testindexOf() {//测试子字符串的第一个字母在母字符串的位置
        assertEquals(4, string1.indexOf("kun"));
        assertEquals(10, string2.indexOf("is"));
        assertEquals(22, string3.indexOf("java"));
    }
    @Test
    public void testlength() {//测试字符串长度
        assertEquals(9, string1.length());
        assertEquals(21, string2.length());
        assertEquals(26, string3.length());
    }
}

• 测试代码截图
  

（三）体会OCP原则和DIP原则的应用

• 支持Byte类代码

import java.util.Objects;
abstract class Data {
    abstract public void DisplayValue();
}
class Integer extends Data {
    int value;
    Integer() {
        value=100;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
}
class Long extends Data {
    long value;
    Long() {
        value=(long)20165230;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
}
class Byte extends Data {//Byte继承Data类
    byte value;
    Byte() {
        value=(byte)20165230;
    }
    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 LongFactory extends Factory {
    public Data CreateDataObject(){
        return new Long();
    }
}
class ByteFactory extends Factory {//ByteFactory继承工厂类
    public Data CreateDataObject(){
        return new Byte();
    }
}
//Client classes
class Document {
    Data data;
    Document(Factory factory){
        data = factory.CreateDataObject();
    }
    public void DisplayData(){
        data.DisplayValue();

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

• 代码运行截图
  

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

• 伪代码

（1）属性：复数包含实部和虚部两个部分，
double RealPart;复数的实部
double ImagePart;复数的虚部
getRealPart():返回复数的实部
getImagePart();返回复数的虚部
setRealPart():设置复数的实部
setImagePart();设置复数的虚部
输出形式：a+bi
（2）方法：
①定义构造函数
public Complex()
public Complex(double R,double I)
②定义公有方法:加减乘除
Complex ComplexAdd(Complex a):实现复数加法
Complex ComplexSub(Complex a):实现复数减法
Complex ComplexMulti(Complex a):实现复数乘法
Complex ComplexDiv(Complex a):实现复数除法
③Override Object
public String toString():将计算结果转化为字符串形式并输出

• 产品代码

public class Complex {
    // 定义属性并生成getter,setter
    private double RealPart;
    private double ImagePart;
    // 定义构造函数
    public Complex(){

    }
    public Complex(double R, double I){
        this.RealPart = R;
        this.ImagePart = I;
    }

    public double getRealPart() {
        return RealPart;
    }

    public void setRealPart(double realPart) {
        RealPart = realPart;
    }

    public double getImagePart() {
        return ImagePart;
    }

    public void setImagePart(double imagePart) {
        ImagePart = imagePart;
    }

    //Override Object
    public boolean equals(Object obj){
        if(this == obj) {
            return true;
        }
        if(!(obj instanceof Complex)) {
            return false;
        }
        Complex complex = (Complex) obj;
        if(complex.RealPart != ((Complex) obj).RealPart) {
            return false;
        }
        if(complex.ImagePart != ((Complex) obj).ImagePart) {
            return false;
        }

        return true;
    }
    public String toString()   {
        String string = "";
        if (ImagePart > 0)
            string =  RealPart + "+" + ImagePart + "i";
        if (ImagePart == 0)
            string =  RealPart + "";
        if (ImagePart < 0)
            string = RealPart + " " + ImagePart + "i";
        return string;
    }

    // 定义公有方法:加减乘除
    Complex ComplexAdd(Complex a) {
        return  new Complex(RealPart+a.RealPart,ImagePart+a.ImagePart);
    }
    Complex ComplexSub(Complex a) {
        return new Complex(RealPart-a.RealPart,ImagePart-a.ImagePart);
    }
    Complex ComplexMulti(Complex a) {
        return new Complex(RealPart*a.RealPart-ImagePart*a.ImagePart,ImagePart*a.RealPart+RealPart*a.ImagePart);
    }
    Complex  ComplexDiv(Complex a) {
        Complex d = new Complex();
        d.RealPart = (this.RealPart * a.RealPart + this.ImagePart * a.ImagePart)/(a.RealPart*a.RealPart+a.ImagePart*a.ImagePart);
        d.ImagePart = (this.ImagePart * a.RealPart - this.RealPart * a.ImagePart)/(a.RealPart*a.RealPart+a.ImagePart*a.ImagePart);
        return d;
    }

}

• 测试代码

import static org.junit.Assert.*;
import org.junit.Test;
import junit.framework.TestCase;
public class ComplexTest extends TestCase {
    Complex complex = new Complex(1,1);
    @Test
    public void testAdd(){
        assertEquals(new Complex(2.0,1.6), complex.ComplexAdd(new Complex(5.2,3.0)));
    }
    //测试加法
    @Test
    public void testSub(){
        assertEquals(new Complex(-2.0,-1.6), complex.ComplexSub(new Complex(5.2,3.0)));
    }
    //测试减法
    @Test
    public void testMulti(){
        assertEquals(new Complex(3.0,2.0), complex.ComplexMulti(new Complex(3.0,2.0)));
    }
    //测试乘法
    @Test
    public void testDiv(){
        assertEquals(new Complex(1.0,1.0), complex.ComplexDiv(new Complex(1.0,1.0)));
        assertEquals(new Complex(0.0,0.0), complex.ComplexDiv(new Complex(1.0,0.0)));
        //assertEquals(new Complex(0.0,0.0), complex.ComplexDiv(new Complex(3,4)));
        //边缘测试
    }
    @Test
    public void testequals(){
        assertEquals(true, complex.equals(new Complex(1.0,1.0)));
    }
    //测试判断相等
}

• 测试代码截图
  

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

三、实验遇到的问题

• 问题1：查询不到junit,如何导入Junit
  

• 问题1解决方案:通过学习学长学姐的博客，找到了解决方法，步骤如下：

1. 打开File中的Project Structure
2. 点击Dependencies,单击右上角的+,然后选择第一个JARs...
3. 找到下载IDEA的路径，在lib文件夹中找到junit-4.12.jar和junit,jar文件，点击ok
4. 选中这两个包然后点击ok

• 问题2：Stringbuffer类的capcity()方法是什么意思？
• 问题2解决方案：通过查询API学习到是返回当前容量
  

接着学习了狄维佳学姐的博客，了解到

如果小于16则默认容器的大小为16。如果大于16则会调用expandCapacity 函数进行容量的扩展。所以第一次append时，小于16则不需扩展，如果大于16则会直接扩展到34（162+2），比较得到大于append后的长度的话则用34，如果不 是则用append后的长度。此时capacity的大小等于append后的长度，如果在append的话，若不超过70（342+2）的话，此时则capacity为70，如果超过70则继续用第二次append后的总长度。

• 问题3：如何实现复数的除法？
• 解决方案：首先通过上网查询学习到除法的运算法则

(a+bi)/(c+di)=(ac+bd)/(c^2 + d^2) +((bc-ad)/(c^2 + d^2))i

接着通过代码中对abcd的定义套入公式便实现了复数的除法。

四、实验心得

• 单元测试的好处

1. 单元测试可最大限度的减少bug
2. 可快速定位bug，减少调试时间
3. 可突破构思瓶颈
4. 提高代码质量

• 在这次实验中学习到了如何进行Junit测试，并初步掌握了面向对象编程的过程，同时了解了TDD方式，OCP、DIP原则和SOLID原则，知道了模式的重要作用和设计模式在Java中的重要地位。通过对老师给出的例子进行学习扩充，运用了举一反三的学习方法，对编程有了进一步的认识和熟悉

五、PSP时间

步骤	耗时	百分比

   |需求分析           |   40min           | 9%            |       
       |  设计         | 65min            |     16%   |
| 代码实现          |   120min          | 29%             |       
|测试          |   60min          | 15%            |  
  |分析总结          |   120min          | 29%            |  

六、参考资料

• 实验二 Java面向对象程序设计
• 实验二《Java面向对象程序设计》的一点说明
• Intellj IDEA 简易教程
• 积极主动敲代码，使用JUnit学习Java