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

实验内容

XP基础
XP核心实践
相关工具

实验要求

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);

    }

}

运行截图为：

实验感悟：

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