2016-2017-2 20155326实验二《Java面向对象程序设计》实验报告

时间  2019-11-08
标签 实验 Java面向对象程序设计 报告 栏目 Java 繁體版
原文   原文链接

2016-2017-2 20155326实验二《Java面向对象程序设计》实验报告

实验内容

初步掌握单元测试和TDDjava

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

初步掌握UML建模编程

熟悉S.O.L.I.D原则设计模式

了解设计模式编程语言

实验要求

1.参考Intellj IDEA 简易教程
提交最后三个测试用例都经过的截图，截图上要有画图加水印，输入本身的学号。模块化

2.参考 积极主动敲代码使用JUnit学习Java,以 TDD的方式研究学习StringBuffer，提交你的单元测试用例和测试经过的截图，截图要加上学号水印。函数

3.实验二 Java面向对象程序设计工具

对设计模式示例进行扩充，体会OCP原则和DIP原则的应用，初步理解设计模式用本身的学号%6进行取余
运算，根据结果进行代码扩充：单元测试

让系统支持Boolean类，并在MyDoc类中添加测试代码代表添加正确学习

4.以TDD的方式开发一个复数类Complex支持加减乘除。

5.使用StarUML对实验二中的代码进行建模，发类图的截图，加上学号水印。类图中至少两个类。

实验步骤

（一）单元测试

编程是智力活动，不是打字，编程前要把干什么、如何干想清楚才能把程序写对、写好。因此当想用程序解决问题时，要会写三种码：伪代码、产品代码、测试代码。
  • 伪代码

  • 产品代码

  • 测试代码

基本了解三种代码后，开始编译各类测试代码测试程序是不是彻底正确的。测试及结果以下图：

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

TDD的通常步骤以下：

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

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

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

编写产品代码

测试经过

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

循环完成全部功能的开发

基于TDD，咱们不会出现过分设计的状况，需求经过测试用例表达出来了，咱们的产品代码只要让测试经过就能够了。

基本了解完TDD后开始进行实验，实验结果以下图所示：

（三）面向对象三要素：封装、继承、多态

（1）抽象

抽象一词的本意是指人在认识思惟活动中对事物表象因素的舍弃和对本质因素的抽取。抽象是人类认识复琐事物和现象时常用的思惟工具，抽象思惟能力在程序设计中很是重要，"去粗取精、化繁为简、由表及里、异中求同"的抽象能力很大程度上决定了程序员的程序设计能力。

抽象就是抽出事物的本质特征而暂时不考虑他们的细节。对于复杂系统问题人们借助分层次抽象的方法进行问题求解；在抽象的最高层，可使用问题环境的语言，以归纳的方式叙述问题的解。在抽象的较低层，则采用过程化的方式进行描述。在描述问题解时，使用面向问题和面向实现的术语。

程序设计中，抽象包括两个方面，一是过程抽象，二是数据抽象。
咱们举个例子说明一下。好比有了如下Java代码：

System.out.println(1);

System.out.println(2);

System.out.println(3);

能够打印出“1,2,3”，想打引“1,2,3,4”怎么办？同窗们的作法大可能是把上面的代码拷贝下来，再加一行：

System.out.println(1);

System.out.println(2);

System.out.println(3);

System.out.println(4);

这就是没有学会过程抽象的作法“拷贝粘贴”式开发。解决问题没？解决了，但有问题，好比想打印出“1..100"怎么办？粘贴100行？这两段代码有三行重复的代码，违反了常见的一个编程原则DRY(Don't Repeat Yourself)，解决的方法是进行过程抽象，写一个函数printn：

public void printn(int n){
    for(int i=1;  i<=n; i++)
        System.out.println(n);
}

上面两段代码就能够用;

printn(3);
printn(4);

代替了，打印出“1..100"也很简单，只要调用printn(100);就好了。

  • 面向对象(Object-Oriented)的三要素包括：封装、继承、多态。

面向对象的思想涉及到软件开发的各个方面，如面向对象分析（OOA）、面向对象设计（OOD）、面向对象编程实现(OOP)。OOA根据抽象关键的问题域来分解系统，关注是什么（what）。OOD是一种提供符号设计系统的面向对象的实现过程，用很是接近问题域术语的方法把系统构形成“现实世界”的对象，关注怎么作（how）,经过模型来实现功能规范。OOP则在设计的基础上用编程语言（如Java）编码。贯穿OOA、OOD和OOP的主线正是抽象。

OOD中建模会用图形化的建模语言UML（Unified Modeling Language）,UML是一种通用的建模语言，咱们实验中使用umbrello进行建模，Windows中推荐你们使用 StarUML。

过程抽象的结果是函数，数据抽象的结果是抽象数据类型（Abstract Data Type，ADT），类能够做具备继承和多态机制的ADT。数据抽象才是OOP的核心和起源。

OO三要素的第一个要素是封装，封装就是将数据与相关行为包装在一块儿以实现信息就隐藏。

