实验二 Java面向对象程序设计
实验内容
1. 初步掌握单元测试和TDD
2. 理解并掌握面向对象三要素：封装、继承、多态
3. 初步掌握UML建模
4. 熟悉S.O.L.I.D原则
5. 了解设计模式
根据实验提交的规则，把实验为五个部分
面向对象程序设计-1
单元测试
1.在 IDEA中我们把产品代码放在src目录中，把测试代码放在test目录中，右键单击项目，在弹出的菜单中选择New->Directory新建一个目录：test。
2.再右键点击设置环境变量，选择Mark Directory->Test Sources Root。
3.根据实验内容代码进行测试，分别对“正常情况”、“边界情况”、“异常情况”进行检验 。
面向对象程序设计-2
2.TDD(Test Driven Devlopment, 测试驱动开发)
1.这种先写测试代码，然后再写产品代码的开发方法叫“测试驱动开发”（TDD）。
2.TDD的一般步骤如下：
明确当前要完成的功能，记录成一个测试列表
快速完成编写针对此功能的测试用例
测试代码编译不通过（没产品代码呢）
编写产品代码
测试通过
面向对象程序设计-3
对设计模式示例进行扩充，体会OCP原则和DIP原则的应用，初步理解设计模式
用自己的学号%6进行取余运算，根据结果进行代码扩充：
3:让系统支持Long类，并在MyDoc类中添加测试代码表明添加正确.
- 设计模式初步
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)
其他面对对象原则
"组合替代继承":这是说相对于继承，要更倾向于使用组合；
"笛米特法则"：这是说"你的类对其它类知道的越少越好"；
"共同封闭原则"：这是说"相关类应该打包在一起"；
"稳定抽象原则"：这是说"类越稳定，越应该由抽象类组成";
abstract class Data
{
abstract public void DisplayValue();
}
class Integer extends Data
{
int value;
Integer()
{
value=100;
}
public void DisplayValue()
{
System.out.println (value);
}
}
class Long extends Data
{
long value;
Long()
{
value=1234567890;
}
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 LongFactory extends Factory
{
public Data CreateDataObject()
{
return new Long();
}
}
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 LongFactory());
e.DisplayData();
}
}
截图
面向对象程序设计-4
使用TDD的方式设计关实现复数类Complex
- 测试代码
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());
}
}
- 产品代码
import java.text.DecimalFormat;//引入DecimalFormat包取一位整数和一位小数
public class Complex {
double Real=0;
double Imaginary=0;
public Complex(){}
public Complex(double Real,double Imaginary){
this.Real=Real;
this.Imaginary=Imaginary;
}
public double getReal(){
return Real;
}
public double getImaginary(){
return Imaginary;
}
public String toString(){
String s = "";
double r=Real;
double i=Imaginary;
if(r==0&&i==0){
s="0";
}
else if(r==0&&i!=0){
s=i+"i";
}
else if(r!=0&&i<0){
s=r+""+i+"i";
}
else if(r!=0&&i==0){
s=r+"";
}
else
{
s=r+"+"+i+"i";
}
return s;
}
public boolean equals(Object obj){//重写equals方法，使其不用来对比字符序列
if(this==obj){
return true;
}
else
return false;
}
DecimalFormat df = new DecimalFormat( "0.0");
public Complex ComplexAdd(Complex a){
return new Complex(Real+a.getReal(),Imaginary+a.getImaginary());
}
public Complex ComplexSub(Complex a){
return new Complex(Real-a.getReal(),Imaginary-a.getImaginary());
}
public Complex ComplexMulti(Complex a){
double r=Real*a.getReal()-Imaginary*a.getImaginary();
double i =Imaginary*a.getReal()+Real*a.getImaginary();
return new Complex(Double.valueOf(df.format(r)),Double.valueOf(df.format(i)));
}
public Complex ComplexDiv(Complex a){
double r=(Real * a.Imaginary + Imaginary * a.Real) / (a.Imaginary * a.Imaginary + a.Real * a.Real);
double i=(Imaginary * a.Imaginary + Real * a.Real) / (a.Real * a.Real + a.Real * a.Real);
return new Complex(Double.valueOf(df.format(r)),Double.valueOf(df.format(i)));
}
}
- 截图
面向对象程序设计-5
- 类图
实验体会
通过这次实验二，熟悉了代码的编写和添加类，并且对uml类图有了最基本的认识。在实验中还学习了TDD模式，这种先编写测试代码，后编写实验代码在一定程度上降低了编写的错误。在实验中还是感觉自己能力欠缺，还需要努力学习。