首页 > 其他 > 详细

软件工程(2018)第三次个人作业

时间:2018-04-01 14:05:25      阅读:173      评论:0      收藏:0      [点我收藏+]

软件工程(2018)第三次个人作业


前方高能:本次作业中含有大量基础知识,请不要嘲笑我QAQ

第三次作业来了。选择看似相比有难度的(1)(其实是看不懂(2)在干什么)

题目要求:题目(1):最大连续子数组和(最大子段和)

背景
问题: 给定n个整数(可能为负数)组成的序列a[1],a[2],a[3],…,a[n],求该序列如a[i]+a[i+1]+…+a[j]的子段和的最大值。当所给的整数均为负数时定义子段和为0,依此定义,所求的最优值为: Max{0,a[i]+a[i+1]+…+a[j]},1<=i<=j<=n
例如,当(a[1],a[2],a[3],a[4],a[5],a[6])=(-2,11,-4,13,-5,-2)时,最大子段和为20。

读完题目,第一想到就是数组解决问题。定义数组a[]输入变量后,遍历数组,将数组每个元素分别开始向后逐步取和,将这些和存到数组b[]中,最后比较数组b[]中,取最大值即可。

看起来用到的方法都是数组的基本方法,第三次作业果然还是简单(心里长舒一口气)

所以我的代码构思是在某堂课上随手完成的,大体思路算法有了后,在自己计算机上实现就行

但是实现又遇到了各种问题,一些在C上容易实现的方法,在Eclipse上还没有试过

问题(1):Java中数组的定义(没错第一个问题就是这个)

解决:参考《疯狂JAVA讲义》。JAVA中数组可动态定义或静态定义,前者定义后分配指定个数个内存,后者定义后直接给数组赋值,由系统来确定分配多少个空间。

        int[] intArr;
        intArr=new int[] {5,6,8,20};//静态定义
        int[] intArr2= {5,6,8,21};//简化静态定义方式
        int[] intArr3;
        intArr3=new int[4];//动态定义
        int[] intArr4=new int[4];//简化动态定义方式

与此同时,我想着把JAVA中所有关于数组的基本方法学习一下,数组的输入输出当然是最重要的

输入:利用循环逐个输入元素,循环变量控制条件是数组的length变量,此时须注意动态定义中会使length有可能大于我们程序运行时要输入的元素个数,在此我有疑问,JAVA是否可以实现动态数组,我们先完成作业,然后再考虑这个

而JAVA中输入方法为下

        Scanner x = new Scanner(System.in);
        int n1=x.nextInt();

输出:利用循环遍历数组元素,逐个输出,输出方法如下

        System.out.println();//ln是换行

同时,了解到JAVA中有foreach循环遍历数组,看起来能简化代码

        for(int m:intArr)
            System.out.println(m);//foreach用法,注意m相当于一个临时变量,所以foreach方法无法完成数组的输入。

由问题(1)引发的关于数组的基本用法先学到这里,基本够用

这样程序代码可以写了,以下是我的程序代码

import java.util.Scanner;

public class Sz
{
    int n;//数组元素个数
    static int[] a=new int[10] ;//输入数组
    static int[] b=new int[10];//以每个元素为首元素的组合集
    public static void createArray(int n)//数组输入
    {
        for(int i=0;i<n;i++)
        {
            Scanner x = new Scanner(System.in);
            int n1=x.nextInt();
            a[i]=n1;
        }
    }
    public static int getMax(int i,int n)//生成数组第i个元素为首元素的组合最大的组合
    {
        int[] c=new int[10];//用于循环中求该元素为首元素的组合中最大的组合
        c[i]=a[i];
        for(int j=i;j<n-1;j++)
        {
            c[j+1]=c[j]+a[j+1];
        }
        for(int m:c)
        {
            if(b[i]<m)
                b[i]=m;
        }
        return b[i];
    }
    public static int getbMax(int[] b)//将b[]中最大元素筛选出来
    {
        int max=0;
        for(int m:b)
        {
            if(max<m)
                max=m;
        }
        return max;
    }

    public static void main(String[] args)
    {
        Scanner x = new Scanner(System.in);
        int n=x.nextInt();
        createArray(n);
        for(int i=0;i<n;i++)
        {
            getMax(i,n);
        }
        System.out.println(getbMax(b));
    }
}

附上程序运行截图

样例1:数组(a[1],a[2],a[3],a[4],a[5],a[6])=(-2,11,-4,13,-5,-2)

技术分享图片

