20155317 实验二 Java面向对象程序设计

实验内容

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

实验步骤

单元测试

1.三种代码：伪代码、产品代码、测试代码。我们应该先写伪代码->再用特定编程语言翻译成产品代码->最后写测试代码，验证自己的代码有没有问题。
(1)伪代码

百分制转五分制：

如果成绩小于60，转成“不及格”

如果成绩在60与70之间，转成“及格”

如果成绩在70与80之间，转成“中等”

如果成绩在80与90之间，转成“良好”

如果成绩在90与100之间，转成“优秀”

其他，转成“错误”

(2)产品代码

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

        }

    }

(3)测试代码

分段测试时：

public void testNormal1() {
    assertEquals("不及格", MyUtil.percentage2fivegrade(55));
    assertEquals("及格", MyUtil.percentage2fivegrade(65));
    assertEquals("中等", MyUtil.percentage2fivegrade(75));
    assertEquals("良好", MyUtil.percentage2fivegrade(85));
    assertEquals("优秀", MyUtil.percentage2fivegrade(95));
}

输入负分或大于100时：

public void testNormal2() {
    assertEquals("错误", MyUtil.percentage2fivegrade(-55));
    assertEquals("错误", MyUtil.percentage2fivegrade(105));
}

测试边界情况：

public void testNormal3() {
    assertEquals("不及格", MyUtil.percentage2fivegrade(0));
    assertEquals("及格", MyUtil.percentage2fivegrade(60));
    assertEquals("中等", MyUtil.percentage2fivegrade(70));
    assertEquals("良好", MyUtil.percentage2fivegrade(80));
    assertEquals("优秀", MyUtil.percentage2fivegrade(90));
    assertEquals("优秀", MyUtil.percentage2fivegrade(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 "错误";

    }

}

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

概念：先写测试代码，然后再写产品代码的开发方法
一般步骤如下：

 明确当前要完成的功能，记录成一个测试列表

 快速完成编写针对此功能的测试用例

 测试代码编译不通过（没产品代码呢）

 编写产品代码

 测试通过

 对代码进行重构，并保证测试通过（重构下次实验练习）

 循环完成所有功能的开发

 TDD模式测试代码的编写和调试结果

在Idea中按照老师所给教程点击进入File-Settings，选择Plugins，搜索Junit，下载junit V2.0

建立TDDDemo,建代码Myutil,Alt+Enter打开小灯笼，建立test

测试代码如下（注意@Test）

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));

    }

}

结果截图

面向对象三要素

1.抽象：去粗取精、化繁为简、由表及里、异中求同。在抽象的最高层，可以使用问题环境的语言，以概括的方式叙述问题的解；在抽象的较低层，则采用过程化的方式进行描述。
2.面向对象(Object-Oriented)的三要素包括：封装、继承、多态。面向对象的思想涉及到软件开发的各个方面，如面向对象分析（OOA）、面向对象设计（OOD）、面向对象编程实现(OOP)。
3.继承
以封装为基础，一个类的定义可以基于另外一个已经存在的类，即子类基于父类，从而实现父类代码的重用。其更为广泛而重要的作用是实现多态。
示例：Dog类和Cat类都有Color属性和相应的setter和getter方法，可以通过继承使其精炼化，把Color属性和相应的setter和getter方法放到父类Animal中。

代码如下

public abstract class Animal {

    private String color;

    public String getColor() {

        return color;

    }

    public void setColor(String color) {

        this.color = color;

    }

    public abstract String shout();

}

 class Dog extends Animal{

    public String shout(){

        return "汪汪";

    }

    public String toString(){

        return "The Dog's color is " + this.getColor() +", and it shouts "+ this.shout() + "!";

    }

}

 class Cat extends Animal{

    public String shout(){

        return "喵喵";

    }

    public String toString(){

        return "The Cat's color is " + this.getColor() +", and it shouts "+ this.shout() + "!";

    }

}

根据TDD建AnimalTest,测试代码为

public class AnimalTest {

    public static void main(String[] args){

    Animal[] arr = {new Dog(),new Cat(),new Cat(),new Dog()};

    for(int i=0; i<arr.length;i++)

        getInfo(arr[i]);

    }

public static void getInfo(Animal a){

        System.out.println(a.toString());

    }

}

UML类图建模

UML是一种通用的建模语言
打开WhiteStarUML

Tools-java1.5-Reverse Engineer，并add所要建模UML的java文件。

run后结果，UML建模图（至少两个类）

一般规则：

+表示public
-表示 private
如果类A中a()方法是抽象方法，那么a()是斜体的，类A是抽象类，所以也是斜体的
UML类图要展示类之间的静态关系，UML中依赖用带箭头的直线表示，例如上例中的Animal类依赖Cat类和Dog类
UML类图中继承的表示法，是用一个带三角的直线指向父类，例如上例中Cat类和Dog类继承Animal类，消除了Dog类和Cat类中的重复代码，符合DRY的要求

设计模式初步

1.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,依赖倒置原则)

2.模式与设计模式：模式是某外在环境(Context) 下﹐对特定问题(Problem)的惯用解决之道(Solution)。计算机科学中有很多模式:

    GRASP模式

    分析模式

    软件体系结构模式

    设计模式：创建型，结构型，行为型

    管理模式： The Manager Pool 实现模式

    界面设计交互模式

