2018-2019-2 20175218 实验三《敏捷开发与XP实践》实验报告

2018-2019-2 20175218 实验三《敏捷开发与XP实践》实验报告

姓名	陈敬勇
班级	1752
学号	20175218
实验序号	实验三
实验名称	敏捷开发与XP实践

实验内容

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

实验要求

1. 没有Linux基础的同窗建议先学习《Linux基础入门（新版）》《Vim编辑器》 课程
2. 完成实验、撰写实验报告，实验报告以博客方式发表在博客园，注意实验报告重点是运行结果，遇到的问题(工具查找，安装，使用，程序的编辑，调试，运行等)、解决办法（空洞的方法如“查网络”、“问同窗”、“看书”等一概得0分）以及分析（从中能够获得什么启示，有什么收获，教训等）。报告能够参考范飞龙老师的指导
3. 严禁抄袭，有该行为者实验成绩归零，并附加其余惩罚措施。

1、敏捷开发与XP实践-1

一、实验要求

• http://www.cnblogs.com/rocedu/p/4795776.html, Eclipse的内容替换成IDEA
• 参考 http://www.cnblogs.com/rocedu/p/6371315.html#SECCODESTANDARD 安装alibaba 插件，解决代码中的规范问题。
• 在IDEA中使用工具（Code->Reformate Code）把下面代码从新格式化，再研究一下Code菜单，找出一项让本身感受最好用的功能。提交截图，加上本身学号水印。

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

二、实验步骤

一、安装 Alibaba Java Code Guidelines 插件

1. 首先在工具箱中打开 IntelliJ IDEA UItimate 软件，如图：

1. 点击 File，选择其中的 Settings ,如图：

1. 点击 Plugins ,在 Marketplace 栏下搜索 alibaba，如图：

1. 找到 Alibaba Java Code Guidelines，点击 Install便可下载安装 Alibaba Java Code Guidelines 插件，如图：

二、规范代码

1. 建立项目，将要规范的代码打上去，如图：

1. 右击项目，选择编码规约扫描，如图：

1. 以后出现不规范的地方，而后依次进行更正，如图：

1. 规范后的代码：

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

三、格式化代码

1. 点击 Code ，选择 Reformate Code，对代码进行格式化，如图：

四、研究Code菜单

1. 点击 Code ，选择 Optimize Imports ，能够对输入端进行优化，如图：

2、敏捷开发与XP实践-2

一、实验要求

• 在码云上把本身的学习搭档加入本身的项目中，确认搭档的项目加入本身后，下载搭档实验二的Complex代码，加入很多于三个JUnit单元测试用例，测试成功后git add .; git commit -m "本身学号 添加内容"；git push;

• 提交搭档项目git log的截图，包含上面git commit的信息，并加上本身的学号水印信息。

  二、实验步骤

  一、进入搭档实验二的Complex代码的码云仓库连接，找到搭档代码

• 搭档代码以下

public class Complex {
    double RealPart=0;
    double ImagePart=0;
    public Complex(){}
    public Complex(double RealPart,double ImagePart){
        this.RealPart=RealPart;
        this.ImagePart=ImagePart;

    }
    public double getRealPart(){
        return RealPart;
    }
    public double getImagePart(){
        return ImagePart;
    }
    public String toString(){
        String s = "";
        double r=RealPart;
        double i=ImagePart;
        if(r==0&&i==0){
            s="0";
        }
        else if(r==0&&i!=0){
            s=i+"i";
        }
        else if(r!=0&&i==0){
            s=r+"";
        }
        else if(r!=0&&i<0){
            s=r+""+i+"i";
        }
        else
        {
            s=r+"+"+i+"i";
        }
        return s;
    }
    public boolean equals(Object obj){
        if(this==obj){
            return true;
        }
        else return false;
    }

