2018-2019-2 20175310 实验二《Java面向对象程序设计》实验报告

2018-2019-2 20175310 实验二《Java面向对象程序设计》实验报告

一、实验步骤及内容

（一）、面向对象程序设计-1

参考 http://www.cnblogs.com/rocedu/p/6371315.html#SECUNITTEST

参考http://www.cnblogs.com/rocedu/p/6736847.html

提交最后三个测试用例都通过的截图，截图上要有画图加水印，输入自己的学号。

1、在IDEA中安装JUnit插件，选择File->Setting打开设置对话框：

2、在设置对话框中选择Plugins, 单击Installed ，在插件安装对话框的搜索中输入junit,单击JunitGenerator V2.0,单击右边绿色的Install按钮安装：

3、我们在IDEA中新建一个项目，然后新建一个类MyUtil，我们要在一个MyUtil类中解决一个百分制成绩转成“优、良、中、及格、不及格”五级制成绩的功能。

针对上面的问题，我们可以通过伪代码这样解决：

百分制转五分制：
如果成绩小于60，转成“不及格”
如果成绩在60与70之间，转成“及格”
如果成绩在70与80之间，转成“中等”
如果成绩在80与90之间，转成“良好”
如果成绩在90与100之间，转成“优秀”
其他，转成“错误”

4、有了伪代码，我们用特定编程语言翻译一下，就是可用的产品代码了，产品代码如下：

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

5、在 IDEA中我们把产品代码放在src目录中，把测试代码放在test目录中，右键单击项目，在弹出的菜单中选择New->Directory新建一个目录：

6、输入目录名test:

7、设置SOURCEPATH环境变量，右键单击test目录，在弹出的菜单中选择Mark Directory as->Test Sources Root：

8、鼠标单击类名会出现一个灯泡状图标，单击图标或按Alt + Entert,在弹出的菜单中选择Create Test:

9、选择创建JUnit3的测试用例 ：

9、测试代码如下：

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

}

10、测试代码及结果如下图：

（二）、面向对象程序设计-2

参考 积极主动敲代码，使用JUnit学习Java （http://www.cnblogs.com/rocedu/p/4837092.html)

参考http://www.cnblogs.com/rocedu/p/6736847.html

以 TDD的方式研究学习StringBuffer，提交你的单元测试用例和测试通过的截图，截图要加上学号水印。

1、产品代码：

public class StringBufferDemo{
    StringBuffer str=new StringBuffer();
    StringBufferDemo(StringBuffer str){
        this.str=str;
    }
    public char charAt(int i){
        return str.charAt(i);
    }
    public int capacity(){
        return str.capacity();
    }
    public int length(){
        return str.length();
    }
    public int indexOf(String buf) {
        return str.indexOf(buf);
    }
}

2、测试代码：

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

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(){
        assertEquals('S',a.charAt(0));
        assertEquals('B',a.charAt(6));
        assertEquals('r',a.charAt(11));
    }
    @Test
    public void testcapacity(){
        assertEquals(28,a.capacity());
        assertEquals(40,b.capacity());
        assertEquals(52,c.capacity());
    }
    @Test
    public void testlength(){
        assertEquals(12,a.length());
        assertEquals(24,b.length());
        assertEquals(36,c.length());
    }
    @Test
    public void testindexOf(){
        assertEquals(0,a.indexOf("Str"));
        assertEquals(6,a.indexOf("Buff"));
        assertEquals(10,a.indexOf("er"));
    }
}

3、测试结果截图：

（三）、面向对象程序设计-3

