一、实验步骤
1.初步掌握单元测试和TDD
2.理解并掌握面向对象三要素：封装，继承，多态
3.初步掌握UML建模
4.熟悉S.O.L.I.D原则
5.了解设计模式
二、实验内容
（一）、单元测试
1.三种代码
- 伪代码
百分制转五分制：
如果成绩小于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 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!");
}
}
2.TDD（Test Dirven Development,测试驱动开发）
(1).明确当前要完成的功能，记录成一个测试列表
(2).快速完成编写针对此功能的测试用例
(3).测试代码编译不通过（没产品代码呢）
(4).编写产品代码
(5).测试通过
(6).对代码进行重构，并保证测试通过（重构下次实验联系）
(7).循环完成所有功能的开发
基于TDD，我们不会出现过度设计的情况，需求通过测试用例表达出来，我们的产品代码只要让测试通过就可以了。
3.实验截图
（二）、面向对象三要素
1.分析
*面向对象(Object-Oriented)的三要素包括：封装、继承、多态。过程抽象的结果是函数，数据抽象的结果是抽象数据类型（Abstract Data Type，ADT），类可以作具有继承和多态机制的ADT。数据抽象才是OOP的核心和起源。
*构造函数实现对象初始化流程的封装。方法封装了操作对象的流程。Java中还可以用private封装对象私有数据成员。封装的目的主要就是隐藏对象细节，将对象当做黑箱进行操作。
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() + "!";
}
}
*继承基本上就是为了避免多个类间重复定义行为共同行为。子类利用关键词extends继承父类，避免重复的行为定义。
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 Dog extends Animal{
public String shout(){
return "汪汪";
}
public String toString(){
return "The Dog's color is " + this.getColor() +", and it shouts "+ this.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() + "!";
}
}
*多态就是使用单一接口操作多种类型的对象。
package cc.openhome;
public class RPG {
public static void main(String[] args) {
SwordsMan swordsMan = new SwordsMan();
swordsMan.setName("Justin");
swordsMan.setLevel(1);
swordsMan.setBlood(200);
Magician magician = new Magician();
magician.setName("Monica");
magician.setLevel(1);
magician.setBlood(100);
drawFight(swordsMan);
drawFight(magician);
}
static void drawFight(Role role) {
System.out.print(role.getName());
role.fight();
}
}
2.截图
（三）SOLID理解
单一职责原则：
定义的类型只做自己份内的事情，不开发无所不能的“上帝类”。
例如一个类A定义了各种属性表示状态，那么状态之间的相互关联，相互影响的关系应该在内部逻辑完成。而不要借助另一个类B来操纵A在各种状态中进行转换。
单一原则带来的好处就是得到了类级别的“高内聚”。
开放封闭原则：
类,模块,函数对扩展开放，对修改闭合。
具体做法就是在可能需要扩展的地方使用接口，抽象基类进行隔离。当需要加入新的功能时，只需要传入一个新的实现了接口或者基类的类。
例如，开发的数据访问层，用接口或基类来规范访问数据的CRUD各种操作，将来即使需要替换不同类型数据库，甚至改变表结构，都不会影响到其余的各层。对于开发工作的分工好处也很多。并且可以带来单元测试上的便利。只需要自己实现一个接口/基类的类就能够模仿数据层的工作。
里氏替换原则：
说的明白点就是子类必须能够替换它们的父类。
接口分离原则：
这个原则的意思是一个接口或者类应该拥有尽可能少的行为。
注意了关键点在尽量少。
接口的设计很容易会失控，不停地添加功能使得一个接口越来越臃肿，导致接口方法越来越多。
其实一种接口就是实现一组相关的操作就可以了。多而全不是一个好的选择。
依赖倒置原则：
高层模块不应该依赖底层模块，两者都应该依赖其抽象。其实就是”面向接口编程，不要面向实现编程“的内在要求。
此原则经常和依赖倒置联系在一起的说法就是“控制反转”，所谓反转，就是高层模块只需要知道干什么就足够了，而底层模块负责怎么做的问题。
另一种说法是细节依赖抽象，抽象不能依赖细节。
（四）UML建模
三、问题与解决
问题一、实验第一个步骤TEST总是标红。
解决方案:在同学的指导下，只要再将Junit-4.12.jar添加进去即可。