一、实验步骤

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各种操作，将来即使需要替换不同类型数据库，甚至改变表结构，都不会影响到其余的各层。对于开发工作的分工好处也很多。并且可以带来单元测试上的便利。只需要自己实现一个接口/基类的类就能够模仿数据层的工作。

里氏替换原则：

说的明白点就是子类必须能够替换它们的父类。

接口分离原则：

这个原则的意思是一个接口或者类应该拥有尽可能少的行为。

注意了关键点在尽量少。

接口的设计很容易会失控，不停地添加功能使得一个接口越来越臃肿，导致接口方法越来越多。

其实一种接口就是实现一组相关的操作就可以了。多而全不是一个好的选择。

依赖倒置原则：

高层模块不应该依赖底层模块，两者都应该依赖其抽象。其实就是”面向接口编程，不要面向实现编程“的内在要求。

此原则经常和依赖倒置联系在一起的说法就是“控制反转”，所谓反转，就是高层模块只需要知道干什么就足够了，而底层模块负责怎么做的问题。

另一种说法是细节依赖抽象，抽象不能依赖细节。