2018-2019-2 20175207 实验二《面向对象程序设计》实验报告

目录
==========
- IDEA中下载并配置单元测试工具JUnit

- [使用Junit学JAVA](#jump2)

- [TDD](#jump3)

- [S.O.L.I.D原则](#jump4)

- [实验总结](#jump5)

IDEA中下载并配置单元测试工具JUnit（虚拟机中）

下载
- File -> Settings或Ctrl + Alt + S进入Settings页面，点击Plugins，在搜索框内输入junit，找到对应的工具并下载。
- 找到IDEA的安装路径，->Plugins->junit解压
配置
- 找到junit.jar的路径
- File -> Project Structure -> Dependancies -> + -> JARs or Directories
- 添加junit.jar
- 勾选junit.jar和junit4-12.jar
- 保存并退回
应用
- 新建一个项目，建一个空类
- 右击类名，Go To -> test -> Creat New Test
- Testing Library选择JUnit3并勾选Member下所有选项
- 点击项目名，右击New -> Directory -> 输入Test
- 右击Test文件夹，Mark Directory as -> Test Sources Rood
回到顶端

使用JUnit学JAVA

任务一：对MyUtil类进行测试，测试用例至少要包含正常情况，错误情况，边界情况的测试。

伪代码

百分制转五分制：
如果成绩小于60，转成“不及格”
如果成绩在60与70之间，转成“及格”
如果成绩在70与80之间，转成“中等”
如果成绩在80与90之间，转成“良好”
如果成绩在90与100之间，转成“优秀”
其他，转成“错误”

产品代码

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 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 testExceptions(){
        assertEquals("错误",MyUtil.percentage2fivegrade(-55));
        assertEquals("错误",MyUtil.percentage2fivegrade(105));
    }
    @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的方式研究学习StringBuffer。

产品代码

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;

public class StringBufferDemoTest extends TestCase {
    StringBuffer a1 = new StringBuffer("StringBuffer");
    StringBuffer a2 = new StringBuffer("StringBufferStringBuffer");
    StringBuffer a3 = new StringBuffer("StringBuffer used by 20175215");
    @Test
    public void testCharAt() throws Exception{//验证返回是否是整个字符串中的第x个字符
        assertEquals('S',a1.charAt(0));
        assertEquals('t',a2.charAt(13));
        assertEquals('b',a3.charAt(18));
    }
    @Test
    public void testcapacity() throws Exception{//验证容量
        assertEquals(28,a1.capacity());
        assertEquals(40,a2.capacity());
        assertEquals(45,a3.capacity());
    }
    @Test
    public void testlength() throws Exception{//验证字符串的长度
        assertEquals(12,a1.length());
        assertEquals(24,a2.length());
        assertEquals(29,a3.length());
    }
    @Test
    public void testindexOf(){//验证所在位置
        assertEquals(6,a1.indexOf("Buff"));
        assertEquals(1,a2.indexOf("tring"));
        assertEquals(25,a3.indexOf("5215"));
    }
}

测试成功截图：

任务三：对设计模式示例进行扩充，体会OCP原则和DIP原则的应用。测试让系统支持Short类，并在MyDoc类中添加测试代码表明添加正确。

产品代码

abstract class Data {
    abstract public void DisplayValue();
}
class Integer extends  Data {
    int value;
    Integer() {
        value=100;
    }
    @Override
    public void DisplayValue(){
        System.out.println (value);
    }
}
class Short extends  Data {
    int value;
    Short() {
        value=5;
    }
    @Override
    public void DisplayValue(){
        System.out.println (value);
    }
}
abstract class Factory {
    abstract public Data CreateDataObject();
}
class IntFactory extends Factory {
    @Override
    public Data CreateDataObject(){
        return new Integer();
    }
}
class ShortFactory extends Factory {
    @Override
    public Data CreateDataObject(){
        return new Short();
    }
}
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 IntFactory());
        d.DisplayData();
        d = new Document(new ShortFactory());
        d.DisplayData();
    }
}

测试成功截图：

任务四：以TDD的方式开发一个复数类Complex。

产品代码

import java.text.DecimalFormat;//引入DecimalFormat包取一位整数和一位小数

public class Complex {
    double Real=0;
    double Imaginary=0;
    public Complex(){}
    public Complex(double Real,double Imaginary){
        this.Real=Real;
        this.Imaginary=Imaginary;

    }
    public double getReal(){
        return Real;
    }
    public double getImaginary(){
        return Imaginary;
    }
    public String toString(){
        String s = "";
        double r=Real;
        double i=Imaginary;
        if(r==0&&i==0){
            s="0";
        }
        else if(r==0&&i!=0){
            s=i+"i";
        }
        else if(r!=0&&i<0){
            s=r+""+i+"i";
        }
        else if(r!=0&&i==0){
            s=r+"";
        }
        else
        {
            s=r+"+"+i+"i";
        }
        return s;
    }
    public boolean equals(Object obj){//重写equals方法，使其不用来对比字符序列
        if(this==obj){
            return true;
        }
        else
            return false;
    }
    DecimalFormat df = new DecimalFormat( "0.0");
    public Complex ComplexAdd(Complex a){
        return new Complex(Real+a.getReal(),Imaginary+a.getImaginary());
    }
    public Complex ComplexSub(Complex a){
        return new Complex(Real-a.getReal(),Imaginary-a.getImaginary());
    }
    public Complex ComplexMulti(Complex a){
        double r=Real*a.getReal()-Imaginary*a.getImaginary();
        double i =Imaginary*a.getReal()+Real*a.getImaginary();
        return new Complex(Double.valueOf(df.format(r)),Double.valueOf(df.format(i)));
    }
    public Complex ComplexDiv(Complex a){
        double r=(Real * a.Imaginary + Imaginary * a.Real) / (a.Imaginary * a.Imaginary + a.Real * a.Real);
        double i=(Imaginary * a.Imaginary + Real * a.Real) / (a.Real * a.Real + a.Real * a.Real);
        return new Complex(Double.valueOf(df.format(r)),Double.valueOf(df.format(i)));
    }
}

测试代码

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

public class ComplexTest extends TestCase {
    Complex a1 =new Complex(3.0,4.0);
    Complex a2 =new Complex( 2.0,-4.0);
    Complex a3 =new Complex(0.0,0.0);
    Complex a4 =new Complex(-3.0,0.0);
    Complex a5 =new Complex(-6.0,-0.8);
    @Test
    public void testgetRealPart()throws Exception{
        assertEquals(3.0,a1.getReal());
        assertEquals(2.0,a2.getReal());
        assertEquals(0.0,a3.getReal());
        assertEquals(-3.0,a4.getReal());
        assertEquals(-6.0,a5.getReal());
    }
    @Test
    public void testgetImagePart()throws Exception{
        assertEquals(4.0,a1.getImaginary());
        assertEquals(-4.0,a2.getImaginary());
        assertEquals(0.0,a3.getImaginary());
        assertEquals(0.0,a4.getImaginary());
        assertEquals(-0.8,a5.getImaginary());

    }
    @Test
    public void testtoString()throws Exception{
        assertEquals("3.0+4.0i",a1.toString());
        assertEquals("2.0-4.0i",a2.toString());
        assertEquals("0",a3.toString());
        assertEquals("-3.0",a4.toString());
        assertEquals("-6.0-0.8i",a5.toString());
    }
    @Test
    public void testComplexAdd()throws Exception{
        assertEquals("5.0",a1.ComplexAdd(a2).toString());
        assertEquals("2.0-4.0i",a2.ComplexAdd(a3).toString());
        assertEquals("-3.0",a3.ComplexAdd(a4).toString());
    }
    @Test
    public void testComplexSub()throws Exception{
        assertEquals("1.0+8.0i",a1.ComplexSub(a2).toString());
        assertEquals("-2.0+4.0i",a3.ComplexSub(a2).toString());
        assertEquals("3.0",a3.ComplexSub(a4).toString());
    }
    @Test
    public void testComplexMulti()throws Exception{
        assertEquals("22.0-4.0i",a1.ComplexMulti(a2).toString());
        assertEquals("0",a2.ComplexMulti(a3).toString());
        assertEquals("18.0+2.4i",a4.ComplexMulti(a5).toString());
    }
    @Test
    public void testComplexDiv()throws Exception{
        assertEquals("-0.2-1.2i",a1.ComplexDiv(a2).toString());
        assertEquals("0",a3.ComplexDiv(a2).toString());
    }
    @Test
    public void testequals()throws Exception{
        assertEquals(true,a1.equals(a1));
        assertEquals(false,a1.equals(a2));

    }
}

测试成功截图：

TDD原则

测试驱动开发所遵循的三个基本原则如下：

除非能让失败的单元测试通过，否则不允许去编写任何的产品代码。
- 对于任何功能需求，都是先从写测试用例入手，为满足测试用例才能去写产品代码。
只允许编写刚好能够导致失败的单元测试。（编译失败也属于一种失败）
- 通常在开发完成后写的测试用例都是希望能通过的测试用例，很可能因先入为主导致不能正确覆盖测试。相反，TDD编写新的测试用例是为了覆盖不同的需求，导致失败。
只允许编写刚好能够使一个失败的单元测试通过的产品代码。
- 编写的生产代码只能是为了使一个失败的单元测试通过，不应编写多余的实现代码。如果过多编写了实现其他功能业务的代码，则违反了TDD的原则。

测试驱动开发基本流程：

编写单元测试 --> 运行单元测试-失败显示红色
编写生产代码 --> 运行单元测试显示绿色
重构代码 -->运行单元测试保证通过

S.O.L.I.D原则

SRP(Single Responsibility Principle,单一职责原则)

OCP(Open-Closed Principle,开放-封闭原则)

LSP(Liskov Substitusion Principle,Liskov替换原则)

ISP(Interface Segregation Principle,接口分离原则)

DIP(Dependency Inversion Principle,依赖倒置原则)

模式与设计模式
模式是某外在环境(Context) 下﹐对特定问题(Problem)的惯用解决之道(Solution)。模式必须使得问题明晰，阐明为什么用它来求解问题，以及在什么情况下有用，什么情况下不能起作用，每个模式因其重复性从而可被复用，本身有自己的名字，有可传授性，能移植到不同情景下。模式可以看作对一个问题可复用的专家级解决方法。计算机科学中有很多模式:
GRASP模式
分析模式
软件体系结构模式
设计模式：创建型，结构型，行为型
管理模式： The Manager Pool 实现模式
界面设计交互模式
…
设计模式实示例
设计模式可以帮我们以最好的方式来设计系统。设计模式背后是抽象和SOLID原则。
- 设计模式有四个基本要素：
  - Pattern name：描述模式，便于交流，存档
  - Problem：描述何处应用该模式
  - Solution：描述一个设计的组成元素，不针对特例
  - Consequence：应用该模式的结果和权衡（trade-offs）
回到顶端

实验总结

PSP(Personal Software Process)

步骤	耗时	百分比
需求分析	5	5%
设计	10	9%
代码实现	25	23%
测试	30	27%
分析总结	40	36%

相关阅读:
数据库连接（join）
Linux top
Game2048
黑豆白豆问题
 1000个苹果10箱
 Jconsole
八数码 Java实现
 两数之和
 磁盘调度算法
 常见应用网络层次
原文地址：https://www.cnblogs.com/ln-0407/p/10742942.html