2018-2019-2 20175105王鑫浩 实验二《Java面向对象程序设计》实验报告

一、实验步骤

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