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

实验内容

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

实验步骤

（一）单元测试

伪代码

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

产品代码

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

测试代码

60分测试

public class MyUtilTest {
    public static void main(String[] args) {
    // 百分制成绩是60时应该返回五级制的“及格”
        if(MyUtil.percentage2fivegrade(60) != "及格")
            System.out.println("test failed!");
        else 
            System.out.println("test passed!");
    }
}

测试结果：

输入负分/超过100分

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

测试结果：

增加边界及异常（输入为负分/超过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 "错误";
    }
}

测试代码

public class MyUtilTest {
    public static void main(String[] args) {
    //测试正常情况
    if(MyUtil.percentage2fivegrade(55) != "不及格")
        System.out.println("test failed 1!");
    else if(MyUtil.percentage2fivegrade(65) != "及格")
        System.out.println("test failed 2!");
    else if(MyUtil.percentage2fivegrade(75) != "中等")
        System.out.println("test failed 3!");
    else if(MyUtil.percentage2fivegrade(85) != "良好")
        System.out.println("test failed 4!");
    else if(MyUtil.percentage2fivegrade(95) != "优秀")
        System.out.println("test failed 5!");
    //测试出错情况
    else if(MyUtil.percentage2fivegrade(-1) != "错误")
        System.out.println("test failed 6!");
    else if(MyUtil.percentage2fivegrade(101) != "错误")
        System.out.println("test failed 7!");
    //测试边界情况
    else if(MyUtil.percentage2fivegrade(0) != "不及格")
        System.out.println("test failed 8!");
    else if(MyUtil.percentage2fivegrade(60) != "及格")
        System.out.println("test failed 9!");
    else if(MyUtil.percentage2fivegrade(70) != "中等")
        System.out.println("test failed 10!");
    else if(MyUtil.percentage2fivegrade(80) != "良好")
        System.out.println("test failed 11!");
    else if(MyUtil.percentage2fivegrade(90) != "优秀")
        System.out.println("test failed 12!");
    else if(MyUtil.percentage2fivegrade(100) != "优秀")
        System.out.println("test failed 13!");
    else
        System.out.println("test passed!");
    }
}

测试结果：

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

TDD的一般步骤如下：
明确当前要完成的功能，记录成一个测试列表
快速完成编写针对此功能的测试用例
测试代码编译不通过（没产品代码呢）
编写产品代码
测试通过
对代码进行重构，并保证测试通过（重构下次实验练习）
循环完成所有功能的开发
IDEA TDD 使用：参考Intellj IDEA 简易教程-单元测试;积极主动敲代码，使用JUnit学习Jav
对MyUtil进行单元测试：
TDD的编码节奏是
1. 增加测试代码，JUnit出现红条
2. 修改产品代码
3. JUnit出现绿条，任务完成

（二）面向对象三要素

（1）抽象
"去粗取精、化繁为简、由表及里、异中求同"。抽象就是抽出事物的本质特征而暂时不考虑他们的细节。对于复杂系统问题人们借助分层次抽象的方法进行问题求解；在抽象的最高层，可以使用问题环境的语言，以概括的方式叙述问题的解。在抽象的较低层，则采用过程化的方式进行描述。在描述问题解时，使用面向问题和面向实现的术语。程序设计中，抽象包括两个方面，一是过程抽象，二是数据抽象。

（2）封装、继承与多态
面向对象(Object-Oriented)的三要素包括：封装、继承、多态。过程抽象的结果是函数，数据抽象的结果是抽象数据类型（Abstract Data Type，ADT），类可以作具有继承和多态机制的ADT。数据抽象才是OOP的核心和起源。

OO三要素的第一个要素是封装，封装就是将数据与相关行为包装在一起以实现信息就隐藏。Java中用类进行封装。
封装实际上使用方法(method)将类的数据隐藏起来，控制用户对类的修改和访问数据的程度,从而带来模块化(Modularity)和信息隐藏(Information hiding)的好处；接口（interface）是封装的准确描述手段。

对应代码:

