# 20202317 2021-2022-1 《数据结构与面向对象程序设计》实验报告

课程：《程序设计与数据结构》
班级： 2023
姓名：吉相融
学号：20202302
实验教师：王志强
实验日期：2021年9月30日
必修/选修： 必修

 

## 1.实验内容

下载安装并使用IDEA，完成下面实验（https://www.cnblogs.com/rocedu/p/6371315.html）。

1. 初步掌握单元测试和TDD

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

3. 初步掌握UML建模

4. 完成蓝墨云上 （1）-（5）实验。

 

## 2.实验过程及结果

1. 初步掌握单元测试和TDD

MyUtiltest是一个测试程序，运行后可以测试程序。

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

封装：即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。”

继承：特殊类的对象拥有一般类的全部属性与行为，称为特殊类对一般类的继承。一个类可以是多个一般类的特殊类，也可以从多个一般类中继承属性与行为，但在java语言中，不允许一个类从多个一般类中继承属性与行为，即在java语言中，只支持单继承。

多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。简单的说:就是用基类的引用指向子类的对象。

 

 

3. 初步掌握UML建模

 4. 完成蓝墨云上 （1）-（5）实验。

（1）

任务详情

参考 http://www.cnblogs.com/rocedu/p/6371315.html#SECUNITTEST 
参考http://www.cnblogs.com/rocedu/p/6736847.html

提交最后三个测试用例都通过的截图，截图上要有画图加水印，输入自己的学号。
代码：

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

 

测试代码：

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

 

运行结果：

 （2）

参考 积极主动敲代码，使用JUnit学习Java （http://www.cnblogs.com/rocedu/p/4837092.html)
参考http://www.cnblogs.com/rocedu/p/6736847.html
以 TDD的方式研究学习StringBuffer，提交你的单元测试用例和测试通过的截图，截图要加上学号水印。
代码：

public class StringBufferDemo{
    public static void main(String [] args){
        StringBuffer buffer = new StringBuffer();
        buffer.append('S');
        buffer.append("tringBuffer");
        System.out.println(buffer.charAt(1));
        System.out.println(buffer.capacity());
        System.out.println(buffer.indexOf("tring"));
        System.out.println("buffer = " + buffer.toString());
    }
}

 

测试代码

import junit.framework.TestCase;

public class StringBufferDemoTest extends TestCase {
    StringBuffer a = new StringBuffer("wanglaoshitaiqiangle");
    StringBuffer b = new StringBuffer("wanglaoshitaihaole");
    StringBuffer c = new StringBuffer("wotainanle555");

    public void testcharAt(){                    //字符索引测试
        assertEquals('w',a.charAt(0));
        assertEquals('o',b.charAt(6));
        assertEquals('5',c.charAt(10));
    }

    public void testcapacity(){                  //测试caoacity(),发现其返回的数值是length()+16
        assertEquals(36,a.capacity());
        assertEquals(33,b.capacity());
        assertEquals(29,c.capacity());
    }

    public void testlength(){                    //字符串长度测试
        assertEquals(20,a.length());
        assertEquals(17,b.length());
        assertEquals(13,c.length());
    }

    public void testindexOf(){                   //子串匹配测试
        assertEquals(0,a.indexOf("wanglaoshi"));
        assertEquals(4,b.indexOf("lao"));
        assertEquals(10,c.indexOf("555"));
    }
}

 

运行结果

 （3）

任务详情