    public Complex ComplexAdd(Complex a){
        return new Complex(RealPart+a.getRealPart(),ImagePart+a.getImagePart());
    }
    public Complex ComplexSub(Complex a){
        return new Complex(RealPart-a.getRealPart(),ImagePart-a.getImagePart());
    }
    public Complex ComplexMulti(Complex a){
        double r=RealPart*a.getRealPart()-ImagePart*a.getImagePart();
        double i =ImagePart*a.getRealPart()+RealPart*a.getImagePart();
        return new Complex(r,i);
    }
    public Complex ComplexDiv(Complex a){
        double r=(RealPart * a.ImagePart + ImagePart * a.RealPart) / (a.ImagePart * a.ImagePart + a.RealPart * a.RealPart);
        double i=(ImagePart * a.ImagePart + RealPart * a.RealPart) / (a.RealPart * a.RealPart + a.RealPart * a.RealPart);
        return new Complex(r,i);
    }


}

• 搭档代码仓库如图

二、对搭档的complex代码进行测试

• 测试代码以下

public class Complex {
    double RealPart=0;
    double ImagePart=0;
    public Complex(){}
    public Complex(double RealPart,double ImagePart){
        this.RealPart=RealPart;
        this.ImagePart=ImagePart;

    }
    public double getRealPart(){
        return RealPart;
    }
    public double getImagePart(){
        return ImagePart;
    }
    public String toString(){
        String s = "";
        double r=RealPart;
        double i=ImagePart;
        if(r==0&&i==0){
            s="0";
        }
        else if(r==0&&i!=0){
            s=i+"i";
        }
        else if(r!=0&&i==0){
            s=r+"";
        }
        else if(r!=0&&i<0){
            s=r+""+i+"i";
        }
        else
        {
            s=r+"+"+i+"i";
        }
        return s;
    }
    public boolean equals(Object obj){
        if(this==obj){
            return true;
        }
        else return false;
    }

    public Complex ComplexAdd(Complex a){
        return new Complex(RealPart+a.getRealPart(),ImagePart+a.getImagePart());
    }
    public Complex ComplexSub(Complex a){
        return new Complex(RealPart-a.getRealPart(),ImagePart-a.getImagePart());
    }
    public Complex ComplexMulti(Complex a){
        double r=RealPart*a.getRealPart()-ImagePart*a.getImagePart();
        double i =ImagePart*a.getRealPart()+RealPart*a.getImagePart();
        return new Complex(r,i);
    }
    public Complex ComplexDiv(Complex a){
        double r=(RealPart * a.ImagePart + ImagePart * a.RealPart) / (a.ImagePart * a.ImagePart + a.RealPart * a.RealPart);
        double i=(ImagePart * a.ImagePart + RealPart * a.RealPart) / (a.RealPart * a.RealPart + a.RealPart * a.RealPart);
        return new Complex(r,i);
    }


}

• 搭档complex代码测试成功如图

三、上传代码

• 代码成功上传截图

• git log截图

3、敏捷开发与XP实践-3

一、实验要求

• http://www.cnblogs.com/rocedu/p/4795776.html, Eclipse的内容替换成IDEA

• 完成重构内容的练习，下载搭档的代码，至少进行三项重构，提交重构后代码的截图，加上本身的学号水印。提交搭档的码云项目连接。

  二、实验步骤

  一、重构的概念

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

二、重构的动机

• 增长新功能
• 原有功能有BUG
• 改善原有程序的结构
• 优化原有系统的性能

三、重构的价值

• 第一种和第二种动机，都是源于客户的功能需求，而第四种是源于客户的非功能需求。软件的外部质量，其衡量的标准就是客户对软件功能需求与非功能需求的满意度。它涉及到一个企业、一个软件的信誉度与生命力，所以为全部软件企业所高度重视。要提升软件内部质量，毫无疑问就是软件修改的第三个动机：改善原有程序的结构。它的价值是隐性的，并不体如今某一次或两次开发中，而是逐渐体如今往后长期维护的软件过程当中。
• 高质量的软件，能够保证开发人员（即便是新手）可以轻易看懂软件代码，可以保证往后的每一次软件维护均可以轻易地完成（不论软件经历了多少次变动，维护了多少年），可以保证往后的每一次需求变动都可以轻易地进行（而不是伤筋动骨地大动）。要作到这几点其实并不容易，它须要咱们持续不断地对系统内部质量进行优化与改进。

