JAVA 私塾第八、九章笔记整理

JAVA 私塾第八、九章笔记整理

第八章 异常和断言

一． 异常的分类

     java.lang.Throwable类充当所有对象的父类，可以使用异常处理机制将这些对象超出并捕获。有Error和Exception两个基本子类。

         错误（Error）：JVM 系统内部错误、资源耗尽等严重情况，程序员不可控制
         例外（Exception）：其它因编程错误或偶然的外在因素导致的一般性问题，程序可  以控制
         当发生Error时，比如说内存益处，不可能指望程序能处理这样的情况，只能让程序终止。而对于Exception，有补救或控制的可能，程序员也可以预先防范。
         【此处有图，需要的可以到JAVA 私塾官网下载完整笔记：w ww.javass.cn】

    RuntimeExceptioni是因设计或实现方式不当导致的问题。也可以说是因为程序员的原因导致的，本来可以避免发生的情况。
    包括IOException在内的其他Exception，则可以认为是描述运行时遇到的困难，他通常由环境而并非程序员的原因引起的，可以进行处理。
    Java程序处理异常的原则为：
    （1） 对于Error和RuntimeException,可以在程序中进行捕获或处理，但不是必须的。
    （2） 对于IOException及其他异常，必须在程序中进行捕获或处理。

二．异常的处理
    try块：在try语句中包含可能会产生异常的语句。
    catch块：用来捕获并处理try中抛出的异常的代码块。
        当多个catch块存在的时候，从上往下catch块的范围应该从小到大，否则会产生一个编译异常。

    finally块：无论是否出现异常都运行的块。
    try,catch,finally块的关系
      （1） try块不能单独存在，后边必须跟catch块或finallly块。
      （2） 三者之间的组合为：try—catch,try—catch—finally,try—finally
      （3） 一个try块可以有多个catch块，从上到下多个catch块的范围从小到大。

    Throws用来在方法定义时声明异常。就是向外抛异常不做处理。

三．自定义异常
    写一个类继承Exception
    用户自定义异常通常属Exception范畴，依据惯例，应以Exception结尾，应该由人工 创建并抛出。

四．断言和断言的使用：
    断言用于证明和测试程序的假设。
    断言可以在运行时从代码中完全删除，所以对代码的运行速度没有影响。
    断言有两种方法：
        一种是 assert<<布尔表达式>>
        另一种是 assert<<布尔表达式>>：<<细节描述>>。
            如果布尔逻辑表达式的值为false,将抛出AssertError异常：细节描述是AssertError异常的描述文本。
        使用javac-source 1.4MyClass.java的方式进行编译。

        运行时要屏蔽断言：java –disableassertions 或java -da
        运行时要允许断言：java –enableassertions 或 java –ea

五. Throw和Throws的功能和使用方法:
    throw 指编程人员主动抛出一个异常
    throw new NullPointerExeption();
    throws指程序遇到异常情况自动的被动抛出一个异常
    public void test() throws Exeption{}

第九章 集合框架

    集合框架基本概念
    【此处有图，需要的可以到JAVA 私塾官网下载完整笔记：ww w.javass.cn】

    Set接口继承自Collection接口，无顺序，不能重复。
    List接口继承自Colleciton接口，有顺序，可重复。
    Map接口不继承自Collection接口，定义了键”(key)—值(value)”映射对的方法，键不可重复。

    Collection接口：用于表示任何对象和元素组。
    Set接口：接口继承自Collection接口，集合中元素无顺序，且不允许集合中出现重复项。依靠添加的对象的equals()方法来检查等同性。

        HashSet类和TreeSet类
        HashSet用来存储重复自由的集合。添加到HashSet的对象需要采用恰当的散列码的方式来实现hashCode()方法。
        添加到TreeSet的元素必须是可排序的。

1. 
   
2. import java.util.HashSet;
   
3. import java.util.Set;
   
4. import java.util.TreeSet;
   
5. 
   
6. public class SetExample {
   
7.     public static void main(String [] args){
   
8.       Set set = new HashSet();
   
9.       set.add("Bernadine");
   
10.       set.add("Elizabeth");
    
11.       set.add("Gene");
    
12.       set.add("Elizabeth");
    
13.       set.add("Clara");
    
14.       System.out.println(set);
    
15.       Set sortedSet = new TreeSet(set);
    
16.       System.out.println(sortedSet);
    
17.    }
    
18. }

复制代码

输出结果：
      [Bernadine, Gene, Clara, Elizabeth]
      [Bernadine, Clara, Elizabeth, Gene]

    List接口：继承了Collection接口以定义一个允许重复项的有序集合。
              List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可根据序号存取容器中的元素
              ArrayList类和LinkedList类
              ArrayList读快改慢，LinkedList改快读慢。

