2018-2019-2 20175306实验三敏捷开发与XP实践《Java开发环境的熟悉》实验报告

2018-2019-2 20175306实验三敏捷开发与XP实践《Java开发环境的熟悉》实验报告

---

实验内容

1. XP基础
2. XP核心实践
3. 相关工具

实验要求

1.没有Linux基础的同学建议先学习《Linux基础入门（新版）》《Vim编辑器》 课程

2.完成实验、撰写实验报告，实验报告以博客方式发表在博客园，注意实验报告重点是运行结果，遇到的问题(工具查找，安装，使用，程序的编辑，调试，运行等)、解决办法（空洞的方法如“查网络”、“问同学”、“看书”等一律得0分）以及分析（从中可以得到什么启示，有什么收获，教训等）。报告可以参考范飞龙老师的指导

实验步骤

（一）编码标准

编程标准包含：具有说明性的名字、清晰的表达式、直截了当的控制流、可读的代码和注释，以及在追求这些内容时一致地使用某些规则和惯用法的重要性。

• 安装alibaba插件
  
  打开Settings ->Plugins在搜索框输入alibaba即可看到Alibaba Java Code Guidelines插件，点击Install进行安装，然后重启IDE生效:
  
  

• 使用：在项目名称上单击右键，在弹出菜单上选择编码规约扫描：
  
  

• 出现下图内容，不规范的地方，有中文提示并且定位到了行，alibaba把问题分为block/critical/major三个等级，有些规则可以一键修复。
  
  

• 例如这里就可以点击直接修复
  
  

• 代码出现的问题：
  
  1.不允许任何魔法值（即未经定义的常量）直接出现在代码中。
  
  2.包名统一使用小写，点分隔符之间有且仅有一个自然语义的英语单词。包名统一使用单数形式，但是类名如果有复数含义，类名可以使用复数形式
  
  3.所有的类都必须添加创建者信息。
  
  

• 规范后代码：

/**
 - CodeStandard
 -  - @author WJS20175306
 - @date 2019/4/29
 */
@SuppressWarnings("ALL")
public class CodeStandard {
    @SuppressWarnings("AlibabaUndefineMagicConstant")
    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());
        //noinspection AlibabaUndefineMagicConstant
        if (buffer.capacity() < 20) {
            buffer.append("1234567");
        }
        for (int i = 0; i < buffer.length(); i++) {
            System.out.println(buffer.charAt(i));
        }
    }
}

• code的使用：参考: code篇
  
  ·Gengrate （ 用于生成Construct、Getter/Setter、toString、Test等） Alt + Insert
  
  

  ·Cyclic Expand Word （ 循环往上选择单词 ） Alt + /
  
  ·Cyclic Expand Word （Backwrad）（ 循环往下选择单词 ） Alt + Shift + /

• 代码标准中很重要的一项是如何给包、类、变量、方法等标识符命名，能很好的命名可以让自己的代码立马上升一个档次。Java中的一般的命名规则有：
  
  · 要体现各自的含义
  
  · 包、类、变量用名词
  
  · 方法名用动宾
  
  · 包名全部小写，如：io，awt
  
  · 类名第一个字母要大写，如：HelloWorldApp
  
  · 变量名第一个字母要小写，如：userName
  
  · 方法名第一个字母要小写：setName

（二）版本控制

• 版本控制提供项目级的 undo（撤销） 功能： 没有什么事情是终结版本， 任何错误必须很容易回滚。 假设你在使用世界上最复杂的文字处理系统。 它具备了所有的能想到的功能，就是没有支持 DELETE（删除） 键。想象你打字的时候得多么的谨慎和缓慢吧， 特别是一篇超大的文档的快临近末尾的时候， 一个不小心就要重头再来（试想你选中所有的文字， 不小心按了 DELETE 键， 因为没有撤销功能，只好重新录入）。编辑文字和版本控制相同，任何时候都需要回滚，无论是一个小时， 一天， 还是一周， 这让你的团队工作自由快速的工作， 而且对于修正错误也非常自信。
• 版本控制允许多人在同一代码上工作， 只要遵守一定的控制原则就行。 再也不会发生诸如一个人覆盖了另一个人编辑的代码，导致那个人的修改无效这样的情况。
• 版本控制系统保存了过去所作的修改的历史记录。如果你遭遇到一些惊讶的代码，通过版本控制系统可以很容易找出是谁干的， 修改了什么， 修改的时间， 如果幸运的话，还能找出原因。
• 版本控制系统还支持在主线上开发的同时发布多个软件版本。在软件发布的时候也不需要整个团队的停止工作，不需要冻结代码。
• 版本控制也是项目级的时间机器，你可以选择任何一个时间， 精确地查看项目在当时的情况。 这对研究非常有用， 也是重现以前某个有问题的发布版本的基础。

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

• 一个完整的重构流程包括：
  
  1.从版本控制系统代码库中Check out code
  
  2.读懂代码（包括测试代码）
  
  3.发现bad smell
  
  4.Refactoring
  
  5.运行所有的Unit Tests
  
  6.往代码库中Check in code

（四）实践

• 邀请搭档进入码云仓库：
  
  

• 搭档的Complex代码
  
  

• 对搭档代码进行测试：
  
  

• 测试代码：

package 其它;

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

