实验三

学号 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程序设计与数据结构教程（第二版）》学习指导