封装实际上使用方法(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 Cat extends Animal{
    public String shout(){
        return "喵喵";
    }
    public String toString(){
        return "The Cat's color is " + this.getColor() +", and it shouts "+ this.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() + "!";
    }
}
  • 用UML展现

  • 设计模式

S.O.L.I.D原则
SRP(Single ResponsibilityPrinciple,单一职责原则)
OCP(Open-Closed Principle,开放-封闭原则)
LSP(Liskov Substitusion Principle,Liskov替换原则)
ISP(Interface Segregation Principle,接口分离原则)
DIP(Dependency Inversion Principle,依赖倒置原则)
设计模式：建立型，结构型，行为型
设计模式实例
让系统支持Boolen类

代码以下：

abstract class Data{
    public abstract void DisplayValue();
}
class Integer extends Data {
    int value;
    Integer(){
        value=100;
    }
    public void DisplayValue(){
        System.out.println(value);
    }
}
class Boolean extends Data{
    boolean value;

    Boolean(){
        value=false;
    }

    public void DisplayValue(){

        if(value)
        {
            System.out.println("20155326true");
        }
        else {
            System.out.println("20155326false");
        }
    }
}
class Document {
    Data pd;
    Document() {
        pd=new Boolean();
    }
    public void DisplayData(){
        pd.DisplayValue();
    }
}
public class MyDoc {
    static Document d;
    public static void main(String[] args) {
        d = new Document();
        d.DisplayData();
    }
}

运行结果：

练习

使用TDD的方式设计关实现复数类Complex。

  • 伪代码

Complex类

定义实部以及虚部；

方法Set设置实部,以及虚部：public double setRealPart()，public double setImagePart();

方法Get取得实部，以及虚部：public double getRealPart()，public double getImagePart();

方法加法Complex ComplexAdd(Complex a)

方法减法Complex ComplexSub(Complex a)

方法乘法Complex ComplexMultib(Complex a)

方法除法Complex ComplexDiv(Complex a)

方法toString()控制输出格式

  • 产品代码
import java.util.Scanner;
public class Complex {
    static int r;
    static int i;
    private double a;
    private double b;
    public static int getRealPart(int RealPart){
            r = RealPart;
        return r;
    }
    public static int getImaginePart(int ImaginePart){
            i = ImaginePart;
        return i;
    }
    public Complex(double a, double b) {
        this.a = a;
        this.b = b;
    }
    public Complex add(Complex c) { 
        return new Complex(a + c.a, b + c.b);
    }
    public Complex minus(Complex c) {    
        return new Complex(a - c.a, b - c.b);
    }
    public Complex multiply(Complex c) {
        return new Complex(a * c.a - b * c.b, a * c.b + b * c.a);
    }
    public String toString() {
        String rtr_str = "";
        if (a > 0)
            rtr_str = "(" + a + "+" + b + "i" + ")";
        if (b == 0)
            rtr_str = "(" + a + ")";
        if (b < 0)
            rtr_str = "(" + a + b + "i" + ")";
        return rtr_str;
    }
}
  • 测试代码
import junit.framework.TestCase;
import org.junit.Test;
import static org.junit.Assert.*;
public class ComplexTest extends TestCase {
        Complex a=new Complex(1,2);
        Complex d=new Complex(0,-1);
        Complex e=new Complex(0,0); 
        @Test
        public void testgetRealPart() throws Exception {
            assertEquals(1, Complex.getRealPart(1));
            assertEquals(-1, Complex.getRealPart(-1));
            assertEquals(0, Complex.getRealPart(0));
        }
        @Test
        public void testgetImaginePart() throws Exception {
            assertEquals(1, Complex.getImaginePart(1));
            assertEquals(-1, Complex.getImaginePart(-1));
            assertEquals(2, Complex.getImaginePart(2));
            assertEquals(0, Complex.getImaginePart(0));
        }
        @Test
        public void testadd() throws Exception {
            assertEquals("(1.0-1.0i)", a.add(d).toString());
            assertEquals("(1.0+2.0i)", a.add(e).toString());
        }
        @Test
        public void testminus() throws Exception {
            assertEquals("(1.0+5.0i)", a.minus(b).toString());
            assertEquals("(1.0+2.0i)", a.minus(c).toString());
        }
        @Test
        public void testmultiply() throws Exception {
            assertEquals("(9.0-2.0i)", a.multiply(b).toString());
            assertEquals("(19.0-38.0i)", a.multiply(b).toString());
            assertEquals("(6.0-3.0i)", a.multiply(b).toString());
            assertEquals("(0.0)", a.multiply(e).toString());
        }
    }
  • 测试结果

分析总结：

此次的实验比较复杂，涉及的内容较多，这周大部分的时间都花在了作实验上，中途遇到的问题也都找同窗解决了。

PSP(Personal Software Process)时间

| 步骤 | 耗时 | 百分比 | | 需求分析 | 50min | 18.5% | | 设计 | 120min | 44.4% | | 代码实现 | 30min | 11.1% | 测试 | 40min | 14.8% | | 分析总结 | 30min | 11.1% |

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程