实验三 敏捷开发与XP实践

实验三 敏捷开发与XP实践

实验内容

• XP基础

• XP核心实践

• 相关工具

编码标准

-代码标准中很重要的一项是如何给包、类、变量、方法等标识符命名，能很好的命名可以让自己的代码立马上升一个档次。Java中的一般的命名规则有：

-要体现各自的含义
-包、类、变量用名词
-方法名用动宾
-包名全部小写，如：io，awt
-类名第一个字母要大写，如：HelloWorldApp
-变量名第一个字母要小写，如：userName
-方法名第一个字母要小写：setName

-加入结对伙伴项目：

• 这是一个可以编译的程序，体会一下它的可读性。我们常见的是这样的代码:

public class CodeStandard {
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());
if(buffer.capacity()<20)
buffer.append("1234567");
for(int i=0; i<buffer.length();i++)
System.out.println(buffer.charAt(i));
}
}

• 程序没有最基本的缩进，让人读起来很费劲，在IDEA中：
  
  

下载搭档实验二的Complex代码，加入不少于三个JUnit单元测试用例

• 搭档代码如下：

import java.lang.*;
public class Complex {
    //定义属性并生成getter，setter
    double RealPart;
    double ImagePart;
    public double getRealPart() {
        return RealPart;
    }
    public void setRealPart(double realPart) {
        this.RealPart=realPart;
    }
    public double getImagePart() {
        return ImagePart;
    }
    public void setImagePart(double imagePart) {
        this.ImagePart=imagePart;
    }
    //定义构造函数
    public Complex(double R, double I) {
        RealPart = R;
        ImagePart = I;
    }
    //Override Object
    public boolean equals(Complex obj1) {
        if (this.getRealPart () == obj1.getRealPart () && this.getImagePart () == obj1.getImagePart ())
            return true;
        else return false;
    }
    //定义公有方法：加减乘除
    public String toString() {
        return "第一个"+RealPart + " 第二个" + ImagePart ;
    }
    public Complex ComplexAdd(Complex obj) {
        return new Complex ( RealPart + obj.getRealPart (), ImagePart + obj.getImagePart () );
    }
    public Complex ComplexSub(Complex obj) {
        return new Complex ( RealPart - obj.getRealPart (), ImagePart - obj.getImagePart () );
    }
    public Complex ComplexMulti(Complex obj) {
        return new Complex ( RealPart * obj.getRealPart () - ImagePart * obj.getImagePart (), RealPart * obj.getImagePart () + ImagePart * obj.getRealPart () );
    }
    public Complex ComplexDiv(Complex obj){
        return new Complex ( RealPart / obj.getRealPart () - ImagePart / obj.getImagePart (), RealPart / obj.getImagePart () + ImagePart / obj.getRealPart () );
    }
}

• 根据他的代码编写ComplexTest，加入不少于三个单元测试用例，代码如下：

/**
 * Created by 20155327 on 2017/5/4.
 */

import static org.junit.Assert.*;


import junit.framework.TestCase;
import org.junit.Test;

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 testgetPart() throws Exception {
        assertEquals(4.0, Complex.getImagePart(4.0));
        assertEquals(5.0, Complex.getImagePart(5.0));
        assertEquals(1.0, Complex.getImagePart(1.0));
    }


}

在IDEA中使用工具（Code->Reformate Code）格式化代码，并学习Code菜单的功能

IDEA中的Code菜单中
可以发现其中的功能十分丰富，同时很多功能都可以通过快捷键实现。现将几个比较常用的功能总结如下：
-code 进入generate中

• Override Methods(Ctrl+O)：重载基本类的方法；
• mplement Methods(Ctrl+I)：完成当前类 implements 的（或者抽象基本类的）接口的方法；
• Generate(Alt+Insert)：创建类里面任何字段的 getter 与 setter 方法；
• Surround With(Ctrl+Alt+T)：使用if-else、try-catch、do-while等包装代码段；

下载搭档的代码，至少进行三项重构

重构，是让我们在不为系统带来新的bug的前提下，使其更加易于阅读、易于维护和易于变更。

重构如下：

public class Person3 implements Cloneable {
    private String name;
    private int ID;
    Person3(String name, int ID){
        this.name = name;
        this.ID = ID;
    }
    public String getName() {
        return name;
    }
    public int getID() {
        return ID;
    }
    @Override
    protected Person3 clone() throws CloneNotSupportedException {
        return (Person3)super.clone();
    }

    public static void main(String[] args) {
        try {
            Person3 p = getJustin();
            Person3 p3 = getClone(p);

            getPrintln((Person3) p);
            getPrintln((Person3) p3);
            getPrintln("p.getName().hashCode() : " + p.getName().hashCode());
            getPrintln("p3.getName().hashCode() : " + p3.getName().hashCode());
            String result = p.getName().hashCode() == p3.getName().hashCode() ? "浅拷贝" : "深拷贝";
            getPrintln(result);
        }catch(CloneNotSupportedException e){
            System.out.println(e);
        }
    }

    private static Person3 getClone(Person3 p) throws CloneNotSupportedException {
        return p.clone();
    }

    private static Person3 getJustin() {
        return new Person3("Justin",20150001);
    }

    private static void getPrintln(String x) {
        System.out.println(x);
    }

    private static void getPrintln(Person3 p) {
        System.out.println(p);
    }
}

重构

重构(Refactor)，就是在不改变软件外部行为的基础上，改变软件内部的结构，使其更加易于阅读、易于维护和易于变更 。

• 代码重复，还有方法过长、参数列过长、条件逻辑过度复杂、分支语句等等方面。通过重构，我们可以实现代码的优化。

以结对的方式完成Java密码学相关内容的学习，结合重构、git、代码标准等

PSP(Personal Software Process)时间

步骤	耗时	百分比
需求分析	20min	20%
设计	10min	10%
代码实现	40min	40%
测试	20min	20%
分析总结	10min	10%

实验体会

这次实验主要是学习重构，重构主要是解决代码重复，还有方法过长、参数列过长、条件逻辑过度复杂、分支语句等等方面的问题，对代码进行优化，看上去不那么的冗长。

重温实验，发现自己还是有地方没有完成，老师让我们介绍code中的一项功能，之前的真的很敷衍，这次重新优化了一下。本次对书上的长代码进行了一次重构体验，真实的体会到了，重构对代码的重要性。他可让代码更短，言简意赅这四个字可能就是对重构最好的诠释吧