20155208实验二 Java面向对象程序设计
一、实验内容
1、初步掌握单元测试和TDD
2、理解并掌握面向对象三要素：封装、继承、多态
3、初步掌握UML建模
4、熟悉S.O.L.I.D原则
5、了解设计模式
二、实验步骤
（一）单元测试
（1）三种代码
伪代码：以简洁的自然语言表明设计步骤；
- 百分制转五分制： 如果成绩小于60，转成“不及格” 如果成绩在60与70之间，转成“及格” 如果成绩在70与80之间，转成“中等” 如果成绩在80与90之间，转成“良好” 如果成绩在90与100之间，转成“优秀” 其他，转成“错误” 产品代码：用以实现特定功能的程序或机器语言；
package exp1;
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 "错误";
}
}- 测试代码：用以对产品代码进行测试的代码；
1、测试一：选取某一合法输入值进行测试
package Test;
public class MyUtilTest {
public static void main(String[] args) {
// 百分制成绩是50时应该返回五级制的“不及格”
if(MyUtil.percentage2fivegrade(50) != "不及格")
System.out.println("test failed!");
else
System.out.println("test passed!");
}
}2、测试二：全面覆盖各等级段
package Test;
public class MyUtilTest {
public static void main(String[] args) {
//测试正常情况
if(MyUtil.percentage2fivegrade(55) != "不及格")
System.out.println("test failed!");
else if(MyUtil.percentage2fivegrade(65) != "及格")
System.out.println("test failed!");
else if(MyUtil.percentage2fivegrade(75) != "中等")
System.out.println("test failed!");
else if(MyUtil.percentage2fivegrade(85) != "良好")
System.out.println("test failed!");
else if(MyUtil.percentage2fivegrade(95) != "优秀")
System.out.println("test failed!");
else
System.out.println("test passed!");
}
}运行结果如下：
3、测试三：异常情况测试
public class MyUtilTest {
public static void main(String[] args) {
//测试出错情况
if(MyUtil.percentage2fivegrade(-10) != "错误")
System.out.println("test failed 1!");
else if(MyUtil.percentage2fivegrade(115) != "错误")
System.out.println("test failed 2!");
else
System.out.println("test passed!");
}
}运行结果如下：
和我们预期的结果不一样，原因是判断不及格时没有要求成绩大于零，因此我们增加对负分的判断：
if ((grade < 0)) return "错误"; 再次运行，测试结果符合预期，如下图所示：
测试四：测试分段结点
package Test;
public class MyUtilTest {
public static void main(String[] args) {
//测试边界情况
if(MyUtil.percentage2fivegrade(0) != "不及格")
System.out.println("test failed 1!");
else if(MyUtil.percentage2fivegrade(60) != "及格")
System.out.println("test failed 2!");
else if(MyUtil.percentage2fivegrade(70) != "中等")
System.out.println("test failed 3!");
else if(MyUtil.percentage2fivegrade(80) != "良好")
System.out.println("test failed 4!");
else if(MyUtil.percentage2fivegrade(90) != "优秀")
System.out.println("test failed 5!");
else if(MyUtil.percentage2fivegrade(100) != "优秀")
System.out.println("test failed 6!");
else
System.out.println("test passed!");
}
}运行结果如下：
于是把判断优秀的条件中包含输入为100的情况，对下面代码进行修改：
else if (grade < 100) return "优秀"; 改成
else if (grade <= 100) return "优秀"; 再次运行，测试结果符合预期，如下图所示：
（2）TDD(Test Driven Devlopment, 测试驱动开发)
- TDD：先写测试代码，然后再写产品代码的开发方法。
- TDD的一般步骤如下： 1、明确当前要完成的功能，记录成一个测试列表
2、快速完成编写针对此功能的测试用例
3、测试代码编译不通过（没产品代码呢）
4、编写产品代码
5、测试通过
6、对代码进行重构，并保证测试通过（重构下次实验练习）
7、循环完成所有功能的开发
在此介绍IDEA下TDD的使用方法：鼠标右键->Go To ->Test
TDD的编码节奏是：
- 增加测试代码，JUnit出现红条
- 修改产品代码
- JUnit出现绿条，任务完成
（二）面向对象三要素
（1）抽象
即“求同存异、去粗取精”的过程。将若干事物中相同的部分进行剥离整理，并形成具有某特定功能的产品，这一过程即为抽象。过程抽象的结果是函数，数据抽象的结果是抽象数据类型其显而易见的好处是（在程序设计中）减少了代码大重复性，提高了效率。
（2）封装、继承与多态
面向对象(Object-Oriented)的三要素包括：封装、继承、多态。面向对象的思想涉及到软件开发的各个方面，如面向对象分析（OOA）、面向对象设计（OOD）、面向对象编程实现(OOP)。OOA根据抽象关键的问题域来分解系统，关注是什么（what）。OOD是一种提供符号设计系统的面向对象的实现过程，用非常接近问题域术语的方法把系统构造成“现实世界”的对象，关注怎么做（how）,通过模型来实现功能规范。OOP则在设计的基础上用编程语言（如Java）编码。贯穿OOA、OOD和OOP的主线正是抽象。 封装：将与某一将数据与相关行为包装在一起以实现信息就隐藏，核心内容是模块化和信息隐藏，与此相伴的是接口的使用。
1、封装示例：
public class Dog {
private String color;
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String bark(){
return "汪汪";
}
public String toString(){
return "The Dog's color is " + this.getColor() +", and it shouts "+ this.bark() + "!";
}
}检测示例：
public class DogTest {
public static void main(String[] args) {
Dog d = new Dog();
d.setColor("Yellow");
getInfo(d);
}
public static void getInfo(Dog d) {
System.out.println(d.toString());
}
}运行结果如下：
利用StarUML软件进行UML建模，可以将以上思路进行具象化表示：
继承：以封装为基础，一个类的定义可以基于另外一个已经存在的类，即子类基于父类，从而实现父类代码的重用。其更为广泛而重要的作用是实现多态。 2、继承示例：Dog类和Cat类都有Color属性和相应的setter和getter方法，可以通过继承使其精炼化，把Color属性和相应的setter和getter方法放到父类Animal中，代码如下：
public abstract class Animal {
private String color;
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public abstract String shout();
}
public class Cat extends Animal {
public String shout() {
return "喵喵";
}
public String toString() {
return "The Cat's color is " + this.getColor() +", and it shouts "+ this.shout() + "!";
}
}
public class Dog extends Animal
{
public String shout() {
return "汪汪";
}
public String toString() {
return "The Dog's color is " + this.getColor() +", and it shouts "+ this.shout() + "!";
}
}- 在Java中，当我们用父类声明引用，用子类生成对象时，多态就出现了。封装、继承与多态是在抽象的基础上进行的“进化”，用于减少重复和赘余。其中很重要的思想就是模块化和信息隐藏。
(三)设计模式
（1）S.O.L.I.D原则
- SRP(Single Responsibility Principle,单一职责原则) 对象提供单一职责的高度封装，对象的改变仅仅依赖于单一职责的改变
- OCP(Open-Closed Principle,开放-封闭原则) 即对扩充开放（功能可增加），对修改封闭（源代码不可改动）
- OCP实现手段：（1）抽象和继承，（2）面向接口编程
- LSP(Liskov Substitusion Principle,Liskov替换原则) 子类必须可以被其基类所代，父类型对象可以被子类型对象所取代
- ISP(Interface Segregation Principle,接口分离原则) 客户不应该依赖他们并未使用的接口
- DIP(Dependency Inversion Principle,依赖倒置原则)
（2）模式与设计模式
模式是某外在环境(Context) 下﹐对特定问题(Problem)的惯用解决之道。其中最重要的是设计模式。
（3）设计模式实示例
设计模式四个基本元素 Pattern name：描述模式，便于交流，存档 Problem：描述何处应用该模式 Solution：描述一个设计的组成元素，不针对特例 Consequence：应用该模式的结果和权衡 示例如下：
package exp1;
class Integer {
int value;
public Integer(){
value=100;
}
public void DisplayValue(){
System.out.println(value);
}
}
class Document {
Integer pi;
public Document(){
pi = new Integer();
}
public void DisplayData(){
pi.DisplayValue();
}
}
public class MyDoc{
static Document d;
public static void main(String [] args) {
d = new Document();
d.DisplayData();
}
}运行结果： （四）练习
使用TDD的方式设计关实现复数类Complex
1.伪代码：
Complex类要输出实部，输出虚部，并按照a+bi的形式输出复数。 Complex类中有两个变量，实部RealPart和虚部ImaginePart；
方法：
getRealPart(int RealPart);返回实部 getImaginePart(int ImaginePart);返回虚部 add(Complex c);实现复数相加 minus(Complex c);实现复数相减 multiply(Complex c);实现复数相乘 toString(int RealPart,int ImaginePart);将复数输出成a+bi的格式。
2.测试代码：
package Test;
import exp1.MyComplex;
import org.junit.Test;
import static org.junit.Assert.*;
public class MyComplexTest {
MyComplex a=new MyComplex(1,2);
MyComplex b=new MyComplex(1,-4);
MyComplex c=new MyComplex(19,0);
MyComplex d=new MyComplex(0,-3);
MyComplex e=new MyComplex(0,0);
@Test
public void getRealPart() throws Exception {
assertEquals(1, MyComplex.getRealPart(1));
assertEquals(-1, MyComplex.getRealPart(-1));
assertEquals(5, MyComplex.getRealPart(5));
assertEquals(22, MyComplex.getRealPart(22));
assertEquals(-100, MyComplex.getRealPart(-100));
assertEquals(0, MyComplex.getRealPart(0));
}
@Test
public void getImaginePart() throws Exception {
assertEquals(1, MyComplex.getImaginePart(1));
assertEquals(-1, MyComplex.getImaginePart(-1));
assertEquals(5, MyComplex.getImaginePart(5));
assertEquals(22, MyComplex.getImaginePart(22));
assertEquals(-100, MyComplex.getImaginePart(-100));
assertEquals(0, MyComplex.getImaginePart(0));
}
@Test
public void add() throws Exception {
assertEquals("(2.0-2.0i)", a.add(b).toString());
assertEquals("(20.0+2.0i)", a.add(c).toString());
assertEquals("(1.0-1.0i)", a.add(d).toString());
assertEquals("(1.0+2.0i)", a.add(e).toString());
}
@Test
public void minus() throws Exception {
assertEquals("(0.0+6.0i)", a.minus(b).toString());
assertEquals("(-18.0+2.0i)", a.minus(c).toString());
assertEquals("(1.0+5.0i)", a.minus(d).toString());
assertEquals("(1.0+2.0i)", a.minus(e).toString());
}
@Test
public void multiply() throws Exception {
assertEquals("(9.0-2.0i)", a.multiply(b).toString());
assertEquals("(19.0+38.0i)", a.multiply(c).toString());
assertEquals("(6.0-3.0i)", a.multiply(d).toString());
assertEquals("(0.0)", a.multiply(e).toString());
}
}单元测试运行通过:
3.产品代码:
PSP(Personal Software Process)时间
| 步骤 | 耗时 | 百分比 |
|---|---|---|
| 需求分析 | 10min | 9.1% |
| 设计 | 15min | 13.6% |
| 代码实现 | 40min | 36.4% |
| 测试 | 25min | 22.7% |
| 分析总结 | 20min | 18.2% |
总结
这次最大的收获就是学会了Junit单元测试，从表面上看，每个单元程序都编写测试代码似乎是增加了工作量，但是其实这些代码不仅为你织起了一张保护网，而且还可以帮助你快速定位错误从而使你大大减少修复BUG的时间。