20145333 《Java程序设计》第5周学习总结

教材学习内容总结

语法与继承架构

使用try、catch

Java中所有错误都会被包装成对象，可以尝试(try)执行程序并捕捉(catch)代表错误的对象后做一些处理。使用了try、catch语法，JVM会尝试执行try区块中的程序代码，如果发生错误，执行程序会跳离错误发生点，然后比对catch括号中声明的类型，是否符合被抛出的错误对象类型，如果是就执行catch中的程序代码。

运用try、catch在错误被捕捉处理后、尝试恢复程序正常的执行流程。

import java.util.*;

public class Average3{

    public static void main(String[] args)

    {

        Scanner console=new Scanner(System.in);

        double sum=0;

        int count=0;

        while(true)

        {

            try

            {

                int number=console.nextInt();

                if(number==0)

                {

                    break;

                }

                sum+=number;

                count++;

            }

            catch (InputMismatchException ex)

            {

                System.out.printf("略过非整数输入:%s%n",console.next());

            }

        }

        System.out.printf("平均 %.2f%n",sum/count);

    }

}

异常继承架构

错误会被包装为对象，这些对象是可抛出的，因此设计错误对象都继承自java.lang.Throwable类。

Throwable定义了取得错误信息堆栈追踪等方法，它有两个子类：java.lang.Error与java.lang.Exception。

Error与其子类实例代表严重系统错误，如硬件层面错误、JVM错误或内存不足等问题。虽可以使用try、catch处理，但并不建议，发生严重错误时，Java应用程序本身是无力回复的。

程序设计本身的错误，建议使用Exception或其子类实例来表现，所以通常称错误处理为异常处理。

单就语法与继承构架上来说，如果某个方法声明会抛出Throwable或子类实例，只要不是属于Error、java.lang.RuntimeException或其子类实例，就必须明确使用try、catch语法处理，或者使用throws声明这个方法会抛出异常，否则编译失败。

IOException是Exception的直接子类，所以编译程序要求明确使用语法加以处理。

受检异常：Exception或其子对象，但非属于RuntimeException或其子对象。

非受检异常：属于RuntimeException衍生出来的类实例，代表API设计者实现某方法时，某些条件成立时引发错误，而且认为API客户端应该在调用方法前做好检查，避免引发错误，编译程序不会强迫一定得在语法上加以处理。

catch括号中列出的异常不能有异常关系，否则会发生编译错误。

package cc.openhome;

public class StackTrace {

public static void main(String[] args) {

    try{

        c();

    }catch(NullPointerException ex){

        ex.printStackTrace();

    }

}

static void c(){

    try{

        b();

    }catch(NullPointerException ex){

        ex.printStackTrace();

        Throwable t=ex.fillInStackTrace();

        throw(NullPointerException)t;

    }

}

static void b(){

    a();

}

static String a(){

    String text=null;

    return text.toUpperCase();

}

}

要抓还是要抛

编译时被检测异常：该异常在编译时，如果没有处理（没有抛也没有try）,编译失败。该异常被表示，代表可以被处理。

运行时异常（编译时不检测）：在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止，需要对代码进行修正。

在异常发生时，可以使用try、catch处理当时环境可进行的异常处理，无法决定如何处理的部分，可以抛出由调用方法的客户端处理，如果想处理部分事项再抛出的做法。

import java.io.*;

import java.util.Scanner;

public class FileUtil{

public static String readFile(String name)throws FileNotFoundException{

    StringBuilder text=new StringBuilder();

    try{

        Scanner console=new Scanner(new FileInputStream(name));

        while(console.hasNext()){

            text.append(console.nextLine())

            .append('\n');

        }

    }catch(FileNotFoundException ex){

        ex.printStackTrace();

        throw ex;

    }

    return text.toString();

}

}

贴心还是造成麻烦

Java是唯一采用受检异常的语言，这有两个目的：一、文件化，受检异常声明会是API操作接口的一部分，客户端只需要查阅文件就可以知道方法可能引发哪些异常，并事先加以处理；二、提供编译程序信息，让编译程序能够在编译时期就检查出API客户端没有处理的异常。

自定义异常类别时，可以继承Throwable、Error、Exception的相关子类，通常建议继承自Exception或其子类，如果不是继承自Error或RuntimeException，那么就会是受检异常。

认识堆栈追踪

若想得知异常发生的根源，以及多重方法调用下异常的堆栈传播，可以利用一场对象自动收集的对堆栈追踪来获取相关信息。

查看堆栈追踪最简单的方法是直接调用异常对象的printStackTrace()。

