实验二 Java面向对象程序设计
实验二 Java面向对象程序设计
一、实验内容
1. 初步掌握单元测试和TDD
2. 理解并掌握面向对象三要素：封装、继承、多态
3. 初步掌握UML建模
4. 熟悉S.O.L.I.D原则
5. 了解设计模式
二、实验要求
1.完成实验、撰写实验报告，以博客方式发表在博客园
2.实验报告重点是运行结果、遇到的问题(工具查找，安装，使用，程序的编辑，调试，运行等)、解决办法
3. 严禁抄袭，有该行为者实验成绩归零，并附加其他惩罚措施
三、实验过程
（一）单元测试
1.三种代码
伪代码：以简洁的自然语言表明设计步骤；
产品代码：用以实现特定功能的程序或机器语言；
测试代码：用以对产品代码进行测试的代码
举例
学生考试等级划分程序产品代码
package java2;
public class MyUtil {
public static String percentage2fivegrade(int grade)
{
//如果成绩小于60，转成“不及格”
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 "优秀";
//其他，转成“错误”
else
return "错误";
}
}
其用到的测试代码如下
测试一：选取某一合法输入值进行测试
package java2;
public class MyUtilTest
{
public static void main(String[] args)
{ // 百分制成绩是50时应该返回五级制的“不及格”
if(MyUtil.percentage2fivegrade(50) != "不及格")
System.out.println("test failed!");
else System.out.println("test passed!");
}
}
运行结果（成功）：
测试二：全面覆盖各等级段
package java2;
public class MyUtilTest2
{
public static void main(String[] args)
{
//测试正常情况
if(MyUtil.percentage2fivegrade(55) != "不及格")
System.out.println("test failed!");
else if(MyUtil.percentage2fivegrade(65) != "及格")
System.out.println("test failed!");
else if(MyUtil.percentage2fivegrade(75) != "中等")
System.out.println("test failed!");
else if(MyUtil.percentage2fivegrade(85) != "良好")
System.out.println("test failed!");
else if(MyUtil.percentage2fivegrade(95) != "优秀")
System.out.println("test failed!");
else System.out.println("test passed!");
}
}
运行结果（成功）：
测试三：测试分段结点
package java2;
public class MyUtilTest3
{
public static void main(String[] args)
{
//测试边界情况
if(MyUtil.percentage2fivegrade(0) != "不及格")
System.out.println("test failed 1!");
else if(MyUtil.percentage2fivegrade(60) != "及格")
System.out.println("test failed 2!");
else if(MyUtil.percentage2fivegrade(70) != "中等")
System.out.println("test failed 3!");
else if(MyUtil.percentage2fivegrade(80) != "良好")
System.out.println("test failed 4!");
else if(MyUtil.percentage2fivegrade(90) != "优秀")
System.out.println("test failed 5!");
else if(MyUtil.percentage2fivegrade(100) != "优秀")
System.out.println("test failed 6!");
else
System.out.println("test passed!");
}
}
运行结果（检测问题）：
通过此对产品代码改进
将
//如果成绩小于60，转成“不及格”
if (grade < 60)
return "不及格";
改为
if(grade<0)
return "错误";
//如果成绩小于60，转成“不及格”
else if (grade < 60)
return "不及格";
2.TDD(Test Driven Devlopment, 测试驱动开发)
TDD，顾名思义，是为了解决产品代码的漏洞，而以程序测试推动程序开发即先写测试代码，然后再写产品代码的开发方式。
明确当前待完成功能并记录成测试列表——〉
快速完成编写针对此功能的测试用例——>
测试代码编译不通过——〉
编写产品代码——〉
测试通过——〉
对代码进行重构，并保证测试通过——〉
循环完成所有功能开发
java中有单元测试工具JUnit来辅助进行TDD。具体过程见下：
（文字表述）：java——〉File——〉New——〉Java Project——〉TDDDemo——〉右键单击TDDDemo——〉New——〉Source Folder——〉test——右键单击test——〉New——〉JUnit Test Case——〉MyUtilTest——〉其superclass改为junit.framework.TestCase
（图片表述，步骤截图）：
逐步完善测试代码如下（包括testNormal 、testException、testBoundary）：
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));
}
@Test
public void testException()
{
assertEquals("错误", MyUtil.percentage2fivegrade(105));
assertEquals("错误", MyUtil.percentage2fivegrade(-55));
}
@Test
public void testBoundary()
{
assertEquals("不及格", MyUtil.percentage2fivegrade(0));
assertEquals("及格", MyUtil.percentage2fivegrade(60));
assertEquals("中等", MyUtil.percentage2fivegrade(70));
assertEquals("良好", MyUtil.percentage2fivegrade(80));
assertEquals("优秀", MyUtil.percentage2fivegrade(90));
assertEquals("优秀", MyUtil.percentage2fivegrade(100));
}
}
在src中新建MyUtil类并输入产品代码，然后运行测试代码（Run as——> JUnit Test）
运行结果如下（分别为修改产品代码前后测试结果）：
总结：
进行产品开发时，既要保证产品代码的正确性，又要保证投入成本的可行性。结合一次代码编写很可能出现漏洞的实际情况，开发出了针对产品的测试代码；为了减少工作量，节约资源成本，又有了TDD方法。此方法创新之处在于“测试驱动”，即提前设置好标准，达到标准即视为合格，这一思想在其他很多领域也是通用的管理办法。
（二）面向对象三要素
1.抽象
即“求同存异、去粗取精”的过程。将若干事物中相同的部分进行剥离整理，并形成具有某特定功能的产品，这一过程即为抽象。过程抽象的结果是函数，数据抽象的结果是抽象数据类型其显而易见的好处是（在程序设计中）减少了代码大重复性，提高了效率。
2.封装、继承与多态
封装：将与某一将数据与相关行为包装在一起以实现信息就隐藏，核心内容是模块化和信息隐藏，与此相伴的是接口的使用
封装示例
public class Dog
{
private String color;
public String getColor()
{
return color;
}
public void setColor(String color)
{
this.color = color;
}
public String bark()
{
return "汪汪";
}
public String toString()
{
return "The Dog's color is " + this.getColor() +", and it shouts "+ this.bark() + "!";
}
}
检测示例
public class DogTest
{
public static void main(String[] args)
{
Dog d = new Dog();
d.setColor("Yellow");
getInfo(d);
}
public static void getInfo(Dog d)
{
System.out.println(d.toString());
}
}
public class AnimalTest
{
public static void main(String[] args)
{
Dog d =new Dog();
d.setColor("Yellow");
getInfo(d);
Cat c =new Cat();
c.setColor("Black");
getInfo(c);
}
public static void getInfo(Dog d)
{
System.out.println(d.toString());
}
public static void getInfo(Cat c)
{
System.out.println(c.toString());
}
}
运行结果如下
利用umbrello软件，可以将以上思路进行具象化表示
继承：以封装为基础，一个类的定义可以基于另外一个已经存在的类，即子类基于父类，从而实现父类代码的重用。其更为广泛而重要的作用是实现多态。
继承示例：
Dog类和Cat类都有Color属性和相应的setter和getter方法，可以通过继承使其精炼化，把Color属性和相应的setter和getter方法放到父类Animal中
代码实现
public abstract class Animal
{
private String color;
public String getColor()
{
return color;
}
public void setColor(String color)
{
this.color = color;
}
public abstract String shout();
}
public class Cat extends Animal
{
public String shout()
{
return "喵喵";
}
public String toString()
{
return "The Cat's color is " + this.getColor() +", and it shouts "+ this.shout() + "!";
}
}
public class Dog extends Animal
{
public String shout()
{
return "汪汪";
}
public String toString()
{
return "The Dog's color is " + this.getColor() +", and it shouts "+ this.shout() + "!";
}
}
总结：
在Java中，当我们用父类声明引用，用子类生成对象时，多态就出现了。封装、继承与多态是在抽象的基础上进行的“进化”，用于减少重复和赘余。其中很重要的思想就是模块化和信息隐藏。
（三）设计模式初步
（1）S.O.L.I.D原则
• SRP(Single Responsibility Principle,单一职责原则)
对象提供单一职责的高度封装，对象的改变仅仅依赖于单一职责的改变
• OCP(Open-Closed Principle,开放-封闭原则)
即对扩充开放（功能可增加），对修改封闭（源代码不可改动）
OCP实现手段：（1）抽象和继承，（2）面向接口编程
• LSP(Liskov Substitusion Principle,Liskov替换原则)
子类必须可以被其基类所代，父类型对象可以被子类型对象所取代
• ISP(Interface Segregation Principle,接口分离原则)
客户不应该依赖他们并未使用的接口
• DIP(Dependency Inversion Principle,依赖倒置原则)
（2）模式与设计模式
模式是某外在环境(Context) 下﹐对特定问题(Problem)的惯用解决之道。其中最重要的是设计模式。
（3）设计模式实示例
设计模式四个基本元素
Pattern name：描述模式，便于交流，存档
Problem：描述何处应用该模式
Solution：描述一个设计的组成元素，不针对特例
Consequence：应用该模式的结果和权衡
示例如下
package liuweiran;
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类
package liuweiran;
//Server Classes
abstract class Data
{
abstract public void DisplayValue();
}
class Integer extends Data
{
int value;
Integer()
{
value=100;
}
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();
}
}
//Client classes
class Document
{
Data pd;
Document(Factory pf)
{
pd = pf.CreateDataObject();
}
public void DisplayData()
{
pd.DisplayValue();
}
}
//Test class
public class MyDoc3
{
static Document d;
public static void main(String[] args)
{
d = new Document(new IntFactory());
d.DisplayData();
}
}
（四）练习
1.使用TDD的方式设计实现复数类Complex。
设计思路：在测试类中，人为设置测验标准（即注明若干情况下的输出量，应本着尽可能全面的原则）；在产品代码中，为了符合测试类标准，应该分情况进行输出。
代码实现：
import org.junit.Test;
import junit.framework.TestCase;
public class FushuTest extends TestCase {
@Test
public void test() {
assertEquals("a输入错误 ", Fushu.fushu(0.0,10.0));
assertEquals("b输入错误 ",Fushu.fushu(9.0, 0.0));
assertEquals("9.0i+10.0",Fushu.fushu(9.0, 10.0));
}
}
public class Fushu
{
public static String fushu(double a,double b)
{
if(a == 0.0)
return "a输入错误 ";
if(b == 0.0)
return "b输入错误 ";
else
{
String t = a+"i+"+b;
return t;
}
}
}
