20155219 2016-2017-2 《Java程序设计》第5周学习总结

教材学习内容总结

异常处理

语法与继承构架
异常就是程序在运行时出现的不正常情况。java中的错误以对象的方式呈现为

java.lang.Throwable

1.Throwable定义了取得错误信息、堆栈追踪等方法，它有两个子类：java.lang.Error与java.lang.Exception。如果某个声明方法会抛出Throeable或子类实例，只要不属于Error或java.lang.RuntimeException或其子类实例，就必须明确使用try、catch语句加以处理，或用throws声明这个方法会抛出异常。

2.Error与其子类实例代表严重系统错误，Java应用程序本身无力回复。

3.Exception与其子类实例代表程序设计本身的错误，通常称错误处理为异常处理。受检异常要求明确使用语法加以处理，非受检异常也叫执行时期异常，编译程序不会强迫必须在语法上加以处理。

4.如果父类异常对象在子类异常对象前被捕捉，则catch子类异常对象的区块永远不会被执行。

5.catch括号中列出的异常不得有继承关系。

6."\d*"是规则表达式，会检测字符串中的字符是否为数字。

使用try、catch语法。JVM会先尝试执行try区块中的代码，如果发生错误就会调理错误发生点，然后比较catch括号中声明类型是否符合被抛出的错误对象类型，如果是就执行catch区块中的代码。

import java.util.*;
public class Average2{
    public static void main(String[] args){
        try{
            Scanner console=new Scanner(System.in);
            double sum=0;
            int count=0;
            while(true){
                int number=console.nextInt();
                if(number==0){
                    break;
                }
                sum+=number;
                count++;
            }
            System.out.printf("平均 %.2f%n",sum/count);
        }catch (InputMismatchException ex){
            System.out.printf("必须输入整数");
        }
    }
}

的各种子类实例。因此也提供了特有的处理异常的语句。

Exception与其子类实例代表程序设计本身的错误，通常称错误处理为异常处理。受检异常要求明确使用语法加以处理，非受检异常也叫执行时期异常，编译程序不会强迫必须在语法上加以处理。
如果父类异常对象在子类异常对象前被捕捉，则catch子类异常对象的区块永远不会被执行。
catch括号中列出的异常不得有继承关系。
"\d*"是规则表达式，会检测字符串中的字符是否为数字，如下代码：

static int nextInt(){
        String input=console.next();
        while(!input.matches("\\d*")){
            System.out.println("请输入数字");
            input=console.next();
        }
        return Integer.parseInt(input);//使用parseint（）方法转化为整形。
    }

throw与catch

1.FileInputStream可以指定档名来开启与读取文档内容，但是在创建时会抛出FileNotFoundException错误。

2.抛出受检异常表示客户端有能力且应处理异常，必须在方法上使用throws声明。

3.抛出非受检异常表示客户端调用方法的时机错误，要求客户端修正漏洞后再调用方法，不用throws声明。

4.catch区块进行完部分错误处理后可以使用throw将异常再抛出。

如下代码：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class h {
    public static void main(String[] args) {
    }
    public static String readFile(String name) throws FileNotFoundException{
        StringBuilder text=new StringBuilder();
        try(Scanner aa=new Scanner(new FileInputStream(name)))
        {
            while (aa.hasNext())
            {
                text.append(aa.nextLine()).append('\n');
            }
        }
        return text.toString();
    }
}

堆栈追踪

直接调用异常对象的printStackTrace()方法是查看堆栈追踪最简单的方法。堆栈追踪信息会显示异常类型，最顶层是异常的根源。使用getStackTrace()可以取得个别的堆栈追踪元素进行处理，会返回StackTraceElement数组，数组中索引0为异常根源的相关信息。

public class StackTraceDemo{
    public static void main(String[] args){
        try{
            c();
        }catch(NullPointerException ex){
            ex.printStackTrace();
        }
    }
    static void c(){
        b();
    }
            static void b(){
        a();
    }
    static String a(){
        String text=null;
        return text.toUpperCase();
    }
}

