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

一、实验报告封面

课程：Java程序设计班级：1652班

姓名：韩啸学号：20165206

指导教师：娄嘉鹏实验日期：2018年4月16日

实验时间：15:35 - 17:15 实验序号：二

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

二、实验内容

- 面向对象程序设计-1

实验要求：

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

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

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

实验过程：

当我们想用程序解决问题时，要写三种码：

伪代码
产品代码
测试代码

用一个例子来表示：需求：我们要在一个MyUtil类中解决一个百分制成绩转成“优、良、中、及格、不及格”五级制成绩的功能。

伪代码与具体编程语言无关，可以用汉语或是英语来写，它是用来帮我们理清思路的。

上述问题的伪代码就可以这样来写：

百分制转五分制：

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

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

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

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

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

其他，转成“错误”

然后将伪代码用编程语言翻译一下就得到产品代码：

public class MyUtil{

   public static String percentage2fivegrade(int grade){

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

       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 "优秀";

       //其他，转成“错误”

       else

           return "错误";

   }

}

这得到的只是初步的产品代码，因为要保证正确性，我们要不断修改产品代码。而这时就要利用测试代码来进行测试。通过不断的测试，得到最终的产品代码：

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

1、实验要求：

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

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

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

2、实验过程：

老师给的StringBuffer例子代码：

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()、indexOf()和length()。

因此测试代码为：

import junit.framework.TestCase;

import org.testng.annotations.Test;

public class StringBufferDemoTest extends TestCase {

StringBuffer a= new StringBuffer("String");

StringBuffer b = new StringBuffer("StringBuffer");

@Test

public void testcharAt() throws Exception{

    assertEquals('S',a.charAt(0));

    assertEquals('g',a.charAt(5));

}

@Test

public void testcapacity() throws Exception{

    assertEquals(22,a.capacity());

    assertEquals(28,b.capacity());

}

@Test

public void testlength() throws Exception{

    assertEquals(6,a.length());

    assertEquals(12,b.length());

}

@Test

public void testindexOf() throws Exception{

    assertEquals(0,a.indexOf("Str"));

    assertEquals(6,b.indexOf("Bu"));

}

}

测试的截图为：

- 面向对象程序设计-3

实验要求：

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

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

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

用自己的学号%6进行取余运算，根据结果进行代码扩充：

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

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

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

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

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

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

实验过程:

OCP原则是OOD中最重要的一个原则，OCP原则的内容是：

软件实体（类，模块，函数等）应该对扩充开放，对修改封闭。

对扩充开放（Open For Extension ）要求软件模块的行为必须是可以扩充的，在应用需求改变或需要满足新的应用需求时，我们要让模块以不同的方式工作；

对修改封闭（Closed for Modification ）要求模块的源代码是不可改动的，任何人都不许修改已有模块的源代码。

基于OCP，利用面向对象中的多态性（Polymorphic），更灵活地处理变更拥抱变化，OCP可以用以下手段实现：（1）抽象和继承，（2）面向接口编程。

DIP原则的内容是：

高层模块不应该依赖于低层模块。二者都应该依赖于抽象；

抽象不应该依赖于细节。细节应该依赖于抽象；

通过接口或者抽象类，DIP在应用中通过依赖注入的方式实现解耦，重用低级模块，重用实现，解除依赖。

我的是让系统支持Byte类，我不是特别明白怎么进行设计，我是根据支持Float类以及其UML类图进行仿照编写的。

测试代码：

// 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 Byte extends  Data {

    byte value;

    Byte() {

        value=1;

    }

    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 ByteFactory extends Factory {

    public Data CreateDataObject(){

        return new Byte();

    }

}

//Client classes

class Document {

    Data pd;

    Document(Factory pf){

        pd = pf.CreateDataObject();

    }

    public void DisplayData(){

        pd.DisplayValue();

    }

}

//Test class

public class MyDoc {

    static Document d;