public abstract class Animal {
    private String color;
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public abstract String shout(); 
}
public class Dog extends Animal{
    public String shout(){
        return "汪汪";
    }
       public String toString(){
        return "The Dog's color is " + this.getColor() +", and it shouts "+ this.shout() + "!";
    }
}
public class Cat extends Animal{
    public String shout(){
        return "喵喵";
    }
    public String toString(){
        return "The Cat's color is " + this.getColor() +", and it shouts "+ this.shout() + "!";
    }
}

（三）设计模式初步

（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）模式与设计模式
计算机科学中有很多模式:

GRASP模式
分析模式
软件体系结构模式
设计模式：创建型，结构型，行为型
管理模式： The Manager Pool 实现模式
界面设计交互模式
…
这里面最重要的是设计模式

（3）设计模式实示例

设计模式有四个基本要素：

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

（四）练习

(1)使用TDD的方式设计关实现复数类Complex

伪代码

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

产品代码

 public class Complex {

    private double realPart;
    private double imaginPart;
    public Complex(){
        double realPart;
        double imaginPart;
    }
    public Complex(double r,double i){
        double realPart;
        double imaginPart;
        this.realPart=r;
        this.imaginPart=i;
    }
    public double getRealPart(){
        return realPart;
    }
    public double getImaginPart(){
        return imaginPart;
    }
    public void setRealPart(double d){
        this.realPart=d;
    }

    public void setImaginPart(double d) {
        this.imaginPart =d;
    }
    public void ComplexAdd(Complex c){
        this.realPart+=c.realPart;
        this.imaginPart+=c.imaginPart;
    }
    public void ComplexAdd(double c){
        this.realPart+=c;
    }
    public void ComplexMinus(Complex c){
        this.realPart-=c.realPart;
        this.imaginPart-=c.imaginPart;
    }
    public void ComplexMinus(double c){
        this.realPart-=c;
    }
    public void ComplexMulti(Complex c){
        this.realPart*=c.realPart;
        this.imaginPart*=c.imaginPart;
    }
    public void ComplexMulti(double c){
        this.realPart*=c;
    }

    }

测试代码

import junit.framework.TestCase;

public class ComplexTest extends TestCase {
    Complex c1 = new Complex(3, 5);
    Complex c2 = new Complex(3, 5);
    double a = 5;

    public void testComplexAdd() throws Exception {
        c1.ComplexAdd(c2);
        assertEquals(6.0, c1.getRealPart());
        assertEquals(10.0, c1.getImaginPart());
    }

    public void testComplexMinus() throws Exception {
        c1.ComplexMinus(c2);
        assertEquals(0.0, c1.getRealPart());
        assertEquals(0.0, c1.getImaginPart());

    }

    public void testComplexMulti() throws Exception {
        c1.ComplexMulti(c2);
        assertEquals(9.0, c1.getRealPart());
        assertEquals(25.0, c1.getImaginPart());

    }
}

单元测试运行通过：

(2)用自己的学号（20155330）%6进行取余运算，根据结果进行代码扩充：

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

原代码：

class Integer { 
   int value;    
   public Integer(){
      value=100;  
   }    
   public void DisplayValue(){
        System.out.println(value);  
   } 
} 
class Document { 
   Integer pi; 
   public Document(){
       pi = new Integer(); 
   } 
   public void DisplayData(){
      pi.DisplayValue();  
   } 
} 
public class MyDoc{ 
   static Document d;
   public static void main(String [] args) { 
        d = new Document(); 
        d.DisplayData(); 
  } 
}

修改后的代码：

// 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单元测试部分。不知道出于什么原因在IDEA中使用老师的方法无法下载JUnitGeneratorV2.0.jar文件，最后是在网页JUnitGeneratorV2.0中下载后利用加入本地文件的方式才可以使用。

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

posted @ 2017-04-19 20:31 20155330 阅读(211) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

20155330

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

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

实验内容

实验步骤

（一）单元测试

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

（二）面向对象三要素

（三）设计模式初步

（四）练习

(1)使用TDD的方式设计关实现复数类Complex

(2)用自己的学号（20155330）%6进行取余运算，根据结果进行代码扩充：

实验总结

公告