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

20145211《Java程序设计》第5周学习总结——独上高楼，望尽天涯路

教材学习内容总结

异常处理

JAVA异常
异常指不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。异常就是出现在运行时出现不正常的情况；异常由来：问题也是现实生活在具体的食物，也可以通过java的类形式进行描述，并封装成对象对于问题的划分——两种：一种是严重的问题，另一种非严重的问题。
Java通过API中Throwable类的众多子类描述各种不同的异常。因而，Java异常都是对象，是Throwable子类的实例，描述了出现在一段编码中的错误条件。当条件生成时，错误将引发异常。
在 Java 中，所有的异常都有一个共同的祖先 Throwable（可抛出）。Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。 Throwable：有两个重要的子类：Exception（异常）和 Error（错误），二者都是 Java 异常处理的重要子类，各自都包含大量子类。
Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM出现的问题。例如，Java虚拟机运行错误，当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机一般会选择线程终止。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误、类定义错误等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。
疾病不可治愈Error,当我直接超出内存容量时，系统认为你已经救不了了，爆出Error
Exception（异常）:是程序本身可以处理的异常，疾病可治愈Exception。
例如当我当我尝试用0作除数时，会报出Exception
Throwable下有两个类：Error,Exception
Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。
注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

通常，Java的异常分为可查的异常和不可查的异常。
可查异常：正确的程序在运行中，很容易出现的、情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。

除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

不可查异常(编译器不要求强制处置的异常):包括运行时异常和错误。
Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。
处理异常机制
在 Java 应用程序中，异常处理机制为：抛出异常，捕捉异常。
捕获异常：try、catch 和 finally
try-catch语句
在Java中，异常通过try-catch语句捕获。其一般语法形式为：

try {  
    // 可能会发生异常的程序代码  
} catch (Type1 id1){  
    // 捕获并处置try抛出的异常类型Type1  
}  
catch (Type2 id2){  
     //捕获并处置try抛出的异常类型Type2  
}

关键词try后的一对大括号将一块可能发生异常的代码包起来，称为监控区域。Java方法在运行过程中出现异常，则创建异常对象。将异常抛出监控区域之外，由Java运行时系统试图寻找匹配的catch子句以捕获异常。若有匹配的catch子句，则运行其异常处理代码，try-catch语句结束。
匹配的原则是：如果抛出的异常对象属于catch子句的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型相匹配。

例：System.out.println("a/b的值是：" + a/b);在运行中出现“除数为0”错误，引发ArithmeticException异常。运行时系统创建异常对象并抛出监控区域，转而匹配合适的异常处理器catch，并执行相应的异常处理代码。由于检查运行时异常的代价远大于捕捉异常所带来的益处，运行时异常不可查。Java编译器允许忽略运行时异常，一个方法可以既不捕捉，也不声明抛出运行时异常。

需要注意的是，一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。Java通过异常类描述异常类型，异常类的层次结构如图1所示。对于有多个catch子句的异常程序而言，应该尽量将捕获底层异常类的catch子句放在前面，同时尽量将捕获相对高层的异常类的catch子句放在后面。否则，捕获底层异常类的catch子句将可能会被屏蔽。RuntimeException异常类包括运行时各种常见的异常，ArithmeticException类和ArrayIndexOutOfBoundsException类都是它的子类。因此，RuntimeException异常类的catch子句应该放在最后面，否则可能会屏蔽其后的特定异常处理或引起编译误。

Throwable类中的常用方法
注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句e.getMessage();用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:

getCause()：返回抛出异常的原因。如果 cause 不存在或未知，则返回 null。

　getMeage()：返回异常的消息信息。

　printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。

有时为了简单会忽略掉catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会忽略处理异常，而错误发生的原因很难查找。

Java常见异常

在Java中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:

runtimeException子类:
1、 java.lang.ArrayIndexOutOfBoundsException
数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
2、java.lang.ArithmeticException
算术条件异常。譬如：整数除零等。
3、java.lang.NullPointerException
空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
4、java.lang.ClassNotFoundException
找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
5、java.lang.NegativeArraySizeException 数组长度为负异常
6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
7、java.lang.SecurityException 安全性异常
8、java.lang.IllegalArgumentException 非法参数异常
2.IOException
IOException：操作输入流和输出流时可能出现的异常。
EOFException 文件已结束异常
FileNotFoundException 文件未找到异常
其他
ClassCastException 类型转换异常类
ArrayStoreException 数组中包含不兼容的值抛出的异常
SQLException 操作数据库异常类
NoSuchFieldException 字段未找到异常
NoSuchMethodException 方法未找到抛出的异常
NumberFormatException 字符串转换为数字抛出的异常
StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常
IllegalAccessException 不允许访问某类异常
InstantiationException 当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常

自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
在程序中使用自定义异常类，大体可分为以下几个步骤。
（1）创建自定义异常类。
（2）在方法中通过throw关键字抛出异常对象。
（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
（4）在出现异常方法的调用者中捕获并处理异常。

Collection与Map