输出如下图

fillInStackTrace()方法会让异常堆栈起点为重抛异常的地方，并返回Throwable对象。

...
    static void c(){
        try{
            b();
        }catch(NullPointerException ex){
            ex.printStackTrace();
            Throwable t=ex.fillInStackTrace();
            throw (NullPointerException) t;
        }
    }
    ...

输出如下图

要注意的是，throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象。下面的操作是错误的：

throw new String(“exception”);

这是因为String 不是Throwable 类的子类。如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。

如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException，则该方法的调用者可选择处理该异常。

finally

1.无论try区块中有无发生异常，若有撰写finally区块，则finally区块一定会被执行。

2.如果撰写的流程中先return后有finally区块，那finally区块会先执行完后再返回值。

public class FinallyDemo{
    public static void main(String[] args){
        System.out.println(test(true));
    }
    static int test(boolean flag){
        try{
            if(flag){
                return 1;
            }
        }finally{
            System.out.println("finally...");
        }
        return 0;
    }
}

输出结果如下：

尝试关闭资源语法。尝试自动关闭资源的对象撰写在try之后的括号中，如果无须catch处理任何异常可以不用撰写，也不用撰写finally自行尝试关闭资源。
尝试关闭资源语法可套用的对象必须操作java.lang.AutoCloseable接口，同时关闭两个以上的对象资源时中间以分号间隔，越后面的越早被关闭。
collection架构

1.目前为止已学过的收集对象的方式是使用object数组。收集对象的行为，如新增对象的add()方法、移除对象的remove()方法等，都是定义在java.util.Collection中。既然能收集对象，也能逐一取得对象，是java.lang.Iterable定义的行为。

2.收集时记录每个对象的索引顺序，并可依索引取回对象，此行为定义在java.util.List接口中；收集的对象不重复，具有集合的行为，则由java.util.Set定义；收集对象时以队列方式排列，收集的对象加入至尾端，取得对象时从前端，用java.util.Queue；对Queue的两端进行加入、移除等动作，用java.util.Deque。

List

1.ArrayList特性：ArrayList搜集对象时使用数组，由于数组在内存中是连续线性空间，根据索引随机存取时速度快，所以适合排序的时候用，可得到较好的速度表现。

2.LinkedList特性：LinkedList采用了链接结构，每次新增对象后会形成链状结构，链接的每个元素会参考至下一个元素，有利于调整索引顺序。

Set：判断对象是否重复时会调用hashCode()和equals()方法，且必须同时操作。

Queue：

1.Queue具有Collection的add（）、remove（）、element（）等方法，也定义了自己的offer（）、poll（）与peek（）等方法。最主要的差别在于，前者操作失败时会抛出异常，而后者操作失败时会返回特定值。

2.Queue的子接口Deque在队列前端加入对象与取出对象，在队列尾端加入对象与取出对象。其中定义的addFirst（）、removeFirst（）、getFirst（）、addLast（）、removeLast（）、getLast（）等方法，操作失败时会抛出异常，而offerFirst（）、pollFirst（）、peekFirst（）、offerLast（）、pollLast（）、peekLast（）等方法，操作失败时会返回特定值。

操作comparable

Collection的sort（）方法要求被排序的对象必须操作java.lang.Comparable接口。Collection的sort（）方法在取得a对象与b对象进行比较时，会先将a对象扮演为Comparable，然后调用a.compareTo（b），如果a对象顺序上小于b对象则返回小于0的值，若顺序上相等则返回0，若顺序上a大于b则返回大于0的值。（Integer有操作Comparable的接口）

Collections的sort（）方法有另一个重载版本，可接受java.util.Comparator接口的操作对象，如果使用这个版本，排序方式将根据Comparator的compare（）定义来决定。代码如下：

