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

zoukankan html css js c++ java

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

一、实验报告封面

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

姓名：韩啸学号：20165206

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

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

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

二、实验内容

- 面向对象程序设计-1
1. 实验要求：
  参考 http://www.cnblogs.com/rocedu/p/6371315.html#SECUNITTEST
  参考http://www.cnblogs.com/rocedu/p/6736847.html
提交最后三个测试用例都通过的截图，截图上要有画图加水印，输入自己的学号。
1. 实验过程：
  当我们想用程序解决问题时，要写三种码：
- 伪代码
- 产品代码
- 测试代码
用一个例子来表示：需求：我们要在一个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
1. 实验要求：
  实验二 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类中添加测试代码表明添加正确，提交测试代码和运行结的截图，加上学号水印
1. 实验过程:
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
1. 实验要求：
  提交：单元测试代码和运行成功截图及码云上代码链接，截图要加上学号水印
参考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)
1. 实验过程：
  产品代码：
```
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%
查看全文

相关阅读:
selenium 在爬虫中的应用
 基于scrapy-redis的第二种形式的分布式爬虫（把普通scrapy框架转成分布式）
django html 模板继承（下）加精
 django页面之间的前端模板继承或者引入详解（上）
inclusion_tag 重复页面加载显示模板
 django ForeignKey ManyToManyField OneToOneField
django建站的注意点
 任务19
数列求和
 鸡兔同笼2