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