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

实验内容

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

实验步骤

一、单元测试与TDD

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

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

    正确的顺序应为:伪代码(思路)→ 测试代码(产品预期功能)→ 产品代码(实现预期功能),这种开发方法叫“测试驱动开发”(TDD)。

TDD的一般步骤如下:

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

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

任务一:实现百分制成绩转成“优、良、中、及格、不及格”五级制成绩并利用JUnit测试检验正常情况,错误情况,边界情况

伪代码:

百分制转五分制:
如果成绩小于60,转成“不及格”
如果成绩在60与70之间,转成“及格”
如果成绩在70与80之间,转成“中等”
如果成绩在80与90之间,转成“良好”
如果成绩在90与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 "优秀";
else
return "错误";
}
}

测试代码:

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(-55));
assertEquals("错误",MyUtil.percentage2fivegrade(105));
}
@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

老师所给程序如下:

public class StringBufferDemo{
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.indexOf("tring"));
System.out.println(buffer.length());
System.out.println("buffer = " + buffer.toString());
}
}

根据TDD方式设计出JUnit测试用例:

  • 首先,此程序中需要测试的方法有:charAt()capacity()length()indexOf()。利用断言进行比较。
  • 通过老师实验中的讲解,charAt()返回此序列中指定索引处的 char 值。(第一个 char 值在索引 0 处,第二个在索引 1 处,依此类推,这类似于数组索引。);capacity()是一个获取当前实体的实际容量的方法;length()是获取实体中存放的字符序列的长度的方法;indexOf()是返回输入的子字符串的第一个字母在母字符串的位置的方法。所以在JUnit测试用例中设置三个容量与长度都不相同的字符串,来对capacity()length()这两个方法进行更加深刻的学习。

测试代码:

import org.junit.Test;
import junit.framework.TestCase;
public class StringBufferDemoTest extends TestCase { StringBuffer a = new StringBuffer("StringBuffer");
StringBuffer b = new StringBuffer("StringBufferStringBuffer");
StringBuffer c = new StringBuffer("StringBufferStringBufferStringBuffer"); @Test
public void testcharAt() {
assertEquals('S',a.charAt(0));
assertEquals('i',a.charAt(3));
assertEquals('B',a.charAt(6));
}
@Test
public void testcapacity() {
assertEquals(28,a.capacity());
assertEquals(40,b.capacity());
assertEquals(52,c.capacity());
}
@Test
public void testindexOf() {
assertEquals(0,a.indexOf("String"));
assertEquals(4,a.indexOf("ngB"));
assertEquals(8,a.indexOf("ffer"));
}
@Test
public void testlength() {
assertEquals(12,a.length());
assertEquals(24,b.length());
assertEquals(36,c.length());
}
}

测试结果:

二、面向对象三要素

  • 抽象

     - 抽象就是抽出事物的本质特征而暂时不考虑他们的细节。对于复杂系统问题人们借助分层次抽象的方法进行问题求解;在抽象的最高层,可以使用问题环境的语言,以概括的方式叙述问题的解。
    - 编程原则DRY(Don't Repeat Yourself)
  • 封装、继承与多态

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

三、设计模式初步

  • 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,依赖倒置原则)
  • OCP是OOD中最重要的一个原则,OCP的内容是:

    - software entities (class, modules, function, etc.) should open for extension,but closed for modification.

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

  • DIP的内容是:

    - High level modules should not depend upon low level modules. Both should depend upon abstractions Abstractions should not depend upon details. Details should depend upon abstractions

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

任务三:对设计模式示例进行扩充,体会OCP原则和DIP原则的应用,初步理解设计模式(扩充:让系统支持Long类,并在MyDoc类中添加测试代码表明添加正确)

代码实现:

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 {
int value;
Long(){
value=11271013;
}
public void DisplayValue(){
System.out.println(value);
}
}
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 Document {
Data pd;
Document(Factory pf){
pd = pf.CreateDataObject();
}
public void DisplayData(){
pd.DisplayValue();
}
}
public class MyDoc{
static Document d;
public static void main(String [] args) {
d = new Document(new IntFactory());
d = new Document(new LongFactory());
d.DisplayData();
}
}

测试结果:

任务四:以TDD的方式开发一个复数类Complex

