实验三

学号 2019-2020-1 《数据结构与面向对象程序设计》实验x报告

课程:《程序设计与数据结构》

班级: 1823

姓名: 杨凯涵

学号:20182321

实验教师:王志强

实验日期:2019年9月24日

必修/选修: 必修

1.实验内容

完成实验一到五:

  • 实验一,实现百分制成绩转成“优、良、中、及格、不及格”五级制成绩的功能。

  • 实验二,以TDD的方式研究学习StringBuffer

  • 实验三,对MyDoc类进行扩充,让其支持byte类,初步理解设计模式

  • 实验四,以TDD的方式开发一个复数类Complex

  • 实验五,使用StarUML对实验二中的代码进行建模

  • 下载并安装idea,在idea上完成以上实验,并把代码git到码云上

2实验过程及结果

实验一

根据参考上说的我们通过下载boxtools来下载idea,但是发现里面的idea是收费的,所以我们下来了idea community版本(且不需要下载JDK配置环境)

接着进行了实验一,编写程序实现百分制成绩转成“优良中及格不及格”五个等级成绩的功能
首先我们需要写出伪代码

百分制转五分制:
如果成绩小于60,转成“不及格”
如果成绩在60与70之间,转成“及格”
如果成绩在70与80之间,转成“中等”
如果成绩在80与90之间,转成“良好”
如果成绩在90与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 "错误";
   }
}

最后测试结果如图所示

如果左下方是test fail!那么就是测试失败的意思,说明我们的代码需要加以修改。

此为在测试过程中出现的一例错误


实验二

然后进行了实验二,是以tdd的形式研究学习Stringbuffer这一个类,这个任务主要锻炼我们自己写JUnit测试用例的能力。

        package com.company;

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

根据老师给出的代码,我们看到了Stringbuffer里四种方法,通过查阅JDKAPI,里面对于CharAt()的解释为“返回此序列中指定索引处的 char 值。第一个 char 值在索引 0 处,第二个在索引1处,依此类推,这类似于数组索引。”indexof(String s)是返回输入的子字符串的第一个字母在母字符串的位置。length()是返回字符串的长度,capacity()是返回当前容量。出于对着三种字符串的思考,我们设置了一串test测试代码

import static org.junit.jupiter.api.Assertions.*;

import junit.framework.TestCase;
import org.junit.Test;
    public class StringBufferDemoTest extends TestCase {
        StringBuffer a = new StringBuffer("Heloiduwhhjujkw");
        StringBuffer b = new StringBuffer("jkwiduwidkwsjiwudowpqdsi");
        StringBuffer c = new StringBuffer("wiudwiszisdwiwdjicudiwdisiuqjenfjcks");

        @Test
        public void testcharAt() throws Exception{
            assertEquals('H',a.charAt(0));
            assertEquals('d',a.charAt(5));
            assertEquals('u',a.charAt(11));
        }

        @Test
        public void testcapacity() throws Exception{
            assertEquals(31,a.capacity());
            assertEquals(40,b.capacity());
            assertEquals(52,c.capacity());
        }

        @Test
        public void testlength() throws  Exception{
            assertEquals(15,a.length());
            assertEquals(24,b.length());
            assertEquals(36,c.length());
        }

        @Test
        public void testindexOf() throws Exception{
            assertEquals(0,a.indexOf("Hel"));
            assertEquals(5,b.indexOf("uwi"));
            assertEquals(2,c.indexOf("udw"));
        }

    }



反复修改代码中的数据,最后通过测试


实验三

对MyDoc类进行扩充,让其支持short类,初步理解设计模式。OCP规则,即对外开放,对内封闭,是OOD中最重要的一个原则,而DIP原则,又被称为依赖倒置原则,指的是要依赖于抽象,而不是依赖于具体,要针对接口编程而不是针对实现编程。例如,我们拿出了娄老师中的博客代码:

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

此段代码中有着我们没学到的知识,有些许地方看不懂,根绝娄老师的博客中所说的,要想支持float类,需要Document类改变构造方法,这样可违背了构造规则(OCP),所以,娄老师更改了其设计模式,

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

我们也依照着娄老师博客中的代码,根据自己的理解摸索,更改了其模式


