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

一、实验内容及步骤

1.初步掌握单元测试和TDD

  • 单元测试

任务一:三种代码

用程序解决问题时,要学会写以下三种代码:

  • 伪代码
  • 产品代码
  • 测试代码

TDD(测试驱动开发):

  • 伪代码(思路)
  • 测试代码(产品预期功能)
  • 产品代码(实现预期功能)

TDD的一般步骤如下:

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

基于TDD,可以有效避免过度开发的现象,因为我们只需要让测试通过即可。

测试类的创建:

  • 将鼠标放在主类类名上,点击出现的黄色小灯泡,在下拉选项中选择Create Test

  • 随后在Testing Library中的下拉选项中选择Junit 3,点击OK便可创建Test
  • 注意:不要忘记@Test的书写

举例:我们要在一个MyUtil类中解决一个百分制成绩转成“优、良、中、及格、不及格”五级制成绩的功能。

测试结果:

任务二:TDD(Test Driven Devlopment, 测试驱动开发)

老师在教程里给出的程序如下:

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(int i):返回此序列中指定索引处的 char 值。第一个 char 值在索引 0 处,第二个在索引 1 处,依此类推,这类似于数组索引
  • capacity():返回当前容量。容量指可用于最新插入的字符的存储量,超过这一容量就需要再次进行分配
  • length():返回子浮窗的长度
  • indexOf(String s):返回输入的子字符串的第一个字母在母字符串的位置
  • toString(String s):返回此对象本身(它已经是一个字符串)

在产品代码里,我们需要为这五个方法加上返回值,并与我们的断言进行比较。产品代码如下:

public class StringBufferDemo {
StringBuffer buffer; public static char CharAt(StringBuffer buffer, int index) {
return buffer.charAt(index);
} public static int Capacity(StringBuffer buffer) {
return buffer.capacity();
} public static int IndexOf(StringBuffer buffer, String str) {
return buffer.indexOf(str);
} public static String ToString(StringBuffer buffer) {
return "buffer = " + buffer.toString();
} public static int Length(StringBuffer buffer) {
return buffer.length();
}
}

根据上述该产品代码,写出对应的测试类,在测试类中我分别都使使用了3个例子来进行测试,如果出现问题,JUnit会出现红条,IDEA会提示哪一个测试用例出现问题,由此可以对应改正产品代码中的问题,直到JUnit出现绿条,任务完成。

测试代码如下:

import junit.framework.TestCase;
import org.junit.*; public class StringBufferDemoTest extends TestCase {
StringBuffer buffer1 = new StringBuffer("iamastudent");
StringBuffer buffer2 = new StringBuffer("youareastudent");
StringBuffer buffer3 = new StringBuffer("heisateacher"); @Test
public void testCharAt() {
assertEquals('i', StringBufferDemo.CharAt(buffer1, 0));
assertEquals('o', StringBufferDemo.CharAt(buffer2, 1));
assertEquals('r', StringBufferDemo.CharAt(buffer3, 11));
} @Test
public void testCapital() {
assertEquals(27, StringBufferDemo.Capacity(buffer1));
assertEquals(30, StringBufferDemo.Capacity(buffer2));
assertEquals(28, StringBufferDemo.Capacity(buffer3));
} @Test
public void testLenght() throws Exception {
assertEquals(11, StringBufferDemo.Length(buffer1));
assertEquals(14, StringBufferDemo.Length(buffer2));
assertEquals(12, StringBufferDemo.Length(buffer3));
} @Test
public void testIndexOf() {
assertEquals(0, StringBufferDemo.IndexOf(buffer1, "iam"));
assertEquals(-1, StringBufferDemo.IndexOf(buffer2, "You"));
assertEquals(11, StringBufferDemo.IndexOf(buffer3, "r"));
} @Test
public void testToString() {
assertEquals("buffer = iamastudent", StringBufferDemo.ToString(buffer1));
assertEquals("buffer = youareastudent", StringBufferDemo.ToString(buffer2));
assertEquals("buffer = heisateacher", StringBufferDemo.ToString(buffer3));
}
}

截图如下:

2.面向对象三要素:封装、继承、多态

面向对象(Object-Oriented)的三要素包括:封装、继承、多态。面向对象的思想涉及到软件开发的各个方面,如面向对象分析(OOA)、面向对象设计(OOD)、面向对象编程实现(OOP)。OOA根据抽象关键的问题域来分解系统,关注是什么(what)。OOD是一种提供符号设计系统的面向对象的实现过程,用非常接近问题域术语的方法把系统构造成“现实世界”的对象,关注怎么做(how),通过模型来实现功能规范。OOP则在设计的基础上用编程语言(如Java)编码。贯穿OOA、OOD和OOP的主线正是抽象。

