标签：ati   提示   继承   方便   linu   tchar   设计   快速   art   

实验二 面向对象程序设计

目录

• 一、实验报告封面
• 二、具体实验内容
  • （一）面向对象程序设计-1 初步掌握单元测试和TDD
  • （二）面向对象程序设计-2 以TDD的方式研究学习StringBuffer
  • （三）面向对象程序设计-3 OCP原则和DIP原则的应用
  • （四）面向对象程序设计-4 以TDD的方式开发一个复数类Complex
  • （五）面向对象程序设计-5 对代码进行UML类图建模
• 三、实验总结
• 四、PSP时间

一、实验报告封面

北京电子科技学院（BESTI）

实 验 报 告

实验名称：面向对象程序设计

实验内容：

1.初步掌握单元测试和TDD

2.理解并掌握面向对象三要素：封装、继承、多态

3.初步掌握UML建模

4.熟悉S.O.L.I.D原则

5.了解设计模式

实验要求：

1.没有Linux基础的同学建议先学习《Linux基础入门（新版）》和《Vim编辑器》 课程

2.完成实验、撰写实验报告，实验报告以博客方式发表在博客园，注意实验报告重点是运行结果，遇到的问题(工具查找，安装，使用，程序的编辑，调试，运行等)、解决办法（空洞的方法如“查网络”、“问同学”、“看书”等一律得0分）以及分析（从中可以得到什么启示，有什么收获，教训等）。报告可以参考范飞龙老师的指导

3.严禁抄袭，有该行为者实验成绩归零，并附加其他惩罚措施。

4.请大家先在实验楼中的~/Code目录中用自己的学号建立一个目录，代码和UML图要放到这个目录中，截图中没有学号的会要求重做，然后跟着下面的步骤练习。

返回目录

二、具体实验内容

（一）初步掌握单元测试和TDD

1.参考 http://www.cnblogs.com/rocedu/p/6371315.html#SECUNITTEST 完成单元测试的学习

2.提交最后三个JUnit测试用例（正常情况，错误情况，边界情况）都通过的截图，截图上要有画图加水印，输入自己的学号

3.本提交点考查JUnit会不会使用，测试用例至少要包含正常情况，错误情况，边界情况的测试

（1）实验步骤

• 新建类：MyUtil.java，输入代码

• 新建一个测试用例类：MyUtilTest，输入代码

  Java编程时，程序员对类实现的测试叫单元测试。
  我们一般新建一个XXXXTest的类用作类XXXX的测试模块。
  这种先写测试代码，然后再写产品代码的开发方法叫“测试驱动开发”（TDD）

• 进行基于TDD的JUnit测试

（2）实验代码

• 类MyUtil.java：

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 "错误";
    }
}

• 类MyUtilTest：

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

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(105));
        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));
    }
}

（3）实验截图

• 增加测试代码，JUnit出现红条（显示2个错误）

• 根据提示修改产品代码，JUnit出现绿条，任务完成

返回目录

（二）以TDD的方式研究学习StringBuffer

参考积极主动敲代码，使用JUnit学习Java
以TDD的方式研究学习StringBuffer
提交你的单元测试用例和测试通过的截图，截图要加上学号水印
测试自己会不会写JUnit测试用例

（1）实验步骤

• 编写StringBufferDemo类
• 快速编写测试代码StringBufferDemoTest类
• TDD运行报错、更正代码
• 出现绿条，成功

（2）实验代码

• StringBufferDemo类

public class StringBufferDemo {
    public static void main(String [] args){
        StringBuffer buffer = new StringBuffer();
        buffer.append(‘S‘);
        buffer.append("tringBuffer");
        System.out.println(buffer.charAt(1));
        System.out.println(buffer.capacity());
        System.out.println(buffer.indexOf("tring"));
        System.out.println("buffer = " + buffer.toString());
    }
}

• 测试代码StringBufferDemoTest类

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

import java.lang.management.BufferPoolMXBean;

public class StringBufferDemoTest extends TestCase {
    StringBuffer str=new StringBuffer("StringBuffer");
    @Test
    public void testcharAt (){
        assertEquals(‘S‘,str.charAt(0));
        assertEquals(‘B‘,str.charAt(6));
    }
    @Test
    public void testcapacity(){
        assertEquals(28,str.capacity());
    }
    @Test
    public void testindexof(){
        assertEquals(6,str.indexOf("Buffer"));
    }
    @Test
    public void testtoString(){
        assertEquals("str:StringBuffer","str:"+str.toString());
    }

}

（3）实验截图

返回目录

（三）面向对象程序设计-3 OCP原则和DIP原则的应用

参考http://www.cnblogs.com/rocedu/p/4472842.html
对设计模式示例进行扩充，体会OCP原则和DIP原则的应用，初步理解设计模式
用自己的学号%6进行取余运算，根据结果（结果是5）进行代码扩充：
5： 让系统支持Double类，并在MyDoc类中添加测试代码表明添加正确，提交测试代码和运行结的截图，加上学号水印

（1）实验步骤

• 对设计模式示例进行扩充，扩充出Double和DoubleFactory

（2）实验代码

abstract class Data {
    abstract public void DisplayValue();
}

class Double extends Data{
    double value;

    Double(){
        value=5;
    }
    public void DisplayValue(){
        System.out.println(value);
    }
}

