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

一、实验前期准备

了解三种代码

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

我们先写伪代码伪代码

从意图层面来解决问题;

有了伪代码

我们用特定编程语言翻译一下,就是可用的产品代码;写完产品代码,接下来写测试代码

证明自己的代码没有问题。Java编程时,程序员对类实现的测试叫单元测试

二、Junit的安装和配置

  • 在IDEA中点击Setting->Plugins->Marketplace 搜索Junit下载JUnitGenerator V2.0,下载后重启IDEA即可找到下载好的Junit

  • Junit包的导入:File->Project Settings->Modules->Dependencies->'+'在你的安装IDEA的路径中找到lib文件夹导入图中的两个包后,点击OK即可正常使用

三、实验内容

任务1:对MyUtil类进行测试,测试用例至少要包含正常情况,错误情况,边界情况的测试。

  • 伪代码
百分制转五分制: 如果成绩小于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 "优秀";           
//如果成绩大于100,转成“错误”       
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(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));   
}
}
  • 过程及结果截图

任务2:以TDD的方式研究学习StringBuffer,提交单元测试用例和测试通过的截图。

  • 产品代码
public class StringBufferDemo {  
StringBuffer buffer = new StringBuffer();   
public void StringBufferDemo (StringBuffer buffer) {       
this.buffer = buffer;   
}   
public Character charAt(int i) {       
return buffer.charAt(i);   
}   
public int capacity() {       
return buffer.capacity();   
}   
public int length() {        
return buffer.length();   
}   
public int indexOf(String s) {       
return buffer.indexOf(s);   
}
}
  • 测试代码
import org.junit.Test;
public class StringBufferDemoTest extends TestCase {   
StringBuffer a = new
StringBuffer("StringBuffer");   
StringBuffer b = new
StringBuffer("StringBufferStringBuffer");   
StringBuffer c = new StringBuffer("StringBuffer12345StringBuffer12345");   
@Test   
public void testcharAt() throws Exception {       
assertEquals('S',a.charAt(0));       
assertEquals('u',b.charAt(7));       
assertEquals('g',c.charAt(22));   
}   
@Test   
public void testcapacity() throws  Exception {       
assertEquals(28,a.capacity());       
assertEquals(40,b.capacity());       
assertEquals(50,c.capacity());   
}   
@Test   
public void testlength() throws  Exception {       
assertEquals(12,a.length());       
assertEquals(24,b.length());       
assertEquals(34,c.length());   
}   
@Test   
public void testindexOf() throws Exception {       
assertEquals(6,a.indexOf("Buf"));       
assertEquals(11,b.indexOf("rSt"));       
assertEquals(15,c.indexOf("45St"));   
}
}
  • 对capacity()方法的理解:

    capacity()用于返回当前字符串的最大容量,初始值为16,即无论字符串中是否有内容,都会被分配容量,当有字符被写入是,容量自动增加,例如当输入StringBuffer 时会增加12个大小的空间,调用capacity()会返回当前字符串最大容量28

  • 结果截图

任务3:

  • 对设计模式示例进行扩充,体会OCP原则和DIP原则的应用。

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

    • 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,依赖倒置原则)

我的学号为9,按照要求题目应为3,即让系统支持Long类,代码如下:

public class MyDoc {   
static Document D;   
static Document E;   
public static void main(String[] args) {       
D = new Document(new IntFactory());       
D.DisplayData();       
E = new Document(new LongFactory());       
E.DisplayData();   
}
}
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 = 1000000000;   
}   
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();   
}
}
  • 结果截图