OOD中建模会用图形化的建模语言UML(Unified Modeling Language),UML是一种通用的建模语言。

过程抽象的结果是函数,数据抽象的结果是抽象数据类型(Abstract Data Type,ADT),类可以作具有继承和多态机制的ADT。数据抽象才是OOP的核心和起源。

OO三要素的第一个要素是封装,封装就是将数据与相关行为包装在一起以实现信息就隐藏,Java中用类进行封装。

封装实际上使用方法(method)将类的数据隐藏起来,控制用户对类的修改和访问数据的程度,从而带来模块化(Modularity)和信息隐藏(Information hiding)的好处;接口(interface)是封装的准确描述手段。

任务三:使用StarUML对实验二中的代码进行建模

  • 点开StarUML程序后,在右下角的选项中选择Class选项建立一个类的UML图

  • 按照下图中提示分别创建对应的变量层和方法层

  • 在右下角选项中选择Generalization选项,创建类与类之间的调用关系

最终结果截图:

  • 较为简单:

  • 较为复杂:

3.设计模式

面向对象三要素是“封装、继承、多态”,任何面向对象编程语言都会在语法上支持这三要素。如何借助抽象思维用好三要素特别是多态还是非常困难的,S.O.L.I.D类设计原则是一个很好的指导:

  • SRP(Single Responsibility Principle,单一职责原则)
  • OCP(Open-Closed Principle,开放-封闭原则)
  • LSP(Liskov Substitusion Principle,Liskov替换原则)
  • ISP(Interface Segregation - Principle,接口分离原则)
  • DIP(Dependency Inversion Principle,依赖倒置原则)

任务四:对MyDoc类进行扩充,让其支持Long类,初步理解设计模式

OCP是OOD中最重要的一个原则,OCP的内容是:

软件实体(类,模块,函数等)应该对扩充开放,对修改封闭。

OCP可以用以下手段实现:

  • 抽象和继承
  • 面向接口编程

老师给出的以Int型为例的代码如下:

abstract class Data{
public abstract void DisplayValue();
}
class Integer extends Data {
int value;
Integer(){
value=100;
}
public void DisplayValue(){
System.out.println(value);
}
}
class Document {
Data pd;
Document() {
pd=new Integer();
}
public void DisplayData(){
pd.DisplayValue();
}
}
public class MyDoc {
static Document d;
public static void main(String[] args) {
d = new Document();
d.DisplayData();
}
}

在上述代码的基础上,要求系统支持Long类,这是一个合理的要求,要支持Long类,Document类要修改两个地方,这违反了OCP原则,使用多态可以解决部分问题:

产品代码:

// 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 Long extends Data {
long value; Long() {
value = 111111111;
} 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();
}
} //Client classes
class Document {
Data pd; Document(Factory pf) {
pd = pf.CreateDataObject();
} public void DisplayData() {
pd.DisplayValue();
}
} //Test class
public class MyDoc {
static Document d1, d2; public static void main(String[] args) {
d1 = new Document(new IntFactory());
d2 = new Document(new LongFactory());
d1.DisplayData();
d2.DisplayData();
}
}

运行结果截图:

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)
  • 产品代码
public class Complex {
// 定义属性并生成getter,setter
private double RealPart;
private double ImagePart; public double getterRealPart() {
return this.RealPart;
} public double getterImagePart() {
return this.ImagePart;
} public static double getterRealPart(double RealPart) {
return RealPart;
} public static double getterImagePart(double ImagePart) {
return ImagePart;
} public void setterRealPart(double RealPart) {
this.RealPart = RealPart;
} public void setterImagePart(double ImagePart) {
this.ImagePart = ImagePart;
} // 定义构造函数
public Complex() {
this.RealPart = 0;
this.ImagePart = 0;
} public Complex(double R, double I) {
this.RealPart = R;
this.ImagePart = I;
} //Override Object
public boolean equals(Object obj) {
Complex complex = (Complex) obj;
if (this == obj) {
return true;
} else if (!(obj instanceof Complex)) {
return false;
} else if (getterRealPart() != complex.getterRealPart()) {
return false;
} else if (getterImagePart() != complex.getterImagePart()) {
return false;
} else
return true;
} public String toString() {
if (getterRealPart() == 0)
return getterImagePart() + "i";
else if (getterImagePart() == 0)
return getterRealPart() + "";
else if (getterImagePart() < 0)
return getterRealPart() + "" + getterImagePart() + "i";
else
return getterRealPart() + "+" + getterImagePart() + "i";
} // 定义公有方法:加减乘除
Complex ComplexAdd(Complex a) {
return new Complex(this.getterRealPart() + a.getterRealPart(), getterImagePart() + a.getterImagePart());
} Complex ComplexSub(Complex a) {
return new Complex(this.getterRealPart() - a.getterRealPart(), getterImagePart() - a.getterImagePart());
} Complex ComplexMulti(Complex a) {
return new Complex(this.getterRealPart() * a.getterRealPart() - a.getterImagePart() * this.getterImagePart(), a.getterImagePart() * this.getterRealPart() + a.getterRealPart() * this.getterImagePart());
} Complex ComplexDiv(Complex a) {
Complex c = new Complex();
if (a.equals(c)) {
System.out.println("错误,分母不能为零!");
}
return new Complex(this.getterRealPart() / a.getterRealPart(), this.getterImagePart() / a.getterImagePart());
}
}
  • 测试代码