样例2:(a[1],a[2],a[3],a[4],a[5])=(-2,6,4,-7,-2)

技术分享图片

注:以上代码是我最终版本代码,没以下问题,我是先写完程序再写博客,所以要保证代码都OK才会回忆我当时编程的心路过程(我觉得边写代码边写博客真的破坏思路,当然我的梦想是能边写边编而不影响思路,正如老师说过的直播写代码,我觉得OK)(我也有主播梦想)

写代码后调试修改了一些小错误,问题不大的,没有写出来。接下来碰到一个我不太理解的错误,虽然Eclipse强大的帮助修改能力教我将所以变量、方法加上static属性,但是我还是要弄懂有啥区别

问题(2)JAVA中static的用法

老规矩,上网学

这次应该是问题明确又基础,很容易找到回答

static表示“全局”或者“静态”的意思,用来修饰成员变量和成员方法,也可以形成静态static代码块,但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说,它不依赖类特定的实例,被类的所有实例共享。

只要这个类被加载,Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此,static对象可以在它的任何对象创建之前访问,无需引用任何对象。

用public修饰的static成员变量和成员方法本质是全局变量和全局方法,当声明它类的对象市,不生成static变量的副本,而是类的所有实例共享同一个static变量。

static变量前可以有private修饰,表示这个变量可以在类的静态代码块中,或者类的其他静态成员方法中使用(当然也可以在非静态成员方法中使用--废话),但是不能在其他类中通过类名来直接引用,这一点很重要。实际上你需要搞明白,private是访问权限限定,static表示不要实例化就可以使用,这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

static修饰的成员变量和成员方法习惯上称为静态变量和静态方法,可以直接通过类名来访问,访问语法为:
类名.静态方法名(参数列表...)
类名.静态变量名

用static修饰的代码块表示静态代码块,当Java虚拟机(JVM)加载类时,就会执行该代码块(用处非常大,呵呵)。

1、static变量
按照是否静态的对类成员变量进行分类可分两种:一种是被static修饰的变量,叫静态变量或类变量;另一种是没有被static修饰的变量,叫实例变量。

两者的区别是:
对于静态变量在内存中只有一个拷贝(节省内存),JVM只为静态分配一次内存,在加载类的过程中完成静态变量的内存分配,可用类名直接访问(方便),当然也可以通过对象来访问(但是这是不推荐的)。
对于实例变量,没创建一个实例,就会为实例变量分配一次内存,实例变量可以在内存中有多个拷贝,互不影响(灵活)。

所以一般在需要实现以下两个功能时使用静态变量:
?  在对象之间共享值时
?  方便访问变量时


2、静态方法
静态方法可以直接通过类名调用,任何的实例也都可以调用,
因此静态方法中不能用this和super关键字,不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法),只能访问所属类的静态成员变量和成员方法。
因为实例成员与特定的对象关联!这个需要去理解,想明白其中的道理,不是记忆!!!
因为static方法独立于任何实例,因此static方法必须被实现,而不能是抽象的abstract。

例如为了方便方法的调用,Java API中的Math类中所有的方法都是静态的,而一般类内部的static方法也是方便其它类对该方法的调用。

静态方法是类内部的一类特殊方法,只有在需要时才将对应的方法声明成静态的,一个类内部的方法一般都是非静态的

以上内容摘自这篇博客(特意看了下欢迎转载,具体示例也有)

个人总结:static修饰的变量和方法称为静态变量,可以在类中直接引用变量、直接调用方法

问题解决后,经过测试也都ok,突然想到,我用Eclipse调试不像c一样熟练,而且我还没掌握Eclipse调试的方法

问题(3)Eclipse中如何调试

网上学习。Eclipse支持设置断点进行调试(否则程序直接运行到底)。右键代码行头数字设置breakpoint(或直接双击数字)(breakpoint更有详细设置,支持条件断点调试,有丶厉害啊这个)F5逐步调试,F6具体进入方法,F7跳出方法,CTRL+F2结束调试,嗯,我记住了

调试过程中,可将鼠标直接放在程序变量上显示变量,更可以设置出Variables窗口查看其余变量(Window——show view——Other——debug——Variables),这样跟C语言调试几乎完美相同了,或许有更多功能待挖掘

接下来是测试

覆盖方法

(1))语句覆盖:选择合适用例,所有语句被执行一次。

语句覆盖是指选择足够的测试用例,使得运行这些测试用例时,被测程序的每一个语句至少执行一次,其覆盖标准无法发现判定中逻辑运算的错误。