Collection又分两种，Set和List，区别在于Set是不可重复的，而List是可重复的
Set常用有两种：HashSet和TreeSet，其内部实现是一个Map，它的元素就相当于Map中的Key，而Value是一个Object常量

private transient HashMap<E,Object> map;
 
private static final Object PRESENT = new Object();
 
public HashSet() {
    map = new HashMap<E,Object>();
}
private transient NavigableMap<E,Object> m;
 
private static final Object PRESENT = new Object();
 
public TreeSet() {
    this(new TreeMap<E,Object>());
}

所有对Set的操作都被最终转嫁为对Map的操作。

List

对Collection接口进行了简单的扩充，你可以将任何对象放到放到一个List容器中，并在需要时从中取出。

常用的有ArrayList和LinkedList，都是有顺序，可重复的集合类型

ArrayList：顾名思义，数据列表，其实就是封装了一个数组，因此它的访问速度极快

private transient Object[] elementData;
 
private int size;

然后封装了一些对数组的常用操作如插入、删除等。
ArrayList可以储存不同类型的对象（虽然一般不推荐这样做），而数组只能是同一类型。ArrayList可以动态增加长度，但效率不高，而数组只能是固定长度，却十分高效。每当执行add/insert等添加元素的方法，都会先检查数组长度是否足够，如果是，它就会以当前容量的3/2倍+1来重新构建一个数组，将旧元素Copy到新数组中，然后丢弃旧数组，在这个临界点的扩容操作，应该来说是比较影响效率的。

ArrayList提供常用方法，add/get/indexOf/remove等，而相应的Arrays没有提供add和remove方法，查询元素索引要先sort再binarySearch