3.设计模式实示例：设计模式(design pattern)提供一个用于细化软件系统的子系统或组件，或它们之间的关系图，它描述通信组件的公共再现结构，通信组件可以解决特定语境中的一个设计问题。设计模式有四个基本要素：

    Pattern name：描述模式，便于交流，存档

    Problem：描述何处应用该模式

    Solution：描述一个设计的组成元素，不针对特例

    Consequence：应用该模式的结果和权衡（trade-offs）

伪代码

1）复数类ComplexNumber的属性

realPart: 实部，代表复数的实数部分

imaginPart:　虚部，代表复数的虚数部分

2）复数类ComplexNumber的方法

ComplexNumber()　构造函数，将实部，虚部都置为0

ComplexNumber(double realPart, double imaginPart)　构造函数，创建复数对象的同时完成复数的实部，虚部的初始化

getRealPart()　获取实部

getImaginaryPart()　获取虚部

getRealPart(double realPart)　设置实部

getImaginaryPart(double imaginPart)　设置虚部

ComplexAdd(ComplexNumber c)　   复数相加

ComplexAdd(double realPart2)　  复数相加

ComplexMinus(ComplexNumber c)　 复数相减

ComplexMinus(double realPart2)　复数相减

ComplexMulti(ComplexNumber c)　 复数相乘

ComplexMulti(double realPart2)　复数相乘

toString() 把当前复数对象的实部，虚部组合成a+bi的字符串形式

测试代码

/**
 * Created by wang on 2017/4/20.
 */

   import java.lang.*;
   public class Complex {
        //定义属性并生成getter，setter
        double RealPart;
        double ImagePart;
        public double getRealPart() {
            return RealPart;
        }
        public void setRealPart(double realPart) {
            this.RealPart=realPart;
        }
        public double getImagePart() {
            return ImagePart;
        }
        public void setImagePart(double imagePart) {
            this.ImagePart=imagePart;
        }
        //定义构造函数
        public Complex(double R, double I) {
            RealPart = R;
            ImagePart = I;
        }
        //Override Object
        public boolean equals(Complex obj1) {
            if (this.getRealPart () == obj1.getRealPart () && this.getImagePart () == obj1.getImagePart ())
                return true;
            else return false;
        }
        //定义公有方法：加减乘除
        public String toString() {
            return "第一个"+RealPart + " 第二个" + ImagePart ;
        }
        public Complex ComplexAdd(Complex obj) {
            return new Complex ( RealPart + obj.getRealPart (), ImagePart + obj.getImagePart () );
        }
        public Complex ComplexSub(Complex obj) {
            return new Complex ( RealPart - obj.getRealPart (), ImagePart - obj.getImagePart () );
        }
        public Complex ComplexMulti(Complex obj) {
            return new Complex ( RealPart * obj.getRealPart () - ImagePart * obj.getImagePart (), RealPart * obj.getImagePart () + ImagePart * obj.getRealPart () );
        }
        public Complex ComplexDiv(Complex obj){
            return new Complex ( RealPart / obj.getRealPart () - ImagePart / obj.getImagePart (), RealPart / obj.getImagePart () + ImagePart / obj.getRealPart () );
        }
    }

产品代码

/**
 * Created by wang on 2017/4/20.
 */

   import java.lang.*;
   public class Complex {
        //定义属性并生成getter，setter
        double RealPart;
        double ImagePart;
        public double getRealPart() {
            return RealPart;
        }
        public void setRealPart(double realPart) {
            this.RealPart=realPart;
        }
        public double getImagePart() {
            return ImagePart;
        }
        public void setImagePart(double imagePart) {
            this.ImagePart=imagePart;
        }
        //定义构造函数
        public Complex(double R, double I) {
            RealPart = R;
            ImagePart = I;
        }
        //Override Object
        public boolean equals(Complex obj1) {
            if (this.getRealPart () == obj1.getRealPart () && this.getImagePart () == obj1.getImagePart ())
                return true;
            else return false;
        }
        //定义公有方法：加减乘除
        public String toString() {
            return "第一个"+RealPart + " 第二个" + ImagePart ;
        }
        public Complex ComplexAdd(Complex obj) {
            return new Complex ( RealPart + obj.getRealPart (), ImagePart + obj.getImagePart () );
        }
        public Complex ComplexSub(Complex obj) {
            return new Complex ( RealPart - obj.getRealPart (), ImagePart - obj.getImagePart () );
        }
        public Complex ComplexMulti(Complex obj) {
            return new Complex ( RealPart * obj.getRealPart () - ImagePart * obj.getImagePart (), RealPart * obj.getImagePart () + ImagePart * obj.getRealPart () );
        }
        public Complex ComplexDiv(Complex obj){
            return new Complex ( RealPart / obj.getRealPart () - ImagePart / obj.getImagePart (), RealPart / obj.getImagePart () + ImagePart / obj.getRealPart () );
        }
    }

结果截图

PSP(Personal Software Process)时间

步骤	耗时	百分比
需求分析	10min	8.3%
设计	20min	16.7%
代码实现	30min	25.0%
测试	45min	37.5%
分析总结	15min	12.5%

总结单元测试的好处
（1）对于整个项目来说，有了完整的测试，保证项目最后交付测试有了可靠依据，减少后期维护的精力和费用
（2）对于开发人员来说大大减少调试工作的时间，同时也规范了对于代码安全管理
（3）能够有效优化代码的设计
（4）测试本身是被测代码的用法说明，替代了一部分代码功能，迫使自己要将被测代码设计得更加独立地去完成某个或某几个功能