(2)判定覆盖:每个判定至少取一次真、一次假。

判定覆盖是设计足够多的测试用例,使得程序中的每一个判断至少获得一次“真”和一次“假”,即使得程序流程图中的每一个真假分支至少被执行一次。

(3)条件覆盖:每个条件的各种可能结果至少满足一次。

条件覆盖是指选择足够的测试用例,使得运行这些测试用例时,判定中每个条件的所有可能结果至少出现一次,但未必能覆盖全部分支。

(4)判定条件覆盖:同时满足判断覆盖和条件覆盖。

判定条件覆盖是设计足够的测试用例,得使判断中每个条件的所有可能取值至少执行一次,同时每个判断本身所有可能结果也至少执行一次。缺点是忽略了条件的组合情况。

(5)条件组合覆盖:所有组合情况都要覆盖一次。

在白盒测试法中,选择足够的测试用例,使得每个判定中条件的各种可能组合都至少出现一次。显然,满足“条件组合覆盖”的测试用例是一定满足“判定覆盖”、“条件覆盖”和“判定/条件覆盖”的。

选定的覆盖方法(判定/条件覆盖)我采用的是判定条件覆盖:

(1)max>b[] max>0

(2)max>b[] max=0

(3)max<b[] max>0

(4)max<b[] max=0

选择用例:

(1)测试用例:{-2,11,-4,9}
(2)测试用例:{-2,-3,-4,-5}
(3)测试用例:{1,2,3,4}
(4)测试用例:{-5,-4,-3,-1}

建立JUNIT测试单元,测试代码如下

import static org.junit.Assert.*;

import org.junit.Test;

public class SzTest
{
    int[] a=new int[] {-2,11,-4,9};
    static int[] b=new int[] {14,16,5,9};
    @Test
    public void testGetMax()
    {
        assertEquals(14,new Sz().getMax(0,4));
        assertEquals(16,new Sz().getMax(1,4));
        assertEquals(5,new Sz().getMax(2,4));
        assertEquals(9,new Sz().getMax(3,4));
    }
    @Test
    public void testGetbMax()
    {
        assertEquals(16,new Sz().getbMax(b));
    }
}

进行测试,出现问题(4)测试失败

如图

技术分享图片

java.lang.AssertionError: expected:<14> but was:<0>

测试结果是0?不应该啊。于是设置断点逐步调试,发现问题。由于Sz中a[]是静态变量,在那个类中可以被程序直接引用修改。而在Sztest类的调用中,Sz的a[]的值一直为0。所以程序输出为0。为了测试用,我将Sz.getMax中临时定义a[]的值为{-2,11,-4,9}(仅测试用,不影响原程序),并且将Sztest中定义的a[]删除(这的a[]没有意义了),重新调试,OK。如图。

技术分享图片
接下来将剩余测试测完,直接列图了
技术分享图片

注:这里的0是因为都是负数,所以默认全用0取代

技术分享图片
技术分享图片

注:这里同理

单元测试完成!

后记:本次作业完成,问题也都圆满解决,最后调试出现的问题是靠自己调试分析完成有点成就感。下次见~!

对了,动态数组还没实现!

我觉得,如果能像建立链表一样建立一个元素,然后每次输入元素都连接上一个元素(链表靠地址连接,数组就靠建立数组时分配的连续内存这个顺序连接),输入结束后,数组也建立完成。通过思考和逐渐实践,我觉得可行,但是总感觉自己理解不深导致没有弄出来。最后在网上发现了跟我思路特别像的大佬实现了(侵删)

    // 定义一个初始长度为0的数组,用来缓存数据
    private String[] src = new String[0];
    // 增加
    public void add(String s)
    {
        //定义新数组,长度是原数组长度+1
        String[] dest = new String[src.length+1];
        //将原数组的数据拷贝到新数组
        System.arraycopy(src, 0, dest, 0, src.length);
        //将新元素放到dest数组的末尾
        dest[src.length]=s;
        //将src指向dest
        src=dest;
    }

豁然开朗,突然想起来C语言中例如a[]中的"a"实际上是一个地址,可以指向别的地址,这样我就可以将两个数组的"数组头"连接起来,模拟建立链表时光标的移动。不过我有疑问了:既然是指向,那原数组是不是应该及时删除从而减少内存呢?删除后才可以算做动态数组的完美建立。感觉又学到了丶东西。

本次作业也收获颇丰呢(最终代码)

软件工程(2018)第三次个人作业

原文:https://www.cnblogs.com/L1aw/p/8686341.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!