20145221 《Java程序设计》第五周学习总结

20145221 《Java程序设计》第五周学习总结

教材学习内容总结

第八章部分 - 异常处理

语法与继承架构

• 使用try...catch

  • 首先要明确一点：Java中所有错误都会打包为对象
  • JVM会尝试执行try区块中的程序代码，如果发生错误，执行程序就会比对catch括号中声明的类型，是否符合被抛出的错误对象类型，如果是就执行catch中的程序代码。
  • 使用try...catch注意，与C语言中程序流程和错误处理不同，Java中把正常流程放try块中，错误（异常）处理放catch块中，这是最直接的区别
  • catch 多个异常：有时，为了把异常都进行日志记录，可以使用一个try，多个catch，即使数个类型的catch块在做同样的事情。但是，要注意多个catch一定把父类放后面。如：

    try{
    	System.in.read();
    }catch(IOException ex){
    	ex.printStackTrace();
    }catch(Exception ex){
    	ex.printStackTrace();
    }
    

  • API文档中带throws的必须使用try...catch,如下图
    
    

• 异常架构

  • Error及其子类写程序不用处理，最多留个日志，属于严重系统错误，如硬件层面错误、JVM错误或内存不足等问题
  • Java异常处理是要处理Exception类及其子类（Checked Exception）
    • RuntimeException及其子类也不用处理(Unchecked Exception)
    • 产生RuntimeException的问题在运行调用代码时发生
      
      
    • 参考Design by Contract (DBC) 契约式设计
  • Multi-catch：实现了catch多重捕捉类，不过各个异常之间不能存在继承关系

• catch or throw?

  • 在Java中还提供了另一种异常处理方式即抛出异常，顾名思义，也就是说一旦发生异常，我把这个异常抛出去，让调用者去进行处理，自己不进行具体的处理，此时需要用到throw和throws关键字
  • throws:自己无法处理，用在方法声明（声明方法中会抛出异常），后面跟的是异常类，可以跟多个，用逗号隔开
  • throw：后面跟异常对象，方法中抛出Checked Exception，方法声明中必须有throws

• 自定义异常

  • 自定义异常，使其可以继承原本有的各种异常，例如RuntimeException，这样可以在运行时，更加精确的帮我们找到是哪里出了问题。

• 异常堆栈

  • printStackTrace：区别于在此之前的用System.out.println(e);来打印异常，printStackTrace();不仅可以打印异常，还可以查看堆栈追踪，显示出更深层的调用关系。如执行书中P240代码时，出现如下显示：
    
    

  • 善用堆栈追踪错误

    • 代码中不要私吞异常
    • 不要错误处理异常
    • 处理时不要显示错误信息

• printStackTrace 和fillInStackTrace
  
  如果想要让异常堆栈起点为重抛异常的地方，可以使用fillInStackTrace();方法，这个方法会重新装填异常堆栈，将起点设为重抛异常的地方，并返回Throwable对象。

• assert

  • java -ea or java：为了避免JDK1.3或者之前更早版本程序使用assert作为变量导致名称冲突问题，默认执行时，不启动断言检查，如果要在执行时启动断言检查，可以在执行java指令时，指定—enableassertions或者—ea自变量。
  • 什么时候使用断言
    1. 断言客户端调用方法前，已经准备好某些前置条件（通常在private方法之中）。
    2. 断言客户端调用方法后，具有方法承诺效果。
    3. 断言对象某个时间点下的状态。
    4. 使用断言取代批注。
    5. 断言程序流程中绝对不会执行到的程序代码部分。

异常与资源管理

• 使用finally
  • try-catch-finally

  try{
      //（尝试运行的）程序代码
  }catch(异常类型 异常的变量名){
      //异常处理代码
  }finally{
      //异常发生，方法返回之前，总是要执行的代码
  }
  

• try with resources
  • 关闭多个资源时用分号分隔，不要试图自行撰写程序代码关闭资源，这样会造成重复。
• java.lang.AutoCloseable
  • try with resources的对象必须实现AutoCloseable接口，该语法也可以同时关闭两个以上的对象资源，只要中间以分号隔开。在try的括号中，越后面撰写的对象资源会越早被关闭。

第九章部分 - Collection与Map

使用Collection集合对象