任务四:以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 {   
double RealPart;   
double ImagePart;   
public Complex() {}   
public Complex(double R,double I) {       
RealPart = R;       
ImagePart = I;   
}   
public double getRealPart() {       
return RealPart;   
}   
public double getImagePart() {       
return ImagePart;   
}   
public boolean equals(Object obj) {       
if(this == obj)           
return true;       
if(obj == null)           
return false;       
if(getClass() != obj.getClass())           
return false;       
if(!(obj instanceof Complex))           
return false;       
else {           
Complex complex = (Complex) obj;           
if (complex.ImagePart == ((Complex) obj).ImagePart)               
return true;           
if (complex.RealPart == ((Complex) obj).RealPart)               
return true;       
}       
return false;   
}   
public  String toString() {       
String str = "";       
if (RealPart == 0&&ImagePart == 0)           
str = "0.0";       
else if (RealPart == 0&&ImagePart != 0)           
str = ImagePart + "" + "i";       
else if (RealPart != 0&&ImagePart == 0)           
str = RealPart + "";       
else if (RealPart !=0&&ImagePart > 0)           
str = RealPart + "" + "+" + ImagePart + "i";       
else if (RealPart !=0&&ImagePart < 0)           
str = RealPart + "" + ImagePart + "i";       
return str;   
}   
public Complex ComplexAdd(Complex a) {       
return new Complex(RealPart + a.getRealPart(),ImagePart + a.getImagePart());   
}   
public  Complex ComplexSub(Complex a) {       
return new Complex(RealPart - a.getRealPart(),ImagePart - a.getImagePart());   
}   
public Complex ComplexMulti(Complex a) {       
return new Complex(RealPart*a.getRealPart() - ImagePart*a.getImagePart(),RealPart*a.getImagePart() +
ImagePart*a.getRealPart());   
}   
public Complex ComplexDiv(Complex a) {       
if(a.getRealPart() == 0&&a.getImagePart() == 0) {           
System.out.println("除数不能为0");           
return new Complex();       
}       
else           
return new Complex((RealPart*a.getRealPart() -
ImagePart*a.getImagePart())/(a.getRealPart()*a.getRealPart()-a.getImagePart()*a.getImagePart()),(RealPart*a.getImagePart() + ImagePart*a.getRealPart())/(a.getRealPart()*a.getRealPart()-a.getImagePart()*a.getImagePart()));   
}
}
  • 测试代码
import junit.framework.TestCase;
import org.junit.Test;
public class ComplexTest extends TestCase {   
Complex a = new Complex(2.0,5.0);   
Complex b = new Complex(1.0,-4.0);   
Complex c = new Complex(-3.0,2.0);   
Complex d = new Complex(-4.0,-3.0);   
Complex e = new Complex(0.0,0.0);   
@Test   
public void testgetRealPart() throws Exception {       
assertEquals(2.0,a.getRealPart());       
assertEquals(1.0,b.getRealPart());       
assertEquals(-3.0,c.getRealPart());       
ssertEquals(-4.0,d.getRealPart());       
assertEquals(0.0,e.getRealPart());   
}   
@Test   
public void testgetImagePart() throws Exception {       
assertEquals(5.0,a.getImagePart());       
assertEquals(-4.0,b.getImagePart());       
assertEquals(2.0,c.getImagePart());       
assertEquals(-3.0,d.getImagePart());       
assertEquals(0.0,e.getImagePart());   
}   
@Test   
public void testequals() throws Exception {       
assertEquals(true,a.toString().equals(a.toString()));       
assertEquals(false,b.toString().equals(c.toString()));       
assertEquals(false,d.toString().equals(e.toString()));   
}   
@Test   
public void testtoString() throws Exception {       
assertEquals("2.0+5.0i",a.toString());       
assertEquals("1.0-4.0i",b.toString());       
assertEquals("-3.0+2.0i",c.toString());       
assertEquals("-4.0-3.0i",d.toString());       
assertEquals("0.0",e.toString());   
}   
@Test   
public void testComplexAdd() throws Exception {       
assertEquals("3.0+1.0i",a.ComplexAdd(b).toString());       
assertEquals("-7.0-1.0i",c.ComplexAdd(d).toString());       
assertEquals("-4.0-3.0i",d.ComplexAdd(e).toString());   
}   
@Test   
public void testComplexSub() throws Exception {       
assertEquals("1.0+9.0i",a.ComplexSub(b).toString());       
assertEquals("1.0+5.0i",c.ComplexSub(d).toString());       
assertEquals("-3.0+2.0i",c.ComplexSub(e).toString());   
}   
public void testComplexMulti() throws Exception {       
assertEquals("22.0-3.0i",a.ComplexMulti(b).toString());       
assertEquals("18.0+1.0i",c.ComplexMulti(d).toString());       
assertEquals("0.0",b.ComplexMulti(e).toString());   
}   
public void testComplexDiv() throws Exception {       
assertEquals("-1.4666666666666666+0.2i",a.ComplexDiv(b).toString());       
assertEquals("2.5714285714285716+0.14285714285714285i",c.ComplexDiv(d).toString());       
assertEquals("0.0",a.ComplexDiv(e).toString());   
}
}
  • 结果截图