四、下载搭档代码并进行重构

• 搭档的complex代码

public class Complex {
    double RealPart=0;
    double ImagePart=0;
    public Complex(){}
    public Complex(double RealPart,double ImagePart){
        this.RealPart=RealPart;
        this.ImagePart=ImagePart;

    }
    public double getRealPart(){
        return RealPart;
    }
    public double getImagePart(){
        return ImagePart;
    }
    public String toString(){
        String s = "";
        double r=RealPart;
        double i=ImagePart;
        if(r==0&&i==0){
            s="0";
        }
        else if(r==0&&i!=0){
            s=i+"i";
        }
        else if(r!=0&&i==0){
            s=r+"";
        }
        else if(r!=0&&i<0){
            s=r+""+i+"i";
        }
        else
        {
            s=r+"+"+i+"i";
        }
        return s;
    }
    public boolean equals(Object obj){
        if(this==obj){
            return true;
        }
        else return false;
    }

    public Complex ComplexAdd(Complex a){
        return new Complex(RealPart+a.getRealPart(),ImagePart+a.getImagePart());
    }
    public Complex ComplexSub(Complex a){
        return new Complex(RealPart-a.getRealPart(),ImagePart-a.getImagePart());
    }
    public Complex ComplexMulti(Complex a){
        double r=RealPart*a.getRealPart()-ImagePart*a.getImagePart();
        double i =ImagePart*a.getRealPart()+RealPart*a.getImagePart();
        return new Complex(r,i);
    }
    public Complex ComplexDiv(Complex a){
        double r=(RealPart * a.ImagePart + ImagePart * a.RealPart) / (a.ImagePart * a.ImagePart + a.RealPart * a.RealPart);
        double i=(ImagePart * a.ImagePart + RealPart * a.RealPart) / (a.RealPart * a.RealPart + a.RealPart * a.RealPart);
        return new Complex(r,i);
    }


}

• 重构1：重写搭档代码 toString 时，加入的@override标志

• 重构2：在搭档的代码中，添加做者和日期

• 重构3：在搭档的代码中，对类中的变量和方法进行封装

• 重构4：在搭档的代码中，规范方法名，注意首字母小写

• 重构5：在搭档的代码中，应用修改精简过长的方法

• 对搭档的代码进行重构后的新代码以下：

/**
 * @author  cjy
 * @date  2019/5/1
 */
public class Complex {
    private double RealPart=0;
    private double ImagePart=0;
    public Complex(){}
    public Complex(double RealPart,double ImagePart){
        this.RealPart=RealPart;
        this.ImagePart=ImagePart;

    }
    public double getRealPart(){
        return RealPart;
    }
    public double getImagePart(){
        return ImagePart;
    }

    @Override
    public String toString(){
        String s = "";
        double r=RealPart;
        double i=ImagePart;
        if(r==0&&i==0){
            s="0";
        }
        else if(r==0&&i!=0){
            s=i+"i";
        }
        else if(r!=0&&i==0){
            s=r+"";
        }
        else if(r!=0&&i<0){
            s=r+""+i+"i";
        }
        else
        {
            s=r+"+"+i+"i";
        }
        return s;
    }
    public boolean equals(Object obj){
        if(this==obj){
            return true;
        }
        else return false;
    }