在使用`throw重抛异常时，异常的追踪堆栈起点，仍是异常的发生根源，而不是重抛异常的地方。

异常与资源管理

使用finally

try、catch语法可以搭配finally，无论try区块中有无发生异常，若撰写有finally区块，则finally区块一定会被执行。

如果程序撰写的流程中先return了，而且也有finally区块，那finally区块会先执行完后，再将值返回。

程序撰写的流程中先return了，而且也有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;

}

}

**使用Collection收集对象 **

认识Collection

收集对象的共同行为定义在Collection中。既然可以收集对象，也要能逐一取得对象，这就是java.lang.Iterable定义行为，它定义了iterator()方法返回java.util.Iterator操作对象，可以逐一取得对象。

具有索引的List

List是一种Collection ,作用是收集对象，并以索引方式保留收集的对象顺序，其操作类之一是java.util.ArrayList。

List定义了许多索引操作的方法。

ArrayList特性：有个可指定容量的构造函数，在大致知道将收集的对象范围，可事先建立足够长度的内部数组。

LinkedList特性： LinkedList在操作List接口时，采用了链接结构。若收集对象经常会有变动索引的情况，考虑链接方式操作的List比较好，像是随时会有客户登录或注销的客户端List，使用LinkedList会有比较的好的效率。

内容不重复的Set

同样是收集对象，在收集过程中若有相同对象，则不再重复收集，此时可以使用Set接口的操作对象。

判断对象是否重复时，都会调用hashCode()与equals()方法，建议两个方法同时使用。

支持队列操作的Queue

使用ArrayDeque来操作容量有限的堆栈。

import java.util.*;

import static java.lang.System.out;

public class Stack

{

private Deque elems = new ArrayDeque();

private int capacity ;

public Stack(int capacity)

{

    this.capacity = capacity;

}

public boolean push(Object elem)

{

    if(isFull())

    {

        return false;

    }

    return elems.offerLast(elem);

}

private boolean ifFull()

{

    return elems.size() + 1 > capacity;

}

public Object pop()

{

    return elems.pollLast();

}

public Object peek()

{

    return elems.size();

}

public static  void main (String[] agrs)

{

    Stack stack = new Stack(5);

    stack.push("Justin");

    stack.push("Monica");

    stack.push("Irene");

    out.println(stack.pop());

    out.println(stack.pop());

    out.println(stack.pop());

}

}

使用泛型

在设计API时可以指定类或方法支持泛型，使用API的客户端在语法上会更为简洁，并得到编译时期检查。

使用定义类型，在需要编译程序检查类型的地方，都可以使用E像是add()方法必须检查传入的对象类型是E，get()方法必须转换为E类型。

声明与建立对象时，可使用角括号告知编译程序，这个对象收集的都会是String,而取回之后也会是String，不用再使用括号转换类型。

泛类型可以定义在方法上，最常见的是在静态方法上定义泛型。

简介Lambda表达式

IntegerFunction doubleFunction = new IntegerFunction()

{

public Integer apply(Integer i)

{

return i*2;

}

}

键值对应的Map

常用Map操作类

常用的Map操作类为java.util.HashMap与java.util.TreeMap，其继承自抽象类java.util.AbstractMap。

使用HashMap：在HashMap中建立键值对应之后，键是无序的。

使用TreeMap：如果使用TreeMap建立键值对应，则键的部分将会排序，条件是作为键的对象必须操作Comparable接口，或者是创建TreeMap时指定操作Comparator接口的对象。

使用Properties：Properties类继承自HashTable，HashTable操作了Map接口，Properties自然也有Map行为。Properties的=左边设定属性名称，右边设定属性值。可以使用Properties的load()方法指定InputStream实例。load()方法结束后会自动关闭InputStream实例。

访问Map键值

若想取得Map中所有的键，可以调用Map的keySet()返回Set对象。

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

Map没有继承Iterable，有个forEach（）方法是定义在Map接口上，可使用这个方法结合Lambda表达式，在迭代键与值时获得不错的可读性。

本周代码托管截图

其他（感悟、思考等，可选）

这一周学习的两章内容很多，又接触到了很多新知识。上周的测试反映除了我学习中的一些问题，就是只看书敲代码，遇到选择题判断题还会一些，但是一遇到写代码这种题就完全不会做了。这说明学的还不扎实，没有对知识完全的理解透彻，也许是自己花的时间的确还不够多，以后要在Java上投入更多的时间来学习。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	3500行	15篇	400小时
第一周	100/100	2/2	20/20
第二周	150/250	1/3	18/38
第三周	100/350	1/4	22/60
第四周	300/650	1/5	30/90
第五周	100/750	1/6	20/110