实验三 Java面向对象程序设计(http://www.cnblogs.com/rocedu/p/4472842.html)

参考http://www.cnblogs.com/rocedu/p/6736847.html

对设计模式示例进行扩充，体会OCP原则和DIP原则的应用，初步理解设计模式
用自己的学号%6进行取余运算，根据结果进行代码扩充：
0:让系统支持Byte类，并在MyDoc类中添加测试代码表明添加正确，提交测试代码和运行结的截图，加上学号水印
1:让系统支持Short类，并在MyDoc类中添加测试代码表明添加正确，提交测试代码和运行结的截图，加上学号水印
2:让系统支持Boolean类，并在MyDoc类中添加测试代码表明添加正确，提交测试代码和运行结的截图，加上学号水印
3:让系统支持Long类，并在MyDoc类中添加测试代码表明添加正确，提交测试代码和运行结的截图，加上学号水印
4:让系统支持Float类，并在MyDoc类中添加测试代码表明添加正确，提交测试代码和运行结的截图，加上学号水印
5:让系统支持Double类，并在MyDoc类中添加测试代码表明添加正确，提交测试代码和运行结的截图，加上学号水印

 

abstract class Data {
    abstract public void DisplayValue();
}
class Integer extends  Data {
    int value;
    Integer() {
        value=20202302%6;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
}
class Byte extends  Data {
    byte value;
    Byte() {
        value=20202302%6;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
}
class Short extends  Data {
    short value;
    Short() {
        value=20202302%6;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
}
class Boolean extends  Data {
    boolean value;
    Boolean() {
        value=20202302%6==3;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
}
class Long extends  Data {
    long value;
    Long() {
        value=20202302;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
}
class Double extends  Data {
    double value;
    Double() {
        value=20202302%6;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
}
class Float extends  Data {
    float value;
    Float() {
        value=20202302%6;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
}
// Pattern Classes
abstract class Factory {
    abstract public Data CreateDataObject();
}
class IntFactory extends Factory {
    public Data CreateDataObject(){
        return new Integer();
    }
}
class ByteFactory extends Factory {
    public Data CreateDataObject(){
        return new Byte();
    }
}
class ShortFactory extends Factory {
    public Data CreateDataObject(){
        return new Short();
    }
}
class BoolenFactory extends Factory {
    public Data CreateDataObject(){
        return new Boolean();
    }
}
class LongFactory extends Factory {
    public Data CreateDataObject(){
        return new Long();
    }
}
class DoubletFactory extends Factory {
    public Data CreateDataObject(){
        return new Double();
    }
}
class FloatFactory extends Factory {
    public Data CreateDataObject(){
        return new Float();
    }
}
//Client classes
4class 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 IntFactory());
        d.DisplayData();
        d = new Document(new ByteFactory());
        d.DisplayData();
        d = new Document(new ShortFactory());
        d.DisplayData();
        d = new Document(new BoolenFactory());
        d.DisplayData();
        d = new Document(new LongFactory());
        d.DisplayData();
        d = new Document(new DoubletFactory());
        d.DisplayData();
        d = new Document(new FloatFactory());
        d.DisplayData();
    }
}

 运行结果·：

 

（4）

任务详情

提交：单元测试代码和运行成功截图及码云上代码链接，截图要加上学号水印

参考http://www.cnblogs.com/rocedu/p/6736847.html

任务：以TDD的方式开发一个复数类Complex，要求如下:

// 定义属性并生成getter,setter
double RealPart;
double ImagePart;

 代码：

public class Complex{
    double RealPart;
    double ImagePart;

    //定义构造函数,定义复数的实部变量a和虚部变量b
    public Complex(double a,double b){
        this.RealPart = a;
        this.ImagePart = b;
    }

    //覆盖对象,判断boolean
    public String toString(){
        return "RealPart:" + RealPart + ", ImagePart:" + ImagePart;
    }
    public boolean equals(Object z1){
        if (z1 == this){
            return true;
        }
        else{
            return false;
        }
    }

    //定义加减乘除子函数
    public Complex ComplexAdd(Complex z2){
        Complex z3 = new Complex(this.RealPart + z2.RealPart,this.ImagePart + z2.ImagePart);
        return z3;
    }
    public Complex ComplexSub(Complex z2){
        Complex z3 = new Complex(this.RealPart - z2.RealPart,this.ImagePart - z2.ImagePart);
        return z3;
    }
    public Complex ComplexMulti(Complex z2){
        Complex z3 = new Complex(this.RealPart * z2.RealPart - this.ImagePart * z2.ImagePart,
                this.ImagePart * z2.RealPart + this.RealPart * z2.ImagePart);
        return z3;
    }
    public Complex ComplexDiv(Complex z2){
        double t = z2.RealPart * z2.RealPart + z2.ImagePart * z2.ImagePart;
        Complex z3 = new Complex((this.RealPart * z2.RealPart + this.ImagePart * z2.ImagePart) / t,
                (this.ImagePart * z2.RealPart - this.RealPart * z2.ImagePart) / t);
        return z3;
    }
}

测试代码：

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

public class ComplexTest extends TestCase {
    Complex z1 = new Complex(4.0,2.0);
    Complex z2 = new Complex(1.0,-1.0);
    @Test
    public void testequals() {
        assertEquals(true, z1.equals(z1));
        assertEquals(false, z1.equals(z2));
    }
    @Test
    public void testComplexAdd() {
        assertEquals("RealPart:5.0, ImagePart:1.0", z1.ComplexAdd(z2).toString());
    }
    @Test
    public void testComplexSub() {
        assertEquals("RealPart:3.0, ImagePart:3.0", z1.ComplexSub(z2).toString());
    }
    @Test
    public void testComplexMulti() {
        assertEquals("RealPart:6.0, ImagePart:-2.0", z1.ComplexMulti(z2).toString());
    }
    @Test
    public void testComplexDiv() {
        assertEquals("RealPart:1.0, ImagePart:3.0", z1.ComplexDiv(z2).toString());
    }
}

运行结果：

 （5）

任务详情

使用[WhiteStarUML](http://whitestaruml.sourceforge.net/)对实验二中的代码进行建模，发类图的截图，加上学号水印。
参考http://www.cnblogs.com/rocedu/p/6736847.html

 

 

3.实验中的问题及解决过程：

（1）调试JUnit时，迟迟找不到包的位置。下载Everything后也没有找到，最终是查找默认位置才找到JUnit.jar的位置，成功将其配置成功。

（不过后来重启电脑后找到了JUnit.jar）

 （2）写的程序许多出现了红字，程序无法正常运行，许多是由于异常导致的。。。。。

解决过程：点红色小灯泡，IDEA会给出合适的解决方法。印象深刻的是我一个程序处理完异常一共用了五六个”Try Catch“，但不得不说是真的好用！

（3）在测试程序时，IDEA经常去运行项目中其他的test程序，许多测试程序第一次运行都无法成功，运行的是其他test程序。。。

解决过程：重新创建一个项目，将之前的test程序转移，再测试当前的test程序。

（事实上，运行其他test程序的原因是两个程序调用了同一个类的方法，所以给类取名时一定要有区分！做一个实验结束后最好开一个项目或者类名要区分清楚。）

4.其他（感悟、思考）

本次实验，第一次使用了IDEA集成开发环境。不得不说集成开发环境编程效率要高出不少，解决问题的效率也大幅提升，不得不感叹与集成开发环境的伟大orz

这一次实验量较大，实验难度也较大，例如多态的程序就包含了很多个类。不得不说这实在让人痛苦，不过希望自己痛苦过后也能有相应的收获。

 

 5.参考资料。

CSDN，云班课相关资料。