Java 学习笔记（三）

1. Java  的异常处理（exception-handling）机制是个简捷、轻量化的执行期间例外状况处理方式，它让你能够
	将处理错误状况的程序代码摆在一个容易阅读的位置。编译器只会注意你有没有表示你会注意到异常，不会
	在乎你真的是怎样处理的。

2. 异常是一种 Exception 类型的对象。方法可以抓住其他方法所抛出的异常。异常总是会丢回给调用方。会抛出异常的方法
	必须要声明它有可能会这么做。
	
3. 不是有编译器检查的，RuntimeException 的子类，被称为检查异常。因为大部分的 RuntimeException 都是因为
	程序逻辑的问题，而不是你所无法预测或防止的方法出现的执行期失败状况。try catch 是用来处理真正的异常，
	而不是你程序的逻辑错误，该块要做的是回复的尝试，或者至少会优雅的列出错误信息。

4. finally 用来存放不管有没有异常都得执行的程序。如果try 或者 catch 块有return 指令，finally 还是会执行。
	流程会跳到 finally 然后在回到 return 指令。
	
5. 处理多个异常的时候，需要从小到大的顺序。通常 Exception 异常需要放到最后面。

6. 如果你不想处理异常，可以将异常再次的抛出（duck）掉。方法抛出异常的时候，方法会从栈上方立即被取出，
	而异常会再度丢给栈上的方法，也就是调用方，如果调用方是个ducker ，则此ducker 也会从栈被取出，异常
	再度抛给此时栈上方的方法。如果连Main 方法都 duck 掉，Java 虚拟机只能挂掉。
	
7. try 一定要有catch 或 finally ,但是只有finally 的try 必须要声明异常。
	void go() throws Exception {
		try {
			x.doSomething();
		} finally {
			something;
		}
		
	}
	
8. 我们把所有的绘图程序代码都在paintComponent() 这个方法中。该方法是由GUI 系统调用，你不可以自己调用。
	它的参数是个你不能自己创建的 Graphics 对象。

9. 内部类。内部类可以使用外部所有的方法与变量，就算是私用的也一样。内部类把存取外部类的方法和变量当作
	是开自家的冰箱。
	内部类的实例一定会绑在外部类的实例上。任意一个内部类只能存取它属于的那一个类的方法和变量。
	package com.bjfu.chapter10;

public class MyOuter {

	private int x;
	
	MyInner inner = new MyInner();
	
	public void go() {
		inner.go();
	}
	public static void main(String[] args) {
		// 也可以从外部类意外的程序代码来初始化内部实例，但这需要特殊的语法。
		MyOuter out = new MyOuter();
		MyOuter.MyInner inner = out.new MyInner();
		
	}
	
	class MyInner {
		
		void go() {
			x = 42;
		}
	}
}
10. 序列化，将被序列化的对象写到文件中，然后就可以让你的程序去文件中读取序列化的对象并把它们展开到活生
	生的状态。

11. 将串流（stream）连接起来代表来源于目的地（文件或网络端口）的连接。串流必须要连接到某处才能算是个串流。
	对象被序列化的时候发生了什么？在堆上的对象有状态-实例变量的值。这些值让同一类的不同实例有不同的
	意义。
	序列化的对象保存了实例变量的值，因此之后可以在堆上带回一模一样的实例。
	当对象还带有对其他对象的引用怎么办？
	当对象被序列化时，被该对象引用的实例变量也会被序列化。且所有被引用的对象也会被序列化。最棒的是，
	这些操作都是自动进行的。

12. 如果要让类能够被序列化，就要实现 serializable 接口。序列化接口没有方法或字段，仅用于标识可序列化的语义。

13. 序列化是全有或全无的。不能够只有部分状态被正确保存下来。
	
14. 如果某实例变量不能或不应该被序列化，就把它标记为 transient （瞬时的）。
	class Chat implements Serializable {
		transient String currentID;
		String userName;
		
		//......
	}
	
15. 如果两个对象都有引用实例变量指向相同的对象会怎样？例如两个Cat 都有相同的 Owner 对象，Owner对象
	会被存储两次吗？
	序列化能够分辨两个对象是否相同。在此情况下，只有一个对象会被存储，其他引用会被复原成指向该对象。
	
16. 解序列化（Deserialization）时，如果找不到或无法加载被解的类时，Java 虚拟机会抛出异常。

17. 如果对象在继承树上有个不可序列化的祖先类，则该不可序列化类及在它之上的类的构造函数（就算是可序列化
	的也一样）就会执行。一旦构造函数连锁启动之后将无法停止。也就是说，从第一个不可序列化的父类开始，
	全部都会重新初始状态。
	
18. 静态变量不会被序列化，当对象被还原的时候，静态变量会维持类中原本的样子，而不是存储时的样子。

19. 如果父类实现序列化，则子类也就自动地有实现，而不管是否有明确的声明。

20. 文件写。FileWriter
	import java.io.FileWriter;
	public class WriteAFile {
	public static void main(String[] args) {
		try {
			// 缓冲区
			BufferedWriter writer = new BufferedWriter(new FileWriter("Foo.txt"));
			writer.write("hello my name is zhangzhaoyu!!!");
			writer.flush();
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

21. 缓冲区的奥妙。缓冲区能让你暂时摆一堆东西一直到满为止。用了缓冲区就可以省下好几趟的来回。
	如果想要强制缓冲区立即写入，只要调用writer.flush() 函数即可。
	
22. 文件读。FileReader
	import java.io.BufferedReader;
	import java.io.File;
	import java.io.FileReader;

public class ReadAFile {

	public static void main(String[] args) {

		try {
			
			File file = new File("Foo.txt");
			FileReader fr = new FileReader(file);
			BufferedReader reader = new BufferedReader(fr); 
			
			String line = null;
			while ((line = reader.readLine()) != null) {
				System.out.println(line);
			}
			
			reader.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

}