    public static void main(String[] args) {

        d = new Document(new ByteFactory());

        d.DisplayData();

    }

}

运行截图：

- 面向对象程序设计-4

实验要求：

提交：单元测试代码和运行成功截图及码云上代码链接，截图要加上学号水印

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

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

实验过程：

产品代码：

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 a) {

        return new Complex(r + a.r, i + a.i);

    }

    public Complex ComplexSub(Complex a) {

        return new Complex(r - a.r, i - a.i);

    }

    public Complex ComplexMulti(Complex a) {

        return new Complex(r * a.r - i * a.i, r * a.i + i * a.r);

    }

    public Complex ComplexDiv(Complex a) {

        return new Complex((r * a.i + i * a.r)/(a.i * a.i + a.r * a.r), (i * a.i + r * a.r)/(a.i * a.i + a.r * a.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;

    }

}

测试代码：

import junit.framework.TestCase;

import org.junit.Test;

public class ComplexTest extends TestCase {

    Complex c1 = new Complex(1, 2);

    Complex c2 = new Complex(2, 2);

    Complex c3 = new Complex(2,0);

    @Test

    public void testgetRealPart() throws Exception {

        assertEquals(-1.1, Complex.getRealPart(-1.1));

        assertEquals(6.0, Complex.getRealPart(6.0));

        assertEquals(0.0, Complex.getRealPart(0.0));

    }

    @Test

    public void testgetImagePart() throws Exception {

        assertEquals(-1.1, Complex.getImagePart(-1.1));

        assertEquals(6.0, Complex.getImagePart(6.0));

        assertEquals(0.0, Complex.getImagePart(0.0));

    }

    @Test

    public void testComplexAdd() throws Exception {

        assertEquals("3.0+4.0i", c1.ComplexAdd(c2).toString());

        assertEquals("3.0+2.0i", c1.ComplexAdd(c3).toString());

        assertEquals("4.0+2.0i", c2.ComplexAdd(c3).toString());

    }

    @Test

    public void testComplexSub() throws Exception {

        assertEquals("-1.0", c1.ComplexSub(c2).toString());

        assertEquals("-1.0+2.0i", c1.ComplexSub(c3).toString());

        assertEquals("0.0+2.0i", c2.ComplexSub(c3).toString());

    }

    @Test

    public void testComplexMulti() throws Exception {

        assertEquals("-2.0+6.0i", c1.ComplexMulti(c2).toString());

        assertEquals("2.0+4.0i", c1.ComplexMulti(c3).toString());

        assertEquals("4.0+4.0i", c2.ComplexMulti(c3).toString());

    }

    @Test

    public void testComplexComplexDiv() throws Exception {

        assertEquals("0.75+0.75i", c1.ComplexDiv(c2).toString());

        assertEquals("1.0+0.5i", c1.ComplexDiv(c3).toString());

        assertEquals("1.0+1.0i", c2.ComplexDiv(c3).toString());

    }

}

运行截图：

代码链接

- 面向对象程序设计-5

1、实验要求：

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

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

类图中只少两个类。

2、实验过程：

三、实验中遇到的问题

问题一：在单元测试中，@Test是红色的。
问题一解决方案：这是因为没有导入相应的包，根据老师的教程，然后我又查阅了一些资料，找到了解决方案。要按照相同的方法，导入两个Junit的包。
问题二：在配置好@Test之后，我在运行单元测试时出现了这样的错误提示。
问题二解决方案：这是因为没有安装Groovy SDK没有安装导致的。在百度搜索，下载安装并且配置环境变量就可以了。

四、实验感悟

这次实验内容很多，有单元测试、TDD、UML等许多知识的结合。学习的时间很长，就算一直跟着老师的教程走，不断的查阅资料，也依然有许多不理解的东西，以后还是要慢慢学。不过还是有许多收获的，许多东西以后也都能用到。

步骤	耗时	百分比
需求分析	15	10%
设计	15	10%
代码实现	50	40%
测试	40	30%
分析总结	10	10%