2018-2019-2 20175204 张湲祯 实验二《Java面向对象程序设计》实验报告

2018-2019-2-20175204 张湲祯 实验二 《Java开发环境的熟悉》实验报告

---

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

一.实验内容：

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

---

二.实验步骤：

1.单元测试

1.在 IDEA中我们把产品代码放在src目录中，把测试代码放在test目录中，右键单击项目，在弹出的菜单中选择New->Directory新建一个目录：test。

2.再右键点击设置环境变量，选择Mark Directory->Test Sources Root。

3.根据实验内容代码进行测试，分别对“正常情况”、“边界情况”、“异常情况”进行检验 。

正常情况：



边界情况：



异常情况：



4.根据实验内容代码对自己代码进行修改，是检验结果通过。

---

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

1.这种先写测试代码，然后再写产品代码的开发方法叫“测试驱动开发”（TDD）。

2.TDD的一般步骤如下：

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

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

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

编写产品代码

测试通过

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

循环完成所有功能的开发。

3.下载并配置Junit

1）IDEA中使用JUnit要安装插件，选择File->Setting打开设置对话框。

2）在设置对话框中选择Plugins, 单击Install JetBrains plugin...按钮打开插件安装界面。

3）在插件安装对话框的搜索中输入junit,单击JunitGenerator V2.0,单击右边绿色的Install1按钮安装。

4）安装完之后重启idea。

4.使用junit

1）点击File->Project Structure进入配置界面

2）点击加号，点击依赖，在路径中选择你安装IDEA的路径，找到lib文件夹，应用junit



3）点击你要测试的类名，再点击右侧的小灯泡，然后点击新建测试Create Test这里选择Junit3，下面选择你要测试的方法。



4）添加正常测试、边界测试、异常测试，注意测试用例前一定要有注解@Test，使用assertEquals语句测试实际结果与预期结果是否一致。



5）根据实验内容更改实验代码，并进行测试

---

3.以 TDD的方式研究学习StringBuffer

1）根据实验要求写实验测试代码

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

public class StringBufferDemoTest extends TestCase {
    StringBuffer a = new StringBuffer("StringBuffer");
    StringBuffer b = new StringBuffer("StringBufferStringBuffer");
    StringBuffer c = new StringBuffer("StringBufferStringBufferStringBuffer");
    @Test
    public void testcharAt() throws Exception {
        assertEquals('S',a.charAt(0));
        assertEquals('g',a.charAt(5));
        assertEquals('r',a.charAt(11));
    }
    @Test
    public void testcapacity() throws Exception {
        assertEquals(28,a.capacity());
        assertEquals(40,b.capacity());
        assertEquals(52,c.capacity());
    }
    @Test
    public void testlength() throws Exception {
        assertEquals(12,a.length());
        assertEquals(24,b.length());
        assertEquals(36,c.length());
    }
    @Test
    public void testindexOf() throws Exception {
        assertEquals(0,a.indexOf("Str"));
        assertEquals(5,a.indexOf("gBu"));
    }
}

2）并进行测试



3）利用API查出capacity(),length()方法的功能。

---

4.面向对象三要素

1.抽象

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

2.封装、继承与多态

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

OOD中建模会用图形化的建模语言UML（Unified Modeling Language）,UML是一种通用的建模语言。过程抽象的结果是函数，数据抽象的结果是抽象数据类型（Abstract Data Type，ADT），类可以作具有继承和多态机制的ADT。数据抽象才是OOP的核心和起源。

3.设计模式初步

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,依赖倒置原则) 高层模块不应该依赖于低层模块。二者都应该依赖于抽象,抽象不应该依赖于细节,细节应该依赖于抽象.

模式与设计模式

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

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

Problem：描述何处应用该模式

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

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

其他面对对象原则

"组合替代继承":这是说相对于继承，要更倾向于使用组合；

"笛米特法则"：这是说"你的类对其它类知道的越少越好"；

"共同封闭原则"：这是说"相关类应该打包在一起"；

"稳定抽象原则"：这是说"类越稳定，越应该由抽象类组成";

---

5.让系统支持Float类，并在MyDoc类中添加测试代码表明添加正确.

1.实验代码

abstract class Data {
        abstract public void DisplayValue();
    }
    class Integer extends  Data {
        int value;
        Integer() {
            value=100;
        }
        public void DisplayValue(){
            System.out.println (value);
        }
    }
    class Float extends Data{       //float类
        float value;
        Float(){
            value=(float)66.66;
        }
        public void DisplayValue(){
            System.out.println(value);
        }
    }
    abstract class Factory {
        abstract public Data CreateDataObject();
    }
    class IntFactory extends Factory {
        public Data CreateDataObject(){
            return new Integer();
        }
    }
    class FloatFactory extends Factory{
        public Data CreateDataObject(){
            return new Float();
        }
    }
    class Document {
        Data pd;
        Document(Factory pf){
            pd = pf.CreateDataObject();
        }
        public void DisplayData(){
            pd.DisplayValue();
        }
    }
    //Test class
    public class MyDoc {
        static Document d;
        static Document e;
        public static void main(String[] args) {
            d = new Document(new IntFactory());
            d.DisplayData();
            e=new Document(new FloatFactory());
            e.DisplayData();

        }
    }