• 认识collection架构
  • Connection: 增、删、遍历对象
    • add
    • remove
    • clear
    • size
    • iterator
• List: 类似数组，具有位置信息，带索引。List是一种Collection，作用是收集对象，并以索引方式保留收集的对象顺序，其操作类之一是java.util.ArrayList。查看API文件的时候发现，List接口定义了add(int index, E element)、remove(int index)、set(int index, E element)等许多依索引操作的方法。
  • ArrayList
    • 类似于《数据结构》中的线性表
  • LinkedList
    • 类似于《数据结构》中的链表
• Set： 其中的对象不能有重复的。同样是收集对象，在收集过程中若有相同对象，则不再重复收集，若有这类需求，可以使用Set接口的操作对象，String的Split（）方法，可以指定切割字符串的方式。一般用hashcode（）与equals（）来判断对象是否相同。
• Queue: 队列
  • 核心方法
    • offer：添加一个元素并返回true，如果队列已满，则返回false。
    • poll：移除并返问队列头部的元素，如果队列为空，则返回null。
    • peek：返回队列头部的元素，如果队列为空，则返回null。
  • Deque: 双向队列。如果希望对Queue的两端进行加入、移除等动作，则可以使用java.util.Deque。
• 注意区分泛型与继承
  • Java的Collection API都支持泛型：在使用Collection收集对象时，由于事先不知道被收集对象的形态，因此内部操作时，都是使用object来参考被收集的对象，取回对象时也是以object类型返回。所以若想针对某类定义的行为操作，必须告诉编译程序，让对象重新扮演该类型。JDK5之后增加了泛型语法。若接口支持泛型，在操作时也会比较方便，只要声明参考时有指定类型，那么创建对象时就不用再写类型了，泛型也可以仅定义在方法上，最常见的是在静态方法上定义泛型。
