2017-2018-2 20165330实验二《Java面向对象程序设计》实验报告

实验内容

• 初步掌握单元测试和TDD
• 理解并掌握面向对象三要素：封装、继承、多态
• 初步掌握UML建模
• 熟悉S.O.L.I.D原则
• 了解设计模式

实验步骤

（一）单元测试

1. 三种代码

• 伪代码：从意图层面来解决问题，表达自己思路的框架
• 产品代码：用特定编程语言将伪代码翻译成产品代码
• 测试代码：测试产品代码

1. 实验

• 产品代码

public class MyUtil{
    public static String percentage2fivegrade(int grade){
        //如果成绩小于0，转成“错误”
        if ((grade < 0))
            return "错误";
            //如果成绩小于60，转成“不及格”
        else 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 "优秀";
            //如果成绩大于100，转成“错误”
        else
            return "错误";
    }
}

• 测试代码

import junit.framework.TestCase;
import org.junit.Test;

import static org.junit.Assert.*;

/**
 * Created by zyx on 2018/4/15.
 */
public class MyUtilTest extends TestCase {
    @Test
    public void testNormal() {
        assertEquals("不及格", MyUtil.percentage2fivegrade(55));
        assertEquals("及格", MyUtil.percentage2fivegrade(65));
        assertEquals("中等", MyUtil.percentage2fivegrade(75));
        assertEquals("良好", MyUtil.percentage2fivegrade(85));
        assertEquals("优秀", MyUtil.percentage2fivegrade(95));

    }
    @Test
    public void testException(){
        assertEquals("不及格",MyUtil.percentage2fivegrade(55));
        assertEquals("不及格",MyUtil.percentage2fivegrade(55));
    }
    @Test
    public void testBoundary(){
        assertEquals("不及格",MyUtil.percentage2fivegrade(0));
        assertEquals("及格",MyUtil.percentage2fivegrade(60));
        assertEquals("中等",MyUtil.percentage2fivegrade(70));
        assertEquals("良好",MyUtil.percentage2fivegrade(80));
        assertEquals("优秀",MyUtil.percentage2fivegrade(90));
        assertEquals("优秀",MyUtil.percentage2fivegrade(100));
    }
}

• 结果截图

TDD(Test Driven Devlopment, 测试驱动开发)

1. TDD的一般步骤：

• 明确当前要完成的功能，记录成一个测试列表
• 快速完成编写针对此功能的测试用例
• 测试代码编译不通过（没产品代码呢）
• 编写产品代码
• 测试通过
• 对代码进行重构，并保证测试通过（重构下次实验练习）
• 循环完成所有功能的开发

1. TDD的编码节奏

• 增加测试代码，JUnit出现红条
• 修改产品代码
• JUnit出现绿条，任务完成

1. IDEA中使用JUnit：安装插件 → 新建一个空类MyUtil1 → 创建JUnit3的测试用例 → 增加一个测试用例testNormal

（二）面向对象三要素

1. 三要素：封装、继承、多态

• 封装就是将数据与相关行为包装在一起以实现信息就隐藏。
• 继承指一个类的定义可以基于另外一个已经存在的类，即子类基于父类，从而实现父类代码的重用。
• 多态是指不同的类对象调用同一个签名的成员方法时将执行不同代码的现象。

1. 实验：以TDD的方式研究学习StringBuffer

• 产品代码

/**
 * Created by zyx on 2018/4/15.
 */

public class StringBufferDemo{
    StringBuffer buffer = new StringBuffer();
    public StringBufferDemo(StringBuffer buffer){
        this.buffer = buffer;
    }
    public Character charAt(int i){
        return buffer.charAt(i);
    }
    public int capacity(){
        return buffer.capacity();
    }
    public int length(){
        return buffer.length();
    }
    public int indexOf(String buf) {
        return buffer.indexOf(buf);
    }

}

• 测试代码

import junit.framework.TestCase;
import org.junit.Test;