2.运行截图

---

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

1.测试代码

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

import static junit.framework.TestCase.assertEquals;

public class ComplexTest extends TestCase {
    Complex c1 = new Complex(0, 3);
    Complex c2 = new Complex(-1, -1);
    Complex c3 = new Complex(2,1);
    @Test
    public void testgetRealPart() throws Exception {
        assertEquals(-1.0, Complex.getRealPart(-1.0));
        assertEquals(5.0, Complex.getRealPart(5.0));
        assertEquals(0.0, Complex.getRealPart(0.0));
    }
    @Test
    public void testgetImagePart() throws Exception {
        assertEquals(-1.0, Complex.getImagePart(-1.0));
        assertEquals(5.0, Complex.getImagePart(5.0));
        assertEquals(0.0, Complex.getImagePart(0.0));
    }
    @Test
    public void testComplexAdd() throws Exception {
        assertEquals("-1.0+2.0i", c1.ComplexAdd(c2).toString());
        assertEquals("2.0+4.0i", c1.ComplexAdd(c3).toString());
        assertEquals("1.0", c2.ComplexAdd(c3).toString());
    }
    @Test
    public void testComplexSub() throws Exception {
        assertEquals("1.0+4.0i", c1.ComplexSub(c2).toString());
        assertEquals("-2.0+2.0i", c1.ComplexSub(c3).toString());
        assertEquals("-3.0 -2.0i", c2.ComplexSub(c3).toString());
    }
    @Test
    public void testComplexMulti() throws Exception {
        assertEquals("3.0 -3.0i", c1.ComplexMulti(c2).toString());
        assertEquals("-3.0+6.0i", c1.ComplexMulti(c3).toString());
        assertEquals("-1.0 -3.0i", c2.ComplexMulti(c3).toString());
    }
    @Test
    public void testComplexComplexDiv() throws Exception {
        assertEquals("-1.5 -1.5i", c1.ComplexDiv(c2).toString());
        assertEquals("1.2+0.6i", c1.ComplexDiv(c3).toString());
        assertEquals("-0.6 -0.6i", c2.ComplexDiv(c3).toString());
    }
}

2.实验代码

public class Complex{
    private double r;
    private double i;
    public Complex(double r, double i) {
        this.r = r;
        this.i = i;
    }

    public static double getRealPart(double r) {
        return r;
    }

    public static double getImagePart(double i) {
        return i;
    }

    public Complex ComplexAdd(Complex c) {
        return new Complex(r + c.r, i + c.i);
    }
    public Complex ComplexSub(Complex c) {
        return new Complex(r - c.r, i - c.i);
    }
    public Complex ComplexMulti(Complex c) {
        return new Complex(r * c.r - i * c.i, r * c.i + i * c.r);
    }
    public Complex ComplexDiv(Complex c) {
        return new Complex((r * c.i + i * c.r)/(c.i * c.i + c.r * c.r), (i * c.i + r * c.r)/(c.i * c.i + c.r * c.r));
    }

    public String toString() {
        String s = " ";
        if (i > 0)
            s =  r + "+" + i + "i";
        if (i == 0)
            s =  r + "";
        if (i < 0)
            s = r + " " + i + "i";
        return s;
    }
}

3.测试截图

---

7.对实验二中的代码进行建模

参考（https://blog.csdn.net/chktsang/article/details/79697747）画类图

1.代码

 abstract class Data {
        abstract public void DisplayValue();
    }
    class Integer extends  Data {
        int value;
        Integer() {
            value=100;
        }
        public void DisplayValue(){
            System.out.println (value);
        }
    }
    class Float extends Data{       //float类
        float value;
        Float(){
            value=(float)66.66;
        }
        public void DisplayValue(){
            System.out.println(value);
        }
    }
    abstract class Factory {
        abstract public Data CreateDataObject();
    }
    class IntFactory extends Factory {
        public Data CreateDataObject(){
            return new Integer();
        }
    }
    class FloatFactory extends Factory{
        public Data CreateDataObject(){
            return new Float();
        }
    }
    class Document {
        Data pd;
        Document(Factory pf){
            pd = pf.CreateDataObject();
        }
        public void DisplayData(){
            pd.DisplayValue();
        }
    }
    //Test class
    public class MyDoc {
        static Document d;
        static Document e;
        public static void main(String[] args) {
            d = new Document(new IntFactory());
            d.DisplayData();
            e=new Document(new FloatFactory());
            e.DisplayData();

        }
    }

2.类图

---

实验中遇到问题

1.问题：在配置junit时显示无法同时配置。



解决方法：在错误地方按alt+enter进行自动修复配置。（https://blog.csdn.net/shifangwannian/article/details/48142329）

---

实验体会

通过这次实验二，熟悉了代码的编写和添加类，并且对uml类图有了最基本的认识，开始尝试画类图，虽然在开始很有难度，但在博客中学习关于类图的内容并结合教程，画出了类图。在实验中还学习了TDD模式，这种先编写测试代码，后编写实验代码在一定程度上降低了编写的错误。在实验中还是感觉自己能力欠缺，还需要努力学习。