一、实验步骤

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添加进去即可。