import static org.junit.Assert.*;

/**
 * Created by zyx on 2018/4/15.
 */
public class StringBufferDemoTest extends TestCase {

    StringBuffer string1 = new StringBuffer("Beautiful");
    StringBuffer string2 = new StringBuffer("Beautiful Girls");
    StringBuffer string3 = new StringBuffer("Beautiful Girls and Boys");
    @Test
    public void testCharAt(){
        assertEquals('a',string1.charAt(2));
        assertEquals(' ',string2.charAt(9));
        assertEquals('a',string3.charAt(16));
    }
    @Test
    public void testCapacity(){
        assertEquals(25,string1.capacity());
        assertEquals(31,string2.capacity());
        assertEquals(40,string3.capacity());
    }
    @Test
    public void testindexOf() {

        assertEquals(1, string3.indexOf("ea"));
    }
    @Test
    public void testlength() {

        assertEquals(9, string1.length());
    }
}

1. 结果截图

（三）设计模式初步

1. S.O.L.I.D原则

• SRP(Single ResponsibilityPrinciple,单一职责原则)
• OCP(Open-Closed Principle,开放-封闭原则)
• LSP(Liskov Substitusion Principle,Liskov替换原则)
• ISP(Interface Segregation Principle,接口分离原则)
• DIP(Dependency Inversion Principle,依赖倒置原则)

1. 设计模式：创建型，结构型，行为型
2. 设计模式有四个基本要素：

• Pattern name：描述模式，便于交流，存档
• Problem：描述何处应用该模式
• Solution：描述一个设计的组成元素，不针对特例
• Consequence：应用该模式的结果和权衡（trade-offs）

1. 实验：用自己的学号（20165330）%6进行取余运算，根据结果进行代码扩充

0： 让系统支持Byte类，并在MyDoc类中添加测试代码表明添加正确。

• 代码

// Server Classes
abstract class Data {
    abstract public void DisplayValue();
}
class Byte extends  Data {
    int value;
    Byte() {
        value=100;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
}
// Pattern Classes
abstract class Factory {
    abstract public Data CreateDataObject();
}
class ByteFactory extends Factory {
    public Data CreateDataObject(){
        return new Byte();
    }
}
//Client classes
class Document {
    Data pd;
    Document(Factory pf){
        pd = pf.CreateDataObject();
    }
    public void DisplayData(){
        pd.DisplayValue();
    }
}
//Test class
public class MyDoc {
    static Document d;
    public static void main(String[] args) {
        d = new Document(new ByteFactory());
        d.DisplayData();
    }
}

• 结果截图

（四）练习

• 使用TDD的方式设计关实现复数类Complex。
• 伪代码

构造函数，将实部，虚部都置为0
构造函数，创建复数对象的同时完成复数的实部，虚部的初始化
设置实部，设置虚部:复数相加、复数相减、复数相乘

• 产品代码

/**
 * Created by zyx on 2018/4/16.
 */
public class Complex {
    // 定义属性并生成getter,setter
    double RealPart;
    double ImagePart;
    // 定义构造函数
    public Complex(){
        RealPart = 0;
        ImagePart = 1;
    }
    public Complex(double R,double I){
        ImagePart = I;
        RealPart = R;
    }