ArrayList排序需外部方法``Collections.sort(..),数组排序则使用Arrays.sort(..)，二者都可以使用自然顺序（实现Comparable）或用Comparator```指定

是一种把键和值对象进行关联的容器，类比Collection，可以这样说：Collection对象中某个值的ID是它在容器中的索引值，而在Map中，某个值的ID是它对应的键。这样我们使用Map时就不用局限于int型的索引值，可以用任何类型的对象作索引。正是由于Key的索引特性，Map中不允许有同值的Key存在（前文讲到Set内部实现是Map中的Key的集合，所以Set的元素不能重复）。当然，Value是可以重复的，甚至可以是同一个Reference。Map在处理相同的Key时，将新值存入，旧值被替换并返回。

HashMap：采用Hash算法，以便快速查找某个元素。

将键的哈希值作为内存索引依据，内部实现是一个适当长度的链式数组，由Key的Hash值对应数组下标，再间接对应内存，是一种比较高效的存取方式。Key的hashCode()相同的情况下，放在同一个单项链表结构中。

一个HashMap中Key的类型应该重写hashCode()方法，保证在两个对象equals为true时返回相同的值，否则在重复性检查时会直接被当做不同的键，造成不可预期的后果。

TreeMap：采用树型储存结构按序存放，因此它便有一些扩展的方法，比如firstKey(),lastKey()等，你还可以从TreeMap中指定一个范围以取得其子Map。

内部实现是一颗二叉排序树，其中序遍历结果为递增序列。所以要求他的Key必须是Comparable或者创建TreeMap的时候指定Comparator。

当Key实现Comparable接口时，必须实现comparaTo(E e)方法，当使用外部比较器（Comparator）时，需实现Comparator的compare(T t1, T t2)方法

泛型(Generic)

泛型允许Coding的时候可以定义一些可变的类型，但必须在使用前进行声明具体是哪种类型

class testGeneric<T> {
    T t;
    testGeneric(T t) {
        this.t = t;
    }
}
 
class test {
    testGeneric<String> tgs = new testGeneric("Hi,Gineric!");
    testGeneric<Integer> tgi = new testGeneric(100);//AutoBoxing
    {
        System.out.println(tgs.t);//Output:Hi,Gineric!
        System.out.println(tgi.t);//AutoUnBoxing&Output:100
    }
}

需要注意Java 泛型的类型参数之实际类型在编译时会被消除,所以无法在运行时得知其类型参数的类型。Java 编译器在编译泛型时会自动加入类型转换的编码，故运行速度不会因为使用泛型而加快。

迭代器(Iterator)

提供一种方法访问一个容器对象中各个元素，而又不需暴露该对象的内部细节。

对于遍历一个容器中所有的元素，Iterator模式是首选的方式

Collection定义了Iterator<E> iterator()方法，子类都各自实现了该方法，我们直接调用即可

Map中虽没有定义，我们可以利用map.entrySet()的iterator()方法

Iterator i = someMap.entrySet().iterator();
while(i.hasNext()) {
    Map.Entry entry = (Map.Entry) i.next();
    Object key = i.getKey();
    Object value = i.getValue();
    //something TODO
}

或者转换为Collection(Set)用增强For循环

ListIterator继承了Iterator，提供了对List的双向遍历的方法。

需要注意的是，调用Iterator的remove方法，删除的是最后一次调用next()（or previous(),if possible）所返回的元素

如果进行迭代时用调用此方法之外的其他方式修改了该迭代器所指向的 collection，则迭代器的行为是不确定的。

也就是说，调用Iterator时，最好不要调用Collection的add/remove等方法

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

throws抛出异常
如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。例如汽车在运行时可能会出现故障，汽车本身没办法处理这个故障，那就让开车的人来处理。

import java.lang.Exception;  
public class TestException {  
    static void pop() throws NegativeArraySizeException {  
        // 定义方法并抛出NegativeArraySizeException异常  
        int[] arr = new int[-3]; // 创建数组  
    }  
  
    public static void main(String[] args) { // 主方法  
        try { // try语句处理异常信息  
            pop(); // 调用pop()方法  
        } catch (NegativeArraySizeException e) {  
            System.out.println("pop()方法抛出的异常");// 输出异常信息  
        }  
    }  
  
}

使用throws关键字将异常抛给调用者后，如果调用者不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的调用者。

public class TestException {  
    public static void main(String[] args) {  
        int a = 6;  
        int b = 0;  
        try { // try监控区域  
              
            if (b == 0) throw new ArithmeticException(); // 通过throw语句抛出异常  
            System.out.println("a/b的值是：" + a / b);  
        }  
        catch (ArithmeticException e) { // catch捕捉异常  
            System.out.println("程序出现异常，变量b不能为0。");  
        }  
        System.out.println("程序正常结束。");  
    }  
}

在try监控区域通过if语句进行判断，当“除数为0”的错误条件成立时引发ArithmeticException异常，创建 ArithmeticException异常对象，并由throw语句将异常抛给Java运行时系统，由系统寻找匹配的异常处理器catch并运行相应异常处理代码，打印输出“程序出现异常，变量b不能为0。”try-catch语句结束，继续程序流程。

事实上，“除数为0”等ArithmeticException，是RuntimException的子类。而运行时异常将由运行时系统自动抛出，不需要使用throw语句。

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

这是我在另一本书上看到的代码

 package Test;  
public class TestException {  
    public TestException() {  
    }  
  
    boolean testEx() throws Exception {  
        boolean ret = true;  
        try {  
            ret = testEx1();  
        } catch (Exception e) {  
            System.out.println("testEx, catch exception");  
            ret = false;  
            throw e;  
        } finally {  
            System.out.println("testEx, finally; return value=" + ret);  
            return ret;  
        }  
    }  
  
    boolean testEx1() throws Exception {  
        boolean ret = true;  
        try {  
            ret = testEx2();  
            if (!ret) {  
                return false;  
            }  
            System.out.println("testEx1, at the end of try");  
            return ret;  
        } catch (Exception e) {  
            System.out.println("testEx1, catch exception");  
            ret = false;  
            throw e;  
        } finally {  
            System.out.println("testEx1, finally; return value=" + ret);  
            return ret;  
        }  
    }  
  
    boolean testEx2() throws Exception {  
        boolean ret = true;  
        try {  
            int b = 12;  
            int c;  
            for (int i = 2; i >= -2; i--) {  
                c = b / i;  
                System.out.println("i=" + i);  
            }  
            return true;  
        } catch (Exception e) {  
            System.out.println("testEx2, catch exception");  
            ret = false;  
            throw e;  
        } finally {  
            System.out.println("testEx2, finally; return value=" + ret);  
            return ret;  
        }  
    }  
  
    public static void main(String[] args) {  
        TestException testException1 = new TestException();  
        try {  
            testException1.testEx();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}

后来才发现事实并不是这样。。

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

时间犹如白驹过隙，学习java课程已经一个月有余了。在这一个多月的时间里，我学习了java的起源、java基础语法、java整体架构。虽然以前学过CC++，但这仅限于浅尝辄止而已，根本就没有去深层次的了解过。Java这门课程是我进入软件编程世界的第一道坎，因此我必须要发扬笨鸟先飞，持之以恒的精神来学习它，争取把第一只拦路虎给消灭了。
书上的代码看似简单，但是有时候照着书敲上去一编译运行却不是这里出错就是那里有问题，高的焦头烂额的；更令人郁闷的是，有时候编译没有问题，但是运行的时候却报错了，这种情况十有八九是因为一些情况没有考虑清楚：有时候我们定义的是整型变量，输入却输入了非整型变量；有时候是因为数组的下标越界；有时候是什么空指针异常……这些情况使得我经常痛不欲生，有好几次一冲动差点把电脑给砸了，但是一想到把电脑砸坏了就得吃一年的白菜就忍住了，所以大家有时候遇到问题不能解决的时候千万不要冲动。
学语言，就是一个修仙的过程，需要耐得住寂寞，守得住淡泊。高处不胜寒啊！而你又独上高楼，心中苦楚又几人知？不过，上了高楼，望尽天涯路，世间美景尽收眼底，岂不快哉！？

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	100/100	2/2	15/15	学会搭建Java环境，学会写一些简单程序，掌握一些小技巧
第二周	100/200	2/4	22/37	学会使用IDEA
第三周	450/650	1/5	24/61	深入了解面向对象
第四周	750/1450	1/6	30/91	理解继承、多态、接口
第五周	750/2200	2/8	30/120	接触异常处理与Map