20145312 实验二《 Java面向对象程序设计》

时间 2019-12-09

原文原文链接

20145312 实验二《 Java面向对象程序设计》

实验内容

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

（一）单元测试
1.三种代码
（1）伪代码：java

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

（2）产品代码与测试代码
例1：编程

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

该产品代码的测试代码（好比输入为负分或大于100的成绩），代码以下：设计模式

public class MyUtilTest2 {
    public static void main(String[] args) {
        //测试出错状况
        if(MyUtil.percentage2fivegrade(-10) != "错误")
            System.out.println("test failed 1!");
        else if(MyUtil.percentage2fivegrade(115) != "错误")
            System.out.println("test failed 2!");
        else
            System.out.println("test passed!");
    }
}

测试结果以下：
数据结构

缘由是判断不及格时没有要求成绩大于零,修改MyUtil.java，增长对负分的判断，代码以下：app

public class MyUtil1 {
    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 "错误";
    }
}

对MyUtil有测试边界状况,对输入为“0，60，70，80，90，100”这些边界状况进行测试的代码以下：编程语言

public class MyUtil1Test1 {
    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!");
    }
}

测试结果以下：
模块化

边界状况中输入100时有错，修改MyUtil.java,把判断优秀的条件中包含输入为100的状况，代码以下：函数

public class MyUtil2 {
    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 "错误";
    }
}

这时再利用刚才的MyUtil1Test1进行测试，获得测试结果以下：
单元测试

（二）面向对象三要素
1.抽象
（1）抽象就是抽出事物的本质特征而暂时不考虑他们的细节，对于复杂系统问题人们借助分层次抽象的方法进行问题求解。
（2）在抽象的最高层，能够使用问题环境的语言，以归纳的方式叙述问题的解。在抽象的较低层，则采用过程化的方式进行描述。
（3）在描述问题解时，使用面向问题和面向实现的术语。
（4）程序设计中，抽象包括两个方面，一是过程抽象，二是数据抽象。过程抽象的结果是函数，数据抽象的结果是抽象数据类型。测试

2.封装、继承与多态
（1）面向对象(Object-Oriented)的三要素包括：封装、继承、多态。
（2）封装实际上使用方法(method)将类的数据隐藏起来，控制用户对类的修改和访问数据的程度,从而带来模块化和信息隐藏的好处。
（3）接口是封装的准确描述手段。
（三）使用UML建模
建模截图以下：

（四）设计模式初步1.S.O.L.I.D原则
面向对象三要素是“封装、继承、多态”，任何面向对象编程语言都会在语法上支持这三要素。如何借助抽象思惟用好三要素特别是多态仍是很是困难的，S.O.L.I.D类设计原则是一个很好的指导。
（1）SRP(Single Responsibility Principle,单一职责原则)
（2）OCP(Open-Closed Principle,开放-封闭原则)
（3）LSP(Liskov Substitusion Principle,Liskov替换原则)
（4）ISP(Interface Segregation Principle,接口分离原则)
（5）DIP(Dependency Inversion Principle,依赖倒置原则)

2.模式与设计模式
（1）模式是某外在环境(Context) 下﹐对特定问题(Problem)的惯用解决之道。
（2）在面向对象中设计模式的地位能够和面向过程编程中的数据结构的地位至关。

（五）练习
1.使用TDD的方式设计关实现复数类Complex。
（1）伪代码：

1. Z = a(实部) + bi（虚部）;
2.相加：实数部与实部相加，虚部与虚部相加
3.相减：实部与实部相减，虚部与虚部相减
4.相乘
A*B=ac-bd+(ad+bc)i
A=a+bi, B=c+di
5.显示一个复数
虚部为负数状况，不显示前面的加号

（2）产品代码

public class Complex{// 1. Z = a(实部) + bi（虚部）;

    private int RealPart;   // 实部
    private int ImaginPart; // 虚部

    public int getRealPart() {
        return RealPart;
    }

    public void setRealPart(int r) {
        RealPart = r;
    }

    public int getImaginPart() {
        return ImaginPart;
    }

    public void setImaginPart(int i) {
        ImaginPart = i;
    }
    // 构造函数
    public Complex() {}
    public Complex(int r, int i) {
        super();
        RealPart = r;
        ImaginPart = i;
    }

    // 相加
    public static String add(Complex a,Complex b){
        Complex temp = new Complex();
        temp.setRealPart(a.getRealPart()+b.getRealPart());
        temp.setImaginPart(a.getImaginPart()+b.getImaginPart());
        return show(temp);
    }

    // 相减
    public static String minus(Complex a,Complex b){
        Complex temp = new Complex();
        temp.setRealPart(a.getRealPart()-b.getRealPart());
        temp.setImaginPart(a.getImaginPart()-b.getImaginPart());
        return show(temp);
    }

    //相乘
//A*B=ac-bd+(ad+bc)i
//A=a+bi, B=c+di
    public static String Multi(Complex a,Complex b){
        Complex temp = new Complex();
        temp.setRealPart((a.getRealPart()*b.getRealPart())-(a.getImaginPart()*b.getImaginPart()));
        temp.setImaginPart((b.getImaginPart()*a.getRealPart())+(b.getRealPart()*a.getImaginPart()));
        return show(temp);
    }



    // 显示输出
    public static String show(Complex a){
        StringBuffer sb = new StringBuffer();
        sb.append(a.getRealPart());
        if(a.getImaginPart()>0){
            sb.append("+"+a.getImaginPart()+"i");
        }else if(a.getImaginPart()<0){
            sb.append(a.getImaginPart()+"i");
        }
        return sb.toString();
    }
}

（3）测试代码：

import static org.junit.Assert.*;
import static org.junit.Assert.assertEquals;

import junit.framework.TestCase;
public class ComplexTest1 extends TestCase{
    public void testNoral(){
        assertEquals("4+1i",Complex.minus(new Complex(4,3),new Complex(0,2) ) );
        assertEquals("5+5i",Complex.add(new Complex(4,3),new Complex(1,2) ) );
        assertEquals("2+8i",Complex.Multi(new Complex(1,1),new Complex(5,3) ) );
    }
    public void testNoral1(){
        assertEquals("4+2i",Complex.minus(new Complex(4,3),new Complex(0,1) ) );
        assertEquals("5+5i",Complex.add(new Complex(3,4),new Complex(2,1) ) );
        assertEquals("2+8i",Complex.Multi(new Complex(1,1),new Complex(5,3) ) );
    }
    public void testNoral2(){
        assertEquals("-3-5i",Complex.minus(new Complex(0,0),new Complex(3,5) ) );
        assertEquals("13+12i",Complex.add(new Complex(6,7),new Complex(7,5) ) ) ;
        assertEquals("0",Complex.Multi(new Complex(0,0),new Complex(3,5) ) );
    }
}

测试结果以下：

4）建模截图以下：