#2018-2019-2-20175204 张湲祯 实验二 《Java开发环境的熟悉》实验报告
#实验二 Java面向对象程序设计 ##一.实验内容：
- 初步掌握单元测试和TDD
- 理解并掌握面向对象三要素：封装、继承、多态
- 初步掌握UML建模
- 熟悉S.O.L.I.D原则
- 了解设计模式
##二.实验步骤： ###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模式，这种先编写测试代码，后编写实验代码在一定程度上降低了编写的错误。在实验中还是感觉自己能力欠缺，还需要努力学习。
来源：oschina
链接：https://my.oschina.net/u/4369125/blog/4161560