    //Override Object
    public boolean equals(Object obj){
        if(this == obj) {
            return true;
        }
        if(!(obj instanceof Complex)) {
            return false;
        }
        Complex complex = (Complex) obj;
        if(complex.RealPart != ((Complex) obj).RealPart) {
            return false;
        }
        if(complex.ImagePart != ((Complex) obj).ImagePart) {
            return false;
        }

        return true;
    }
    public String toString()   {
        String string = "";
        if (ImagePart > 0)
            string =  RealPart + "+" + ImagePart + "i";
        if (ImagePart == 0)
            string =  RealPart + "";
        if (ImagePart < 0)
            string = RealPart + " " + ImagePart + "i";
        return string;
    }
    // 定义公有方法:加减乘除
    Complex ComplexAdd(Complex a) {
        return  new Complex(RealPart+a.RealPart,ImagePart+a.ImagePart);
    }
    Complex ComplexSub(Complex a) {
        return new Complex(RealPart-a.RealPart,ImagePart-a.ImagePart);
    }
    Complex ComplexMulti(Complex a) {
        return new Complex(RealPart*a.RealPart,ImagePart*a.ImagePart);
    }
    Complex ComplexDiv(Complex a) {
        if(a.RealPart==0||a.ImagePart==0) {
            System.out.println("被减数不能为0");
            return new Complex();
        }

        double d = Math.sqrt(a.RealPart*a.RealPart)+Math.sqrt(a.ImagePart*a.ImagePart);
        return new Complex((RealPart*a.RealPart+ImagePart*a.ImagePart)/d,Math.round((RealPart*a.ImagePart-ImagePart*a.RealPart)/d));
    }
}

• 测试代码

import static org.junit.Assert.*;
import org.junit.Test;
import junit.framework.TestCase;
/**
 * Created by zyx on 2018/4/16.
 */
public class ComplexTest extends TestCase {
    Complex complex = new Complex(1,1);
    @Test
    public void testAdd(){
        assertEquals(new Complex(3.3,3.4), complex.ComplexAdd(new Complex(2.3,2.4)));
    }
    //测试加法
    @Test
    public void testSub(){
        assertEquals(new Complex(-5.3,-2.4), complex.ComplexSub(new Complex(6.3,3.4)));
    }
    //测试减法
    @Test
    public void testMulti(){
        assertEquals(new Complex(3.0,2.0), complex.ComplexMulti(new Complex(3.0,2.0)));
    }
    //测试乘法
    @Test
    public void testDiv(){
        assertEquals(new Complex(1.0,1.0), complex.ComplexDiv(new Complex(1.0,1.0)));
        assertEquals(new Complex(0.0,0.0), complex.ComplexDiv(new Complex(1.0,0.0)));
        //assertEquals(new Complex(0.0,0.0), complex.ComplexDiv(new Complex(3,4)));
        //边缘测试
    }
    @Test
    public void testequals(){
        assertEquals(true, complex.equals(new Complex(1.0,1.0)));
    }
    //测试判断相等
}

• 结果截图

（五）使用StarUML对实验二中的代码进行建模

实验中遇到的问题及解决方法

1. 如何在IDEA中新建一个SourceFolder文件夹？

• 步骤为；
  • 第一步：新建一个普通的文件夹：New->directory
  • 第二步：点击File中的Project Structure
  • 第三步：选择左侧Project Setting 中的Modules
  • 第四步：点击右侧的Sources,然后鼠标移到想要转换的普通文件上点右键，选择resource即可

1. 导入Junit包时不懂老师教程里的方法，找不到idea的lib文件夹

• 解决步骤：
  • 打开我的计算机，在搜索中寻找junit.jar和junit-4.12
  • 搜索到后右键查看属性，点击详细信息，即可找到路经
    
    

1. 在使用UML时，卸载重装了多次后出现
   
   

• 解决步骤：在参考解决StarUML启动时报错问题后
  • 打开电脑中的命令，输入下面命令
    
    
  • 在打开界面中找到下面文件并启动即可
    
    

实验总结

• 这次实验相对上一次内容更多，需要学习的地方更加细化。在看实验教程时，一开始还没有适应这些知识，有些地方比如TDD的方法步骤有些在IDEA中没找到，所以费了些时间，好在还是弄懂了，在以后的学习中也要强化这些花了很长时间才弄懂得部分！

步骤	耗时	百分比
需求分析	10min	10%
设计	15min	15%
代码实现	50min	50%
测试	5min	5%
分析总结	20min	20%

参考资料

• Intellj IDEA 简易教程
• 实验二 Java面向对象程序设计
• 实验二《Java面向对象程序设计》的一点说明