public class HYComplexTest extends TestCase {
    HYComplex a = new HYComplex(2.0,4.0);
    HYComplex b = new HYComplex(0.0,-3.0);
    HYComplex c = new HYComplex(-5.0,0.0);
    @Test
    public void testgetRealpart(){
        assertEquals(2.0,a.getRealPart());
        assertEquals(0.0,b.getRealPart());
        assertEquals(-5.0,c.getRealPart());
    }
    @Test
    public void testgetImagePart(){
        assertEquals(4.0,a.getImagePart());
        assertEquals(-3.0,b.getImagePart());
        assertEquals(0.0,c.getImagePart());
    }
    @Test
    public void testMyComplexAdd(){
        String q = a.complexAdd(b).toString();
        String w = b.complexAdd(c).toString();
        String e = c.complexAdd(a).toString();
        assertEquals("2.0+1.0i",q);
        assertEquals("-5.0-3.0i",w);
        assertEquals("-3.0+4.0i",e);
    }
    @Test
    public void testMyComplexSub(){
        String r = a.complexSub(b).toString();
        String t = b.complexSub(c).toString();
        String y = c.complexSub(a).toString();
        assertEquals("2.0+7.0i",r);
        assertEquals("5.0-3.0i",t);
        assertEquals("-7.0-4.0i",y);
    }
    @Test
    public void testMyComplexMulti(){
        String u = a.complexMulti(b).toString();
        String i = b.complexMulti(c).toString();
        String o = c.complexMulti(a).toString();
        assertEquals("12.0-6.0i",u);
        assertEquals("15.0i",i);
        assertEquals("-10.0-20.0i",o);
    }
    @Test
    public void testMyComplexDiv(){
        String p = c.complexDiv(a).toString();
        assertEquals("-0.5+2.5i",p);
    }
    @Test
    public void testtoString(){
        assertEquals("2.0+4.0i",a.toString());
        assertEquals("-3.0i",b.toString());
        assertEquals("-5.0",c.toString());
    }
}

• 重构1：所有类都必须添加创建者信息
  
  

• 重构2：所有的覆写方法，必须加@Override注解
  
  

• 重构3：方法名，参数名，成员变量，局部变量都统一使用lowerCamelCase
  
  

• 重构4：在if/else/for/while/do语句中必须使用大括号，即使只有一行代码
  
  

• 重构后上传到搭档仓库的git log：
  
  

码云链接：

我的链接

搭档的链接

（五）java与密码学

1.实验要求：

参考 http://www.cnblogs.com/rocedu/p/6683948.html，以结对的方式完成Java密码学相关内容的学习，结合重构，git,代码标准。

2.实验过程：

我和搭档进行的是凯撒密码的实现。凯撒密码的加密和解密算法相当来说比较简单。

其加密过程如下：

若明文记为m，密文记为c，秘钥为k，加密变换记为Encrypt(k,m)，解密变换记为Decrypt(k,m)）。凯撒密码的加密过程可记为如下一个变换：

c≡m+k mod n （其中n为基本字符个数）

同样，解密过程可表示为：

m≡c+k mod n （其中n为基本字符个数）

加密代码为：

import java.util.Scanner;

public class JiaMi {
    public static void main(String[] args) {
        System.out.print("请输入明文：");
        Scanner a=new Scanner(System.in);
        String b=a.nextLine();
        System.out.print("请输入秘钥：");
        Scanner c=new Scanner(System.in);
        int key=c.nextInt();
        Encrypt(b, key);
    }

    public static void Encrypt(String str,int k){
        String s="";
        for (int i = 0; i < str.length(); i++) {
            char c=str.charAt(i);
            if(c>='a'&&c<='z'){
                c+=k%26;
                if(c<'a') {
                    c+=26;
                }
                if(c>'z') {
                    c-=26;
                }

            }else if(c>='A'&&c<='Z'){
                c+=k%26;
                if(c<'A') {
                    c+=26;
                }
                if(c>'Z') {
                    c-=26;
                }
            }
            s+=c;
        }
        System.out.println(str+" 加密为： "+s);
    }
}

解密代码为：

import java.util.Scanner;

public class JieMi {
    public static void main(String[] args) {
        System.out.print("请输入密文：");
        Scanner a=new Scanner(System.in);
        String b=a.nextLine();
        System.out.print("请输入秘钥：");
        Scanner c=new Scanner(System.in);
        int key=c.nextInt();
        Decrypt(b, key);
    }

    public static void Decrypt(String str,int k){
        String s="";
        for (int i = 0; i < str.length(); i++) {
            char c=str.charAt(i);
            if(c>='a'&&c<='z'){
                c-=k%26;
                if(c<'a') {
                    c+=26;
                }
                if(c>'z') {
                    c-=26;
                }

            }else if(c>='A'&&c<='Z'){
                c-=k%26;
                if(c<'A') {
                    c+=26;
                }
                if(c>'Z') {
                    c-=26;
                }
            }
            s+=c;
        }
        System.out.println(str+" 解密为： "+s);
    }
}

运行截图为：

实验感悟：

本次实验让我学会了对代码的规范修改，突然发现自己的代码还有很多的不足，不够规范，虽然有些问题不必非要体现出来，但是当规范后显得更加正式。还有对代码的重构，在不改变软件外部行为的基础上，改变软件内部的结构，使其更加易于阅读、易于维护和易于变更，非常强大。最后学到了将代码上传到搭档的码云里，感觉不一样。