abstract class Data {
    abstract public void DisplayValue();
}
class Integer extends  Data {
    int value;
    Integer() {
        value=5000;
    }
    public void DisplayValue(){
        System.out.println (value);
    }
}
class Short extends Data {
    short value;
    Short(){
        value=12;
    }
    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 ShortFactory extends Factory {
    public Data CreateDataObject(){
        return new short();
    }
}
class Document {
    Data pd;
    Document(Factory pf){
        pd = pf.CreateDataObject();
    }
    public void DisplayData(){
        pd.DisplayValue();
    }
}
public class MyDoc {
    static Document a;
    public static void main(String[] args) {
        a=new Document(new ByteFactory());
        a.DisplayData();
    }
}

从代码中观测,通过增加了一层抽象层,使得代码符合Ocp准则,并未直接的改变document类的构造方法。


实验四

以TDD的方式开发一个复数类Complex。从实验二实验一的学习中,我们学会了使用TDD,接下来我们则要利用TDD来开发一个复数类,首先,我们先写上一段伪代码

定义属性:虚部和实部
复数的实部 R
复数的虚部 I
返回复数的实部 getR()
返回复数的虚部 getI()
设置复数的实部 setR()
设置复数的虚部 setI()
输出:a+bi

通过上面的伪代码,我们写出了我们的产品代码

package com.company;

public class Complex{
    private double r;
    private double i;

    public Complex(double R, double I) {
        r = R;
        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;
    }
}

再设计我们的测试代码,不断测试我们的产品代码,最终完成测试


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


实验五

使用whiteStarUML对实验二中的代码进行建模

通过以上的学习,我自己做了一个uml图

3. 实验过程中遇到的问题和解决过程

问题1:文件有红灯泡,无法运行
问题1解决方案:
红灯泡是idea便捷的优势之一,我们只需要点击红灯泡,然后就会出现许多的解决选项,一般使用这种方法,都可以解决idea编程中的大部分问题,这样做可以极大的增快我们编写代码的效率,可以帮助我们快速的发现错误。
问题2:

本人想打开多个项目看代码的时候,发现文件底下都有着一个红色标记,且文件无法运行。
问题2解决方案:当我们单独打开一个项目的时候,就不会发生这种情况了。

根据推测,这可能是和项目的环境有关,当我们打开多个项目的时候,打开的是项目前的那个文件夹目录,这时候,环境显然是不对的,需要我们重新配置,而当我们只单独打开一个项目的时候,环境配置没有问题,里面的所有文件都可以运行,以后应该减少project的数量,尽量文件在一个project中运行。
问题3:StringBuffer的capacity问题探究

加分题!本题可在额外加分选项中加1分。如下代码:
public class StringBufferTest {
  public static void main(String[] args) {
      StringBuffer sb = new StringBuffer("cccccccccccc");
      System.out.println("sb:" + sb);
      System.out.println("sb.capacity():" + sb.capacity());
      System.out.println("sb.length():" + sb.length());

      StringBuffer sBuffer =new StringBuffer();
      sBuffer.append("cccccccccccc");//12个c
      System.out.println("SBuffer's capacity"+sBuffer.capacity());

  }
}
1.为什么结果不同?
2.以后超出范围,应该怎么扩容,capacity扩容的规律是什么?

问题3解决方法:

我们了解到,capacity有着三种不同的构造方法,上面的结果不同很大原因是两种capacity的构造方法不同,第一种是构造StringBffer(String s);这样的话就是可以指定分配给该对象的实体初始容量为参数s的字符序列长度再加上16.第二种是只给16,如果字符序列大于16时,实体的容量才会自动增加。
那么,capacity又是怎么扩容的呢?

旧值*2+2

即第一次内存是16的话,如果扩容,则内存就变成162+2=34,第二次扩容就变成342+2=70。
通过这个式子,我们可以正确使用capacity的扩容方法。同时,capacity的其他功能也可以在书上或者JDKAPI中找出

其他(感悟、思考等)

  • idea是一个开发软件的好工具,其极大的便利了我们编写代码,这也说明了我们应该加强对于学习如何使用idea的力度,只有正确的使用idea,才能更好的学习编程java。
  • 对于问题不仅要知其然还应该要知其所以然,深入去探讨每行代码的含义,如实验三中的代码,只是单独的照猫画虎修改代码,到头来还是一头雾水
  • 深刻的了解了TDD的意义,便是重复多次的举例验证代码,学会使用tdd,能帮助我们打出更好更优秀的代码

参考资料

《Java程序设计与数据结构教程(第二版)》

《Java程序设计与数据结构教程(第二版)》学习指导

posted @ 2019-09-28 16:55  楊某人  阅读(249)  评论(0编辑  收藏  举报