import junit.framework.TestCase;
import org.junit.Test; public class ComplexTest extends TestCase {
Complex complex1 = new Complex(3, 4);
Complex complex2 = new Complex(1, -2);
Complex complex3 = new Complex(1, 1); @Test
public void testgetterRealPart() throws Exception {
assertEquals(3.0, Complex.getterRealPart(3.0));
assertEquals(1.0, Complex.getterRealPart(1.0));
assertEquals(-2.0, Complex.getterRealPart(-2.0));
} @Test
public void testgetterImagePart() throws Exception {
assertEquals(4.0, Complex.getterImagePart(4.0));
assertEquals(-2.0, Complex.getterImagePart(-2.0));
assertEquals(0.0, Complex.getterImagePart(0.0));
} @Test
public void testAdd() throws Exception {
assertEquals("4.0+2.0i", complex1.ComplexAdd(complex2).toString());
assertEquals("4.0+5.0i", complex1.ComplexAdd(complex3).toString());
assertEquals("2.0-1.0i", complex2.ComplexAdd(complex3).toString());
} @Test
public void testSub() throws Exception {
assertEquals("2.0+6.0i", complex1.ComplexSub(complex2).toString());
assertEquals("2.0+3.0i", complex1.ComplexSub(complex3).toString());
assertEquals("-3.0i", complex2.ComplexSub(complex3).toString());
} @Test
public void testMulti() throws Exception {
assertEquals("11.0-2.0i", complex1.ComplexMulti(complex2).toString());
assertEquals("-1.0+7.0i", complex1.ComplexMulti(complex3).toString());
assertEquals("3.0-1.0i", complex2.ComplexMulti(complex3).toString());
} @Test
public void testDiv() throws Exception {
assertEquals("3.0-2.0i", complex1.ComplexDiv(complex2).toString());
assertEquals("3.0+4.0i", complex1.ComplexDiv(complex3).toString());
assertEquals("1.0-2.0i", complex2.ComplexDiv(complex3).toString());
}
}

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

  • 一开始以为Test类是自己手动在Test目录下创建,导致结果不会出现测试条

解决过程:

1.将鼠标放在主类类名上,点击出现的黄色小灯泡,在下拉选项中选择Create Test

2.随后在Testing Library中的下拉选项中选择Junit 3,点击OK便可创建Test

3.注意:不要忘记@Test的书写

  • 在书写测试类时,StringBuffer()中的capacity()方法总是出错

解决方法:

参考capacity()的用法可知,StringBuffer在内部维护一个字符数组,当你使用缺省的构造函数来创建StringBuffer对象的时候, StringBuffer的容量被初始化为16个字符,也就是说缺省容量就是16个字符。当StringBuffer达到最大容 量的时候,它会将自身容量增加到当前的2倍再加2,也就是(2*旧值+2)。

也就是说,对于空字符串,调用capacity()方法初始分配值为16;大小超过16时则扩充容量为34,再次扩充得到70。

三、实验体会与总结

我通过本次实验学会了如何编写测试代码、如何绘画UML图以及在TDD模式下编写代码。

在自己上手实践操作过程中,加深了对平时不清楚的知识点的理解,也掌握了的Junit的用法。在使用测试代码的时候,既可以测试到代码是否正确,又规范了编程习惯,单元测试提供了一种高效快速的测试代码正确性的方法。

四、PSP(Personal Software Process)时间

步骤 耗时 百分比
步骤 耗时 百分比
需求分析 20min 12%
设计 30min 18%
代码实现 50min 30%
测试 30min 18%
分析总结 40min 22%

五、代码链接

https://gitee.com/BESTI-IS-JAVA-2018/ch1/tree/master/20165315exp2

