zoukankan html css js c++ java

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

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

实验内容

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

实验要求

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

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

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

2、实验步骤

1、安装 Alibaba Java Code Guidelines 插件

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

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

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

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

2、规范代码

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

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

之后出现不规范的地方，然后依次进行更正，如图：

规范后的代码：

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

3、格式化代码

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

4、研究Code菜单

点击 Code ，选择 Optimize Imports ，可以对输入端进行优化，如图：

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

1、实验要求

在码云上把自己的学习搭档加入自己的项目中，确认搭档的项目加入自己后，下载搭档实验二的Complex代码，加入不少于三个JUnit单元测试用例，测试成功后git add .; git commit -m "自己学号添加内容"；git push;
提交搭档项目git log的截图，包含上面git commit的信息，并加上自己的学号水印信息。

2、实验步骤

1、进入搭档实验二的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);
    }


}

搭档代码仓库如图

2、对搭档的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代码测试成功如图

3、上传代码

代码成功上传截图

git log截图

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

1、实验要求

http://www.cnblogs.com/rocedu/p/4795776.html, Eclipse的内容替换成IDEA
完成重构内容的练习，下载搭档的代码，至少进行三项重构，提交重构后代码的截图，加上自己的学号水印。提交搭档的码云项目链接。

2、实验步骤

1、重构的概念

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

2、重构的动机

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

3、重构的价值

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

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

搭档的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);
    }


}

重构后的代码截图

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

1、实验要求

参考 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平台上进行用户身份鉴别的功能。

2、实验步骤

Java对称加密-DES算法

加密过程步骤
- （1）从文件中获取密钥
- （2）创建密码器（Cipher对象）
- （3）初始化密码器
- （4）获取等待加密的明文
- （5）执行加密
- （6）处理加密结果
解密过程步骤
- （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);
    }
}

实验截图

五、代码托管

码云链接：点击进入链接

搭档的码云链接：
- https://gitee.com/zzm-zcc/zhang_zhi_min/tree/master/实验2
我的码云链接：
- https://gitee.com/cjy-123/20175218cjy/tree/master/Experiment2/test4

六、实验心得

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

查看全文

相关阅读:
约瑟夫环-我的解答与迷宫
 数据结构实验一
 typedef struct 是什么意思
 编程名言名句
 创建单链表
 离散实验一
 Angela Merkel poised for record poll win and historic third term
我的生活计划-贵在执行，贵在坚持
 考研经验
 2010年河南省普通高校招生本科一批院校平行投档分数线（理科）

原文地址：https://www.cnblogs.com/cjy-123/p/10802582.html