任务5:

  • 使用StarUML对实验二中的代码进行建模,发类图的截图,加上学号水印
  • 类图中只少两个类
  • 类,继承,接口实现,组合在UML中表达

选择画类图的题目为任务3

四、实验中遇到的问题

  • 在按照博客中给的步骤进行任务2时按照给的代码输入后发现结果与所给的不同,反复测试后发现博客中代码存在问题,因为将代码12345添加至了第八行中,而这一行代码在执行时被注释掉不会被执行,但第五行的字符串和之前相比并没有发生改变,因此在运行时不会出现给出的结果,应该将代码12345添加至第五行的字符串末尾才能出现事例中的运行结果

五、脚本运行截图

六、代码托管

https://gitee.com/wangzihong/20175209/tree/master

20175209 实验二《Java面向对象程序设计》实验报告的更多相关文章

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  10. 20145239杜文超 《Java程序设计》实验二 Java面向对象程序设计实验报告

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

随机推荐

  1. Android View的重绘过程之Draw

    博客首页:http://www.cnblogs.com/kezhuang/p/ View绘制的三部曲,测量,布局,绘画现在我们分析绘画部分测量和布局 在前两篇文章中已经分析过了.不了解的可以去我的博客 ...

  2. Dart语言入门(一)

    Dart 语言介绍 Dart 是谷歌在 2011 年推出的编程语言,是一种结构化 Web 编程语言,允许用户通过 Chromium 中所整合的虚拟机(Dart VM)直接运行 Dart 语言编写的程序 ...

  3. 使用免费 mongodb数据库 + 免费node.js服务器搭建小程序接口

    由于微信的小程序只支持不带端口的域名接口,不支持IP地址和接口,所以我们需要映射到80端口并绑定备案过的域名才能被微信小程序访问到.简单点就是接口需要 https 协议才行,找了许久的免费的数据库与n ...

  4. DVWA 黑客攻防演练(十四)CSRF 攻击 Cross Site Request Forgery

    这么多攻击中,CSRF 攻击,全称是 Cross Site Request Forgery,翻译过来是跨站请求伪造可谓是最防不胜防之一.比如删除一篇文章,添加一笔钱之类,如果开发者是没有考虑到会被 C ...

  5. git错误--ssh: Could not resolve hostname ssh.github.com: Name or service not known--解决方式

    错误如下: git push origin ssh: Could not resolve hostname ssh.github.com: Name or service not known fata ...

  6. Spring Boot使用Maven打包替换资源文件占位符

    在Spring Boot开发中,通过Maven构建项目依赖是一件比较舒心的事,可以为我们省去处理冲突等大部分问题,将更多的精力用于业务功能上.近期在项目中,由于项目集成了其他外部系统资源文件,需要根据 ...

  7. 事务的四大特性(ACID):

    事务的四大特性(ACID):    1.原子性(Atomicity): 事务中所有操作是不可再分割的原子单元.事务中所有操作要么都执行成功,要么都执行失败. 2.一致性(Consistency): 事 ...

  8. SqlServer无备份下误删数据恢复

    系统已上线,给客户修改bug的时候,使用delete语句删表数据,没想到库没切换成测试库.误删了正式库的数据,而且一次备份都没有做过,玩大了 不扯了,进入主题 网上很多方法,都是针对至少有一次备份的情 ...

  9. 应用wavesurfer.js绘制音频波形图小白极速上手总结

    一.简介 1.1  引   人生中第一份工作公司有语音识别业务,需要做一个web网页来整合语音引擎的标注结果和错误率等参数,并提供人工比对的语音标注功能(功能类似于TranscriberAG等),(博 ...

  10. AI和机器学习对云应用的安全产生了何种影响?

    AI和机器学习对云应用的安全产生了何种影响? 正如其他许多新兴技术一样,AI是一把双刃剑,它对于云计算的安全影响是双重的:这项技术可以使工作负载变得更加安全,但也可能会为新的威胁打开大门. 出现这种分 ...