import java.util.*;
import static java.util.Comparator.*;
public class Sort6 {
    public static void main(String[] args){
        List words=Arrays.asList("B","X","A","M",null,"F","W","O",null);
        words.sort(nullsFirst(reverseOrder()));
        System.out.println(words);
    }
}

访问Map键值

1.如果想取得Map中所有的键，可以调用Map的keySet（）返回Set对象。

2.键是不重复的。

3.如果想取得Map中所有的值，则可以使用values（）返回Collection对象。

4.如果想同时取得Map的键与值，可以使用entrySet（）方法，会返回一个Set对象，每个元素都是Map.Entry实例，可以调用getKey（）取得键，调用getValue（）取得值。

教材学习中的问题和解决过程

xx1问题：书上p269Students按照书上在IDEA中输入后显示有错误Cannot resolve symbol 'set'。
xx1解决方案：书上印刷有错误，将最后一句中的set改为students即可运行成功。如下：
xx2问题
xx2解决方案
...

代码调试中的问题和解决过程

xx1问题：第七章课后题第一道题。
xx1解决方案写出如下代码：

package src.week5;
import java.util.AbstractCollection;
import java.util.ArrayList;
public class f extends classcard
{
    ArrayList balance1=new ArrayList();
    ArrayList bonus1=new ArrayList();
    ArrayList number1=new ArrayList();
    ArrayList count =new ArrayList();
    int i=1;
    @Override
    public void store(int money)
        {
            if(money>0)
            {
                this.balance+=money;
                if(money>=1000){
                    this.bonus++;
                }
            }
            else
         System.out.println("储值不能为负");
        }
        @Override
        public void save(classcard c,classcard a)
        {
            balance1.add(a.balance);
            System.out.println(a.balance);
            bonus1.add(a.bonus);
            System.out.println(a.bonus);
            number1.add(a.number);
            System.out.println(a.number);
            count.add(i++);
        }
        public classcard load(String number)
        {
            int m=0;
            for(int j=1;j<=count.size();j++)
            {
                if((number1.get(j)).equals(number))
                {
                    System.out.println(balance1.get(j));
                    System.out.println(bonus1.get(j));
                    System.out.println(number);
                    m=1;
                }
            }
            return null;
        }
    public static void main(String[] args) {
        f c=new f();
    f a=new f();
    f b=new f();
    a.classcard("123",1,2);
    b.classcard("134",2,4);
    c.save(c,a);
    c.save(c,b);
    }
}

经过多次修改，仍然无法解决对load函数的正确引用。

xx2问题：书上p269Studentsset问题解决后，又出现如下问题
xx2解决方案：发现是不小心把main类放在student1类里面了（纯属粗心，该打）。
xx3问题：如下代码：

public static void main(String[] args) {
        aa nn=new aa();
        nn.next=8;
        int v=9;
        Object elems[]={1,2,3,4,5,6,7,8};
        nn.add(v);
        for(int j=0;j<nn.next;j++)
        System.out.println(nn.get(j));
    }
    private Object[]elems;
    private int next;
    public aa(int captia)
    {
        elems=new Object[captia];
    }
    public aa()
    {
        this(8);
    }
    public void add(E e)
    {
        if(next==elems.length)
        {
            elems=Arrays.copyOf(elems,elems.length*2);
        }
        elems[next++]=e;
    }
    public E get(int i)
    {
        return (E)elems[i];
    }
    public int size()
    {
        return next;
    }
}

出现如下错误：主要原因我认为是不了解如何正确初定义数组。但上网查了方法之后，发现我定义数组的方法是正确的，但没有新建一个实例，所以才会出现null，新建实例后得到正确结果。

代码托管

代码提交过程截图：
- 运行 git log --pretty=format:"%h - %an, %cd : %s" 并截图
代码量截图：
- 运行 find src -name "*.java" | xargs cat | grep -v ^$ | wc -l 并截图