实验二 Java面向对象程序设计(http://www.cnblogs.com/rocedu/p/4472842.html)

参考http://www.cnblogs.com/rocedu/p/6736847.html

对设计模式示例进行扩充，体会OCP原则和DIP原则的应用，初步理解设计模式

让系统支持Float类，并在MyDoc类中添加测试代码表明添加正确，提交测试代码和运行结的截图，加上学号水印

1、产品代码：

// Server Classes
abstract class Data {
    abstract public void DisplayValue();
}
class Integer extends  Data {
    int value;
    Integer() {
         value=100;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
 }
class Float extends  Data {
    float value;
    Float() {
        value=1.23456F;
    }
    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 FloatFactory extends Factory {
    public Data CreateDataObject(){
        return new Float();
    }
}
class Document {    //Client classes
    Data pd;
    Document(Factory pf){
       pd = pf.CreateDataObject();
    }
    public void DisplayData(){
       pd.DisplayValue();
   }
 }
 //Test class
 public class MyDoc {
    static Document d,f;
    public static void main(String[] args) {
            d = new Document(new IntFactory());
            d.DisplayData();
            f = new Document(new FloatFactory());
            f.DisplayData();
    }
}

2、运行结果截图：

（四）、面向对象程序设计-4

任务：以TDD的方式开发一个复数类Complex，要求如下:

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

//Override Object
public boolean equals(Object obj)
public String toString()

// 定义公有方法:加减乘除
Complex ComplexAdd(Complex a)
Complex ComplexSub(Complex a)
Complex ComplexMulti(Complex a)
Complex ComplexDiv(Complex a)

1、产品代码：

Complex.java

public class Complex {
    // 定义属性并生成getter,setter
    double RealPart;
    double ImagePart;
    void setRealPart(double r){
        RealPart=r;
    }
    void setImagePart(double i){
        ImagePart=i;
    }
    double getRealPart(Complex a){
        return a.RealPart;
    }
    double getImagePart(Complex a){
        return a.ImagePart;
    }
    // 定义构造函数
    public Complex(double r,double i){
        RealPart=r;
        ImagePart=i;
    }

    //Override Object

    public String toString(){
        String result = new String();
        if (ImagePart>0)
            result = RealPart+"+"+ImagePart+"i";
        if (ImagePart==0)
            result = RealPart+"";
        if (ImagePart<0)
            result = RealPart+"-"+ImagePart*(-1)+"i";
        return result;
    }

    public Complex ComplexAdd(Complex a){
        return new Complex(RealPart+a.RealPart,ImagePart+a.ImagePart);
    }

    public Complex ComplexSub(Complex a){
        return new Complex(RealPart-a.RealPart,ImagePart-a.ImagePart);
    }

    public Complex ComplexMulti(Complex a){
        return new Complex(RealPart*a.RealPart-ImagePart*a.ImagePart,RealPart*a.ImagePart+ImagePart*a.RealPart);
    }

    public Complex ComplexDiv(Complex a){
        double d = Math.sqrt(a.RealPart * a.RealPart) + Math.sqrt(a.ImagePart * a.ImagePart);
        return new Complex((RealPart*a.RealPart+ImagePart*a.ImagePart)/d,(ImagePart*a.RealPart-RealPart*a.ImagePart)/d);
    }
}

ComplexDemo.java

public class ComplexDemo {
    public static void main(String[] a) {
    Complex b = new Complex(2, 6);
    Complex c = new Complex(1, -3);
    System.out.println("("+b + ")+(" + c + ")=" + b.ComplexAdd(c));
    System.out.println("("+b + ")-(" + c + ")=" + b.ComplexSub(c));
    System.out.println("("+b + ")*(" + c + ")=" + b.ComplexMulti(c));
    System.out.println("("+b + ")/(" + c + ")=" + b.ComplexDiv(c));
    }
}

2、测试代码：

import junit.framework.TestCase;
import org.junit.Test;
public class ComplexTest extends TestCase {
    Complex b = new Complex(2,6);
    Complex c = new Complex(1,-3);
    @Test
    public void testComplexAdd(){
        assertEquals("3.0+3.0i",b.ComplexAdd(c)+"");
    }
    @Test
    public void testComplexSub(){
        assertEquals("1.0+9.0i",b.ComplexSub(c)+"");
    }
    @Test
    public void testComplexMulti(){
        assertEquals("20.0",b.ComplexMulti(c)+"");
    }
    @Test
    public void testComplexDiv(){
        assertEquals("-4.0+3.0i",b.ComplexDiv(c)+"");
    }
}

3、测试结果截图：

（五）、面向对象程序设计-5

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

参考http://www.cnblogs.com/rocedu/p/6736847.html

二、实验过程中遇到的问题及其解决

• 问题1：
  
  在做第四个实验的时候，当复数的虚部为负时，表达式显示错误：
  
  

• 问题1解决方案：
  
  首先用（）把两个复数隔开，更加清晰
  
  
  
  然后判断虚部的正负，当虚部为负时，将ImagePart*（-1）作为一个整体输出。
  
  

• 问题2：
  
  测试代码时，提示不正确
  
  

• 问题2解决方案：
  
  可以看到提示说，希望得到的和实际得到的，看起来是一样的，但是编译不通过，所以应该是类型不同。
  
  将计算结果最后加上“”，将结果转换成字符串类型，就可以编译通过了。
  
  

三、码云链接

四、参考代码

Intellj IDEA 简易教程

实验二《Java面向对象程序设计》的一点说明

积极主动敲代码，使用JUnit学习Java

实验二 Java面向对象程序设计

五、PSP时间

步骤	耗时（min）	百分比
需求分析	30	13%
设计	40	17%
代码实现	90	39%
测试	30	13%
分析总结	40	17%