abstract class Factory {
    abstract public Data CreateDataObject();
}

class DoubleFactory extends Factory{
    public Data CreateDataObject(){
        return new Double();
    }
}

class Document {
    Data pd;
    Document(Factory pf){
        pd = pf.CreateDataObject();
    }
    public void DisplayData(){
        pd.DisplayValue();
    }
}

public class MyDoc {
    static Document d;
    public static void main(String[] args) {
        d = new Document(new DoubleFactory());
        d.DisplayData();
    }
}

（3）实验截图

返回目录

（四）面向对象程序设计-4 以TDD的方式开发一个复数类Complex

参考http://www.cnblogs.com/rocedu/p/6736847.html
任务：以TDD的方式开发一个复数类Complex

（1）实验步骤

• 定义属性并生成getter,setter

  double RealPart;
  double ImagePart;

• 定义构造函数

  public Complex()
  public Complex(double R,double I)

• Override Object

  public boolean equals(Object obj)
  public String toString()

• 定义公有方法:加减乘除

  Complex ComplexAdd(Complex a)
  Complex ComplexSub(Complex a)
  Complex ComplexMulti(Complex a)
  Complex ComplexDiv(Complex a)

（2）实验代码

• Complex类

public class Complex {

    private double RealPart;
    private double ImagePart;

    public Complex() {

    }

    public Complex(double R, double I) {
        this.RealPart = R;
        this.ImagePart = I;
    }

    public double getRealPart() {
        return RealPart;
    }

    public void setRealPart(double realPart) {
        RealPart = realPart;
    }

    public double getImagePart() {
        return ImagePart;
    }

    public void setImagePart(double imagePart) {
        ImagePart = imagePart;
    }

    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, ImagePart * a.RealPart + RealPart * a.ImagePart);
    }

    Complex ComplexDiv(Complex a) {
        Complex d = new Complex();
        d.RealPart = (this.RealPart * a.RealPart + this.ImagePart * a.ImagePart) / (a.RealPart * a.RealPart + a.ImagePart * a.ImagePart);
        d.ImagePart = (this.ImagePart * a.RealPart - this.RealPart * a.ImagePart) / (a.RealPart * a.RealPart + a.ImagePart * a.ImagePart);
        return d;

    }
}

• 测试代码ComplexTest类

import org.junit.*;
import static org.junit.Assert.*;
public class ComplexTest {
    Complex a = new Complex(0, 2);
    Complex b = new Complex(2, -1);
    @Test
    public void testAdd() {
        assertEquals("2.0+1.0i", a.ComplexAdd(b).toString());
        System.out.println(a.ComplexAdd(b));
    }
    @Test
    public void testSub() {
        assertEquals("-2.0+3.0i", a.ComplexSub(b).toString());
        System.out.println(a.ComplexSub(b));
    }
    @Test
    public void testMulti() {
        assertEquals("2.0+4.0i", a.ComplexMulti(b).toString());
        System.out.println(a.ComplexMulti(b));
    }
    @Test
    public void testDiv() {
        assertEquals("-0.4+0.8i", a.ComplexDiv(b).toString());
        System.out.println(a.ComplexDiv(b));
    }
}

（3）实验截图

返回目录

（五）面向对象程序设计-5 对代码进行UML类图建模

使用WhiteStarUML对实验二中的代码（选其一）进行建模，发类图的截图，加上学号水印。
参考http://www.cnblogs.com/rocedu/p/6736847.html，类图中至少有两个类。

（1）实验步骤

• 打开StarUML，选择对MyDoc.java进行UML类图建模
• 注意MyDoc中各变量和方法的名字

（2）实验截图

返回目录

三、实验总结

• 遇到的问题：

刚开始使用TDD测试代码的时候还不太熟练，看到出现红条后一位运行失败了，仔细参考老师所给教程后得知可以直接在测试代码上进行修改，只需要看下端提示栏中显示的错误，就能直接点击跳转过去，并且按照给出的结论修改代码即可最终成功。另外还要查缺补漏，将各种可能性都包含在内，才能将代码进一步完善。

• 分析与总结：

这次实验蛮难的……涉及到的内容也挺多，主要是新增了单元测试和TDD的使用，从未接触过有些措手不及，所以刚开始的时候犯了挺多错误做了无用功。后来跟着教程了解到快速创建测试代码test的方法，发现IDEA真的很方便啊，增添了测试用例的使用就能更快的找出错误的地方，还能自动报错，直接帮你指出错误应该怎么修改，只需要动动手改正就行。这个实验考验了我的思维能力，毕竟要想使自己的代码显得完美无缺，就要将方方面面的漏洞都考虑到，再加上测试代码这个辅助，才能在有效时间里高效的操作，更正，完善带密码。当然以后也希望能用上这个方法对代码进行检查，特别是长代码就更需要机器帮忙识别报错了。

• 参考资料：

1. Intellj IDEA 简易教程-单元测试
2. 实验二《Java面向对象程序设计》的一点说明
3. 积极主动敲代码，使用JUnit学习Java
4. 实验二 Java面向对象程序设计

返回目录

四、PSP时间

返回目录

20165223 实验四 Android开发基础

标签：ati   提示   继承   方便   linu   tchar   设计   快速   art   

原文地址：https://www.cnblogs.com/moddy13162201/p/9065125.html