代码实现:

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(0, 3);
Complex c2 = new Complex(-1, -1);
Complex c3 = new Complex(2, 1); @Test
public void testgetRealPart() throws Exception {
assertEquals(-1.0, Complex.getRealPart(-1.0));
assertEquals(5.0, Complex.getRealPart(5.0));
assertEquals(0.0, Complex.getRealPart(0.0));
} @Test
public void testgetImagePart() throws Exception {
assertEquals(-1.0, Complex.getImagePart(-1.0));
assertEquals(5.0, Complex.getImagePart(5.0));
assertEquals(0.0, Complex.getImagePart(0.0));
} @Test
public void testComplexAdd() throws Exception {
assertEquals("-1.0+2.0i", c1.ComplexAdd(c2).toString());
assertEquals("2.0+4.0i", c1.ComplexAdd(c3).toString());
assertEquals("1.0", c2.ComplexAdd(c3).toString());
} @Test
public void testComplexSub() throws Exception {
assertEquals("1.0+4.0i", c1.ComplexSub(c2).toString());
assertEquals("-2.0+2.0i", c1.ComplexSub(c3).toString());
assertEquals("-3.0 -2.0i", c2.ComplexSub(c3).toString());
} @Test
public void testComplexMulti() throws Exception {
assertEquals("3.0 -3.0i", c1.ComplexMulti(c2).toString());
assertEquals("-3.0+6.0i", c1.ComplexMulti(c3).toString());
assertEquals("-1.0 -3.0i", c2.ComplexMulti(c3).toString());
} @Test
public void testComplexComplexDiv() throws Exception {
assertEquals("-1.5 -1.5i", c1.ComplexDiv(c2).toString());
assertEquals("1.2+0.6i", c1.ComplexDiv(c3).toString());
assertEquals("-0.6 -0.6i", c2.ComplexDiv(c3).toString());
}
}

测试结果:

遇到的问题:

在写JUnit测试用例时,寻找到用来测试的合适的复数比较困难。由于复数的除法较为复杂,在测试时,很容易出现无限循环的小数,导致测试失败。

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

如图:

总结与体会

本次实验内容较多,但是掌握了JUnit测试的方法,通过编写测试代码,可以测试自己代码中正常情况、异常情况、边界情况或是程序中的算法是否正确。这样减少了对于代码的重复多次运行与数据测试,费时也费力,有时一些数据会导致运行崩溃,对电脑也有损伤。

在利用JUnit测试代码的过程中,也掌握了对于assertEquals的使用,对于代码中一些方法的理解也更加透彻与深刻。

在实验过程中,对于TDD方式、UML建模、S.O.L.I.D原则以及设计模式等等,也有更加深刻而切身的体会。编写代码是一个需要思考与改进的过程,对自己Java的水平也是一个提高。

步骤 耗时 百分比
需求分析 10min 17.2%
设计 20min 34.5%
代码实现 8min 13.8%
测试 15min 25.9%
分析总结 5min 8.6%

20165233 实验二 Java面向对象程序设计的更多相关文章

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

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

  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. 20145113 实验二 Java面向对象程序设计

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

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

    北京电子科技学院(BESTI) 实     验    报     告 课程:Java程序设计  班级:1353  姓名:韩玉琪  学号:20135317 成绩:             指导教师:娄嘉 ...

  7. 20145225唐振远 实验二 "Java面向对象程序设计"

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

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

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

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

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

随机推荐

  1. 解决本地项目推送到码云(github),上提示:failed to push some refs to ...

    本地项目上传github 命令如下: 1.git init 2.git add . 3.git commit  -m "init" 4.git remote add origin ...

  2. TensorFlow实现FM

    看了网上的一些用tf实现的FM,很多都没有考虑FM实际使用中数据样本稀疏的问题. 我在实现的时候使用 embedding_lookup_sparse来解决这个问题. 对于二阶部分,由于embeddin ...

  3. Linux 常用环境搭建

    已有环境 python 2.6.6 jdk 1.7 —tomcat— —jenkins— —jq— —Python 2.7— —pip— —PIL— —Android SDK— —yum or apt ...

  4. hdu2897找规律

    又是找规律,无语了,说好的博弈呢,搞了半天的sg函数没有一点头绪 当n%(p+q)==0时,先手win,第一次取q个,以后每次,后手取k个,先手就取p+q-k个,最后,后手必取q个 当n=(p+q)* ...

  5. AppCrawler自动化遍历使用详解(版本2.1.0 )

    AppCrawle是自动遍历的app爬虫工具,最大的特点是灵活性,实现:对整个APP的所有可点击元素进行遍历点击.   优点: 1.支持android和iOS, 支持真机和模拟器 2.可通过配置来设定 ...

  6. gcd 与 扩gcd 总结

    gcd 定理的证明: 模板: ll gcd(ll a,ll b) { ) return a; else return gcd(b,a%b); } 扩gcd证明: 模板: ll extgcd(ll a, ...

  7. 通读cheerio API-网络爬虫

    所谓工欲善其事,必先利其器,所以通读了cheerio的API,顺便翻译了一遍,有些地方因为知道的比较少,不知道什么意思,保留了英文,希望各位不吝告诉我,然后一起把这个翻译完成. ###cheerio ...

  8. [转载]Morris Traversal方法遍历二叉树(非递归,不用栈,O(1)空间)

    本文主要解决一个问题,如何实现二叉树的前中后序遍历,有两个要求: 1. O(1)空间复杂度,即只能使用常数空间: 2. 二叉树的形状不能被破坏(中间过程允许改变其形状). 通常,实现二叉树的前序(pr ...

  9. 038——VUE中组件之WEB开发中组件使用场景与定义组件的方式

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  10. hdu5818

    题解: 维护两个左偏树 按照左偏树模板来做 代码: #include<cstdio> #include<cmath> #include<algorithm> #in ...