上周考试错题总结

错题1:System.out.println( “HELLO”.( toLowerCase() ) ) 会输出“hello”
原因，理解情况:toLowerCase()的使用方法：将此字符串中的所有字符转换为小写.故答案如上。
错题2：CH06填空：写出编译P165 RPG.java的命令（javac –d . *.java）

原因，理解情况："."表示在当前文件夹下编译。由于RPG.java需要把程序全部编译。故需要加“.”。
错题3CH07 填空：面向对象中，设计经验可以用（设计模式）表达。
错题4：使用JDB进行调试时单步执行命令有step和next,我们优先使用（next）。

理解情况：next是把函数执行完成；step是跳进函数内部。我们一般使用next。
错题5：填空：使用JDB进行调试时查看源代码的命令是（list）。
错题6：：用enum定义一个Season的类型表示四季（public enum Season{SPRING, SUMMER, AUTUMN,WINTER}）。
理解情况：：enum中列举的常数一般用大写字母表示。

结对及互评

评分标准

正确使用Markdown语法（加1分）：
- 不使用Markdown不加分
- 有语法错误的不加分（链接打不开，表格不对，列表不正确...）
- 排版混乱的不加分
模板中的要素齐全（加1分）
- 缺少“教材学习中的问题和解决过程”的不加分
- 缺少“代码调试中的问题和解决过程”的不加分
- 代码托管不能打开的不加分
- 缺少“结对及互评”的不能打开的不加分
- 缺少“上周考试错题总结”的不能加分
- 缺少“进度条”的不能加分
- 缺少“参考资料”的不能加分
教材学习中的问题和解决过程, 一个问题加1分
代码调试中的问题和解决过程, 一个问题加1分
本周有效代码超过300分行的（加2分）
- 一周提交次数少于20次的不加分
其他加分：
- 周五前发博客的加1分
- 感想，体会不假大空的加1分
- 排版精美的加一分
- 进度条中记录学习时间与改进情况的加1分
- 有动手写新代码的加1分
- 课后选择题有验证的加1分
- 代码Commit Message规范的加1分
- 错题学习深入的加1分
- 本周有效代码超过300分行加两分
扣分：
- 有抄袭的扣至0分
- 代码作弊的扣至0分

点评模板：

基于评分标准，我给本博客打分：9分分。得分情况如下：
正确使用Markdown语法：+1
模板中的要素基本齐全：+1
教材学习中的问题和解决过程：+1
代码调试中的问题和解决过程：+1
进度条中记录学习时间与改进：+1
代码Commit Message规范的：+1
本周有效代码超过300分行：+2
排版精美：+1

点评：小益同学对课本上的内容进行了思考，并进行归纳与总结，这点要向她学习。模板使用也很标准，排版精美，看得出很用心，希望以后遇到问题多动手敲代码，最好能自己编出代码！这点我们互相监督，共同努力，一起进步~

点评过的同学博客和代码

20155224

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	120/120	1/1	16/16	开始了JAVA学习的第一步！
第二周	346/466	1/2	23/36	了解并学习了Java基础语法
第三周	364/830	1/3	21/57	进一步了解java设计语句
第四周	570/1300	2/5	20/77	初步学习了继承与多态，接口与多态知识。
第五周	1056/2356	1/5	23/100	了解Java的异常处理，学习Collection和Map架构

尝试一下记录「计划学习时间」和「实际学习时间」，到期末看看能不能改进自己的计划能力。这个工作学习中很重要，也很有用。

耗时估计的公式

：Y=X+X/N ，Y=X-X/N，训练次数多了，X、Y就接近了。

参考：软件工程软件的估计为什么这么难，软件工程估计方法

计划学习时间:18小时
实际学习时间:23小时
改进情况：这周学习任务量比较大，花费的时间比预期要多，但效率比之前要高一些。
有空多看看现代软件工程课件软件工程师能力自我评价表

参考资料