    public Complex ComplexAdd(Complex a){
        return new Complex(RealPart+a.getRealPart(),ImagePart+a.getImagePart());
    }
    public Complex ComplexSub(Complex a){
        return new Complex(RealPart-a.getRealPart(),ImagePart-a.getImagePart());
    }
    public Complex ComplexMulti(Complex a){
        double r=RealPart*a.getRealPart()-ImagePart*a.getImagePart();
        double i =ImagePart*a.getRealPart()+RealPart*a.getImagePart();
        return new Complex(r,i);
    }
    public Complex ComplexDiv(Complex a){
        double r=(RealPart * a.ImagePart + ImagePart * a.RealPart) / (a.ImagePart * a.ImagePart + a.RealPart * a.RealPart);
        double i=(ImagePart * a.ImagePart + RealPart * a.RealPart) / (a.RealPart * a.RealPart + a.RealPart * a.RealPart);
        return new Complex(r,i);
    }


}

• 重构后的代码截图

4、敏捷开发与XP实践-4

一、实验要求

• 参考 http://www.cnblogs.com/rocedu/p/6683948.html，以结对的方式完成Java密码学相关内容的学习，结合重构，git,代码标准。
• 提交学习成果码云连接和表明性成果截图，要有学号水印。
• Java安全体系结构总共分为4个部分：
  • JCA（ Java Cryptography Architecture， Java加密体系结构）：JCA提供基本的加密框架， 如证书、 数字签名、消息摘要和密钥对产生器。
  • JCE（ Java Cryptography Extension， Java加密扩展包）：JCE在JCA的基础上做了扩展， 提供了各类加密算法、 消息摘要算法和密钥管理等功能。JCE的实现主要在javax.crypto包（ 及其子包） 中
  • JSSE（ Java Secure Sockets Extension， Java安全套接字扩展包）：JSSE提供了基于SSL（ Secure Sockets Layer，安全套接字层） 的加密功能。 在网络的传输过程当中， 信息会通过多个主机（颇有可能其中一台就被窃听） ， 最终传送给接收者， 这是不安全的。这种确保网络通讯安全的服务就是由JSSE来提供的。

  • JAAS（ Java Authentication and Authentication Service， Java鉴别与安全服务）：JAAS提供了在Java平台上进行用户身份鉴别的功能。

    二、实验步骤

    Java对称加密-DES算法

1. 加密过程步骤
   • （1）从文件中获取密钥
   • （2）建立密码器（Cipher对象）
   • （3）初始化密码器
   • （4）获取等待加密的明文
   • （5）执行加密
   • （6）处理加密结果
2. 解密过程步骤
   • （1）获取密文
   • （2）获取密钥
   • （3）建立密码器（Cipher对象）
   • （4）初始化密码器
   • （5）执行解密
     （其余加密算法相似）

实验代码

public class Caesar {
    public static void main(String[] args) throws Exception{
        String s=args[0];
        int key=Integer.parseInt(args[1]);
        String es="";
        for(int i=0;i<s.length( );i++)
        {  char c=s.charAt(i);
            // 是小写字母
            if(c>='a' && c<='z')
                //移动key%26位
            { c+=key%26;
                if(c<'a') {
                    //向左超界
                    c+=26;
                }
                if(c>'z') {
                    //向右超界
                    c-=26;
                }
            }
            // 是大写字母
            else if(c>='A' && c<='Z')
            {  c+=key%26;
                if(c<'A') {
                    c+=26;
                }
                if(c>'Z') {
                    c-=26;
                }
            }
            es+=c;
        }
        System.out.println(es);
    }
}

实验截图

5、代码托管

码云连接：点击进入连接

• 搭档的码云连接：
  • https://gitee.com/zzm-zcc/zhang_zhi_min/tree/master/%E5%AE%9E%E9%AA%8C2
• 个人码云连接：
  • https://gitee.com/cjy-123/20175218cjy/tree/master/Experiment2/test4

6、实验心得

经过这一次的实验，我对Java的学习更加深刻了。特别是对一个程序的理解。之前觉得只要把程序弄出来，可以实现想要的做用就能够了。可是，作了实验三以后，我知道了，一个程序作出来不是这么简单的，须要咱们考虑到不少方面。就像此次实验，咱们写完程序，还要学会规范程序。而后，另外一方面就是，还经过学习Java，联系到了其余学科，这样即兼顾了两门学科的学习，还知道了两门学科的联系，能把两科都学得更好。