2017-2018-2 20165315 实验二《Java面向对象程序设计》实验报告的更多相关文章

  1. 实验二Java面向对象程序设计实验报告(2)

    实验二 Java面向对象程序设计 实验概述: 课程:程序设计与数据结构 班级:1623班 姓名: 邢天岳 学号:2309 指导老师:娄老师 王老师 实验日期:2017.4.16 实验名称: Java面 ...

  2. 20145213《Java程序设计》实验二Java面向对象程序设计实验报告

    20145213<Java程序设计>实验二Java面向对象程序设计实验报告 实验内容 初步掌握单元测试和TDD 理解并掌握面向对象三要素:封装,继承,多态 初步掌握UML建模 熟悉S.O. ...

  3. 20145206《Java程序设计》实验二Java面向对象程序设计实验报告

    20145206<Java程序设计>实验二Java面向对象程序设计实验报告 实验内容 初步掌握单元测试和TDD 理解并掌握面向对象三要素:封装.继承.多态 初步掌握UML建模 熟悉S.O. ...

  4. 20145308刘昊阳 《Java程序设计》实验二 Java面向对象程序设计 实验报告

    20145308刘昊阳 <Java程序设计>实验二 Java面向对象程序设计 实验报告 实验名称 Java面向对象程序设计 实验内容 初步掌握单元测试和TDD 理解并掌握面相对象三要素:封 ...

  5. 20162311 实验二 Java面向对象程序设计 实验报告

    实验二 Java面向对象程序设计 实验内容 1. 初步掌握单元测试和TDD 2. 理解并掌握面向对象三要素:封装.继承.多态 3. 初步掌握UML建模 4. 熟悉S.O.L.I.D原则 5. 了解设计 ...

  6. 实验二 Java面向对象程序设计实验报告

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

  7. 20145326《Java程序设计》实验二Java面向对象程序设计实验报告

    20145326<Java程序设计>实验二Java面向对象程序设计实验报告 实验内容 初步掌握单元测试和TDD 理解并掌握面向对象三要素:封装.继承.多态 初步掌握UML建模 熟悉S.O. ...

  8. 20155217 实验二 Java面向对象程序设计 实验报告

    20155217 实验二 Java面向对象程序设计 实验报告 实验内容 初步掌握单元测试和TDD 理解并掌握面向对象三要素:封装.继承.多态 初步掌握UML建模 熟悉S.O.L.I.D原则 了解设计模 ...

  9. 20145219 《Java程序设计》实验二 Java面向对象程序设计实验报告

    20145219 <Java程序设计>实验二 Java面向对象程序设计实验报告 实验内容 初步掌握单元测试和TDD 理解并掌握面向对象三要素:封装.继承.多态 初步掌握UML建模 熟悉S. ...

  10. 20162305 实验二 Java面向对象程序设计 实验报告

    20162305 实验二 Java面向对象程序设计 实验报告 实验内容 1.初步掌握单元测试和TDD 2.理解并掌握面向对象三要素:封装.继承.多态 3.初步掌握UML建模 4.熟悉S.O.L.I.D ...

随机推荐

  1. leetcode题解 candy

    要求的条件是: 1.每个人最少一个糖果. 2.相邻的小朋友,要保证,评分高的比评分低的糖果多. 如果从一侧扫描的话,容易确定的就是递增序列,只要上升1个就够了. 容易出现问题的就是:遇到下降期,或者相 ...

  2. Django权限auth模块详解

    转自:http://www.cnblogs.com/Finley/p/5575305.html 1,auth模块是Django提供的标准权限管理系统,可以提供用户身份认证,用户组和权限管理 2,aut ...

  3. python 之列表推导式,集合推导式,以及字典推导式

    https://www.cnblogs.com/weihengblog/p/8428124.html

  4. LeetCode OJ 49. Group Anagrams

    题目 Given an array of strings, group anagrams together. For example, given: ["eat", "t ...

  5. Oracle存储过程中使用临时表

    一.Oracle临时表知识 在Oracle中,临时表分为SESSION.TRANSACTION两种,SESSION级的临时表数据在整个SESSION都存在,直到结束此次SESSION:而 TRANSA ...

  6. Android Studio3.1.2编译时Java Compiler出错:Warning: Failed to parse host proxy3.bj...

    删除gradle.properties中的代理设置... #移除下面配置systemProp.http.proxyHost=proxy3.bj.petrochina systemProp.http.p ...

  7. 30.SSH配置文件模板和类库.md

    目录 1.struts2 4.类库 1.struts2 1.<?xml version="1.0" encoding="UTF-8"?>2.< ...

  8. CSS强制换行和禁止换行代码

    一.强制换行      1.word-break: break-all;       只对英文起作用,以字母作为换行依据.      2.word-wrap: break-word;   只对英文起作 ...

  9. 编程四剑客awk

    awk  'pattern +{action}' file (1)AWK基本语法参数详解 a:单引号 ''是为了和shell命令区分开: b:大括号{}表示一个命令分组: c:pattern 是一个过 ...

  10. HTML 视频

    在html5中使用视频,只要添加元素<video></video>元素表示. <video>有几个属性: src 指定音频文件的路径 poster 视频播放之前显示 ...