• Lambda表达式
  • 注意与匿名类相比的好处：DRY(Don't Repeat Yourself)。
  • 在JDK8中可以使用Lambda来简化程序，Lambda表达式的语法省略了接口类型和方法名称。—>左边是参数列，右边是方法本体。
• Iterable与Iterator
  • Iterator
    • next
    • hasNext
• Comparable与Comparator
  • sort：Java中对象排序，要么对象实现了Comparable可以直接sort要么提供Comparator对象告知sort如何排序

键值对应的Map

• 常用的Map类
  • 以事先利用java.util.Map接口的操作对象来建立键值对应数据，之后若要取得值，只要用对应的键就可以迅速取得。判断键是否重复是根据hashcode()与equals()，所以作为键的对象必须操作hashcode()与equals()。
  • HashMap：建立的键值对应是无序的
  • TreeMap：建立的键值对应是有序的
  • Properties:配置文件
• 访问Map键值
  • keySet：将Map中所有的键存入到set集合中。因为set具备迭代器。所有可以迭代方式取出所有的键，再根据get方法。获取每一个键对应的值。keySet():迭代后只能通过get()取key。
  • values：获取集合中的所有的值，没有键，没有对应关系

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

第八章书中部分代码调试：

• 课本P236页代码

	import java.io.*;
	import java.util.Scanner;

	public class FileUtil {
	    public static String readFile(String name) throws FileNotFoundException {
	        StringBuilder text = new StringBuilder();
	        Scanner console = null;
	        try {
	            console = new Scanner(new FileInputStream(name));
	            while (console.hasNext()) {
	                text.append(console.nextLine())
	                        .append('\n');
	            }
	        } finally {
	            if(console != null) {
	                console.close();
	            }
	        }
	        return text.toString();
	    }
	}

• 分析：这段代码没有什么问题，只是最开始不能理解代码中的console.hasNext()，书中也没有加以解释。但既然这句在while语句的括号中，可以肯定的是这个函数的返回值一定是true或false。最后，通过查询API发现这个的用法就是，当JVM发现了另一个标记符号时，就会进行while循环。
  
  

第九章书中部分代码调试

• 课本P266页代码

public class SimpleLinkedList {
    private class Node {
        Node(Object o) {
            this.o = o;
        }
        Object o;
        Node next;
    }
    private Node first;
    public void add(Object elem) {
        Node node = new Node(elem);
        if(first == null) {
            first = node;
        }
        else {
            append(node);
        }
    }
    private void append(Node node) {
        Node last = first;
        while(last.next != null) {
            last = last.next;
        }
        last.next = node;
    }
    public int size() {
        int count = 0;
        Node last = first;
        while(last != null) {
            last = last.next;
            count++;
        }
        return count;
    }
    public Object get(int index) {
        checkSize(index);
        return findElemOf(index);
    }
   private void checkSize(int index) throws IndexOutOfBoundsException {
        int size = size();
        if(index >= size) {
            throw new IndexOutOfBoundsException(
                    String.format("Index: %d, Size: %d", index, size));
        }
    }
    private Object findElemOf(int index) {
        int count = 0;
        Node last = first;
        while(count < index) {
            last = last.next;
            count++;
        }
        return last.elem;
    }
}

• 结果：
  
  

• 分析：IDEA编译时，发现了错误，上述是运行结果，很显然elem是错的。结合课本知识，经过分析后，发现findElemOf函数的返回类型是Object，又因为last指的是节点，节点的调用在代码中写的很清楚，应该把return last.elem;改为return last.o;，这样JVM就可以识别。为了验证自己的想法，把代码重新跑了一遍。

• 课本P269页代码：

import java.util.*;
class Student {
	private String name;
	private String number;
	Student(String name, String number) {
		this.name = name;
	    this.number = number;
	}
	@Override
	public String toString()  {
		eturn String.format("(%s, %s)", name, number);
	}
}
public class Students {
	public static void main(String[] args) {
		Set students = new HashSet();
	    students.add(new Student("Justin", "B835031"));
	    students.add(new Student("Monica", "B835032"));
	    students.add(new Student("Justin", "B835031"));
	    System.out.println(set);
	}
}

• 分析：在敲代码之前，就发现最后一行代码中“set”出现的有点莫名其妙，应该不是set。为了验证我的猜想，在计算机上敲了一遍，果然IDEA报错了，IDEA的提醒与我想的一致，是不能识别“set”。结合课本，不难发现这里应该想要输出的是Set类的实例students。果然改成students后，代码顺利执行，显示 结果：[(Monica, B835032), (Justin, B835031), (Justin, B835031)]

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

• 这两章的内容又比较深奥了，《学习笔记》虽然厚实，但还是有些不懂的没提到，所以在本周的学习过程中，对书中代码不明确的地方都进行了JAVA-API的查询。虽然现在还不能很熟练地查询使用API，只知道通过API了解一些函数方法的功能以及相关所属情况，不过确实对我理解书中不懂的起到了一定帮助。通过这周队API的熟悉，明白了：学习Java API时一定要对上层的类好好研究，学习，再学习和应用子类时就比较容易了。

• 之前其实就听说过异常处理，当时并不了解，以为就是调试代码的一种手段，这次学习后，发现异常处理真的非常有用，避免了客户在使用程序时很多尴尬的场面。异常处理，使得代码更加牢靠，可靠性增强，不会轻易被“玩死”；另一方面，Java中所有错误都会打包为对象，异常处理通过提供try/catch/finally等实现了对错误对象的处理，也可以通过自定义异常实现对代码的层层管控，知道是哪一环节出了错，方便对异常进行处理和维护。

• 总之，这两章又充满了许多新知识，感觉Java学的越来越深了，从最开始的基础语法，到现在对类相关知识的扩充，对后面的知识虽然可能陌生一些，但是通过调试书中代码、查询API等多种学习方法，应该还是可以将相关知识掌握好的。对于还是弄不懂的知识，那就有待于以后的代码实践了，在用中学，可能会对这个知识掌握的更加全面，也许还会有新的发现。

• 【附1】托管截图
  
  

  

  

  

• 【附2】用cloc.exe统计代码如下：
  
  

  

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	200/200	1/6	20/20	学会MarkdownPad2
第二周	150/350	1/7	15/35	理解了补码机制
第三周	500/850	1/8	25/60	初步了解了对象
第四周	1231/2081	1/9	27/87	初步了解了继承与接口
第五周	749/2930	3/12	30/117	了解了异常处理

参考资料

• Java学习笔记(第8版)
• 《Java学习笔记(第8版)》学习指导
• 积极主动敲代码，使用JUnit学习Java