1. 子父类间异常的注意事项：
子类重写父类方法时只能抛出相同异常或者该异常的子类。
如果父类方法没有抛出异常，子类进行方法重写时，只能通过try catch进行捕获。
2. IO体系：
InputStream/OutputStream 字节流的抽象类。 Reader/Writer 字符流的抽象类。
FileInputStream/FileOutputStream 节点流(操作文件) ByteArrayInputStream/ByteArrayOutputStream 节点流
ObjectInputStream/ObjectOutputStream 处理流(操作对象)
DataInputStream/DataOutputStream(操作基本数据类型与字符串)
FileReader/FileWriter 节点流(操作文件) BufferedReader/BufferedWriter(处理流,增加缓存功能，提高读写效率。)
BufferedInputStream/BufferedOutputStream(处理流，增加缓存功能，提高读写效率。)
InputStreamReader/OutputStreamWriter(处理流：将字节流对象转化成字符流对象。)
3. 序列化：把Java对象转换为字节序列的过程称为对象的序列化。
反序列化：把字节序列恢复为Java对象的过程称为对象的反序列化。
4. 序列化涉及的类和接口：
ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化。
ObjectInputStream代表对象输入流，它的readObject()方法输入流中读取字节序列，再把它们反序列化为一个对象。
只有实现了Serializable接口的类的对象才能被序列化。 Serializable接口是一个空接口，只起到标记作用。
5. 对象中的某些属性如果不想被序列化，不能使用static，而是使用transient修饰。
6. java.lang包下的包装类：八种基本数据类型都有对应的包装类，分别是：
Byte Short Integer Long Float Double Character Boolean
7. 包装类的主要用途：作为和基本数据类型对应的类型存在，方便涉及到对象的操作，如Object[]、集合等的操作。
8. 如果数据在-128~127这个区间，那么在类加载时就已经为该区间的每个数值创建了对象。
public class Test3 {
public static void main(String[] args) {
Integer in1 = -128;
Integer in2 = -128;
System.out.println(in1 == in2);//true 因为123在缓存范围内
System.out.println(in1.equals(in2));//true
Integer in3 = 1234;
Integer in4 = 1234;
System.out.println(in3 == in4);//false 因为1234不在缓存范围内
System.out.println(in3.equals(in4));//true
}
}
9. 自动装箱调用的是valueOf()方法。自动拆箱调用的xxxValue()方法。
10. DateFormat是一个抽象类，一般使用它的的子类SimpleDateFormat类来实现时间和字符串之间的转换。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDateFormat {
public static void main(String[] args) throws ParseException {
// new出SimpleDateFormat对象
SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
SimpleDateFormat s2 = new SimpleDateFormat("yyyy-MM-dd");
// 将时间对象转换成字符串
String daytime = s1.format(new Date());
System.out.println(daytime);
System.out.println(s2.format(new Date()));
System.out.println(new SimpleDateFormat("hh:mm:ss").format(new Date()));
// 将符合指定格式的字符串转成成时间对象.字符串格式需要和指定格式一致。
String time = "2007-10-7";
Date date = s2.parse(time);
System.out.println("date1: " + date);
time = "2007-10-7 20:15:30";
date = s1.parse(time);
System.out.println("date2: " + date);
}
}11. 日历类：Calendar 类是一个抽象类，GregorianCalendar 是 Calendar 的一个具体子类。
12. 枚举：JDK1.5引入了枚举类型。枚举类型的定义包括枚举声明和枚举体。格式如下：
enum 枚举名 {
枚举体（常量列表）
}import java.util.Random;
public class TestEnum {
public static void main(String[] args) {
// switch语句中使用枚举
int a = new Random().nextInt(4); // 生成0，1，2，3的随机数
switch (Season.values()[a]) {
case SPRING:
System.out.println("春天");
break;
case SUMMER:
System.out.println("夏天");
break;
case AUTUMN:
System.out.println("秋天");
break;
case WINDTER:
System.out.println("冬天");
break;
}
}
}
/**季节*/
enum Season {
SPRING, SUMMER, AUTUMN, WINDTER//枚举实例默认都是public static final修饰的。
}
13. 进程：执行中的程序叫做进程(Process)，是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如：在用酷
狗听音乐，也可以使用eclipse写代码，也可以同时用浏览器查看网页。
14. 线程：线程是一个进程内部的一个执行单元，它是程序中的一个单一的顺序控制流程。 一个进程可以产生多个线程。
15. java中实现多线程的两种方式：
通过继承Thread类实现多线程 ：
public class TestThread extends Thread {//自定义类继承Thread类
//run()方法里是线程体
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(this.getName() + ":" + i);//getName()方法是返回线程名称
}
}
public static void main(String[] args) {
TestThread thread1 = new TestThread();//创建线程对象
thread1.start();//启动线程
TestThread thread2 = new TestThread();
thread2.start();
}
}通过Runnable接口实现多线程：
public class TestThread2 implements Runnable {//自定义类实现Runnable接口；
//run()方法里是线程体；
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
public static void main(String[] args) {
//创建线程对象，把实现了Runnable接口的对象作为参数传入；
Thread thread1 = new Thread(new TestThread2());
thread1.start();//启动线程；
Thread thread2 = new Thread(new TestThread2());
thread2.start();
}
}16. 线程的五个状态：创建 就绪 运行 阻塞 死亡
start()方法从创建状态到就绪状态。 获得cpu，通过run方法进入运行状态。 sleep(int millsecond)+wait()+join()三种方法
可使线程进入阻塞状态。
17 . 终止线程的典型方式：
public class TestThreadCiycle implements Runnable {
String name;
boolean live = true;// 标记变量，表示线程是否可中止；
public TestThreadCiycle(String name) {
super();
this.name = name;
}
public void run() {
int i = 0;
//当live的值是true时，继续线程体；false则结束循环，继而终止线程体；
while (live) {
System.out.println(name + (i++));
}
}
public void terminate() {
live = false;
}
public static void main(String[] args) {
TestThreadCiycle ttc = new TestThreadCiycle("线程A:");
Thread t1 = new Thread(ttc);// 新生状态
t1.start();// 就绪状态
for (int i = 0; i < 100; i++) {
System.out.println("主线程" + i);
}
ttc.terminate();
System.out.println("ttc stop!");
}
}18. sleep()方法：可以让正在运行的线程进入阻塞状态，直到休眠时间满了，进入就绪状态。
19. yield()方法：可以让正在运行的线程直接进入就绪状态，让出CPU的使用权。
20. 线程A在运行期间，可以调用线程B的join()方法，让线程B和线程A联合。这样，线程A就必须等待线程B执行完毕后，才能
继续执行。
public class TestThreadState {
public static void main(String[] args) {
System.out.println("爸爸和儿子买烟故事");
Thread father = new Thread(new FatherThread());
father.start();
}
}
class FatherThread implements Runnable {
public void run() {
System.out.println("爸爸想抽烟，发现烟抽完了");
System.out.println("爸爸让儿子去买包红塔山");
Thread son = new Thread(new SonThread());
son.start();
System.out.println("爸爸等儿子买烟回来");
try {
son.join();
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("爸爸出门去找儿子跑哪去了");
// 结束JVM。如果是0则表示正常结束；如果是非0则表示非正常结束
System.exit(1);
}
System.out.println("爸爸高兴的接过烟开始抽，并把零钱给了儿子");
}
}
class SonThread implements Runnable {
public void run() {
System.out.println("儿子出门去买烟");
System.out.println("儿子买烟需要10分钟");
try {
for (int i = 1; i <= 10; i++) {
System.out.println("第" + i + "分钟");
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("儿子买烟回来了");
}
}