1. 
   
2. import java.util.ArrayList;
   
3. import java.util.LinkedList;
   
4. import java.util.List;
   
5. 
   
6. public class ListExample {
   
7.     public static void main(String [] args){
   
8.     List list = new ArrayList();
   
9.     list.add("Bernadine");
   
10.     list.add("Elizabeth");
    
11.     list.add("Gene");
    
12.     list.add("Elizabeth");
    
13.     list.add("Clara");
    
14.     System.out.println(list);
    
15.     System.out.println("2:" + list.get(2));
    
16.     System.out.println("0:" + list.get(0));
    
17.     LinkedList queue = new LinkedList();
    
18.     queue.addFirst("Bernadine");
    
19.     queue.addFirst("Elizabeth");
    
20.     queue.addFirst("Gene");
    
21.     queue.addFirst("Elizabeth");
    
22.     queue.addFirst("Clara");
    
23.     System.out.println(queue);
    
24.     queue.removeLast();
    
25.     queue.removeLast();
    
26.     System.out.println(queue);
    
27.     }
    
28. }

复制代码

输出结果：
    [Bernadine, Elizabeth, Gene, Elizabeth, Clara]
    2:Gene
    0:Bernadine
    [Clara, Elizabeth, Gene, Elizabeth, Bernadine]
    [Clara, Elizabeth, Gene]

    Map接口：不是从Collection接口继承，用来存储键值对。Map中存储的键值对通过键来标识，所以键是不能重复的。键和值都可以为null。
    Map的两个实现类：HashMap和TreeMap
        HashMap：在Map中插入，删除和定位元素。
        TreeMap：按键的顺序遍历。

1. 
   
2. import java.util.*;
   
3. 
   
4. public class MapExample {
   
5.     public static void main(String [] args){
   
6.        HashMap map = new HashMap();
   
7.        Integer ONE = new Integer(1);
   
8.        for(int i=0, n=args.length;i<n; i++){
   
9.            String key = args[i];
   
10.            Integer frequency = (Integer)map.get(key);
    
11.            if(frequency == null){
    
12.               frequency = ONE;
    
13.            }else{
    
14.               int value = frequency.intValue();
    
15.               frequency = new Integer(value+1);
    
16.            }
    
17.            map.put(key, frequency);
    
18.        }
    
19.        System.out.println(map);
    
20.        TreeMap sortedMap = new TreeMap(map);
    
21.        System.out.println(sortedMap);
    
22.     }
    
23. }

复制代码

输出结果：
<one=2, world=1, dream=1>
<dream=1, one=2, world=1>

    Comparable接口：容器中可以排序的类都实现了java.lang.Comparable接口
         Comparable接口中只有一个方法：
             Public int compareTo(Object obj)
             返回 0 表示 this == object;
             返回正数表示 this>object;
             返回负数表示 this<object.

1. 
   
2. public class Student implements java.io.Serializable,Comparable {
   
3.     ∵ String name;
   
4.     ∵ String result;
   
5. 
   
6.     public int compareTo(Object o) {
   
7.         Student s = (Student) o;
   
8.         return Integer.valueOf(result) > Integer.valueOf(s.result) ? -1
   
9.               : (Integer.valueOf(result) == Integer.valueOf(s.result) ? 0 : 1);
   
10.     }
    
11. }

复制代码

Iterator接口：所有实现Collection的类都有一个Iterator方法以返回一个实现了Iterator 接口的对象。
        Iterator对象称作迭代器，用以方便的实现对容器元素的遍历操作。
        Iterator接口定义了如下方法：
        hasNext():Boolean;
        next():Object;
        remove():void;

1. 
   
2. import java.util.Collection;
   
3. import java.util.HashSet;
   
4. import java.util.Iterator;
   
5. import java.util.TreeSet;
   
6. 
   
7. public class TestIterator {
   
8.    public static void main(String [] args){
   
9.       Collection collection = new HashSet();
   
10.       collection.add("1");
    
11.       collection.add("2");
    
12.       collection.add("3");
    
13.       collection.add("4");
    
14.       collection.add("5");
    
15.       collection.add("6");
    
16.       Iterator iterator = collection.iterator();
    
17.       while(iterator.hasNext()){
    
18.          Object element = iterator.next();
    
19.          System.out.println(element);
    
20.       }
    
21.    }
    
22. }

复制代码

输出结果：  352461

断言用在黑盒测试；似乎在业务中没使用‘；抛异常以一张积极的方式处理流程；

不要压制异常：可以使用如下格式: try { //代码 } catch (Exception e) { //空 }