JavaSe重要点分析

try、catch、finally、return的执行顺序 (1)

运行时异常与一般异常有何异同 (7)

反射问题个人归纳 (8)

抽象类和接口的区别 (15)

Java中的线程有五种状态 (15)

常见的运行时异常 (16)

异常语句 (17)

Sleee与wait的区别？ (19)

线程的概述（Introduction） (22)

线程的定义（Defining） (22)

线程的启动（Starting） (24)

线程的状态（State） (24)

线程状态图 (25)

线程的方法（Method）、属性（Property） (25)

尝试阐述wait和sleep的区别 (26)

try、catch、finally、return的执行顺序

package test;

public class App1 {

/*

* 测试异常时的执行顺序 finally是在return之前执行的

*

* 对于finally之前有return的情况 finally是在return之前执行的，如果返回的是值类型，finally不改变结果

* 如果返回的是引用类型，finally改变结果

*/

public int testFinally() {

int i = 0;

System.out.println("before");

try {

System.out.println("enter");

if (i == 0) {

throw new Exception("throw");

}

return i;

// 如果没有异常，先return再下面的finally，最后还是要执行这里的return，但是结果结果是0

} catch (Exception e) {

System.out.println("ep");

return i; // 如果有异常，先return再下面的finally，最后还是要执行这里的return，但是结果结果是0

} finally {

i++;

System.out.println("finally");

i++;

System.out.println(i);

}

}

/**

* 测试异常时的执行顺序 finally是在return之前执行的

*/

public Person testFinally1() {

System.out.println("before");

Person p = new Person();

try {

System.out.println("enter");

// 不管有没异常，返回的都是p.id = 1之后的对象；

// 也就是说，即使如上面例子执行顺序不一样，但是finally不改变返回值本身；

// 如上面例子，return的时候，结果是0，无论finally怎么改i的值，返回还是1，

// 这里的，返回的对象一直是p；

// **这里可以看出，finally是在return之前执行的

if (p.id == 0) {

throw new Exception("throw");

}

System.out.println("over");

p.id = 1;

return p;

} catch (Exception e) {

System.out.println("ep");

p.id = -1;

return p;

} finally {

p.id = 2;

System.out.println("finally");

}

}

public static void main(String[] args) {

//System.out.println(new App1().testFinally());

System.out.println(new App1().testFinally1().id);

}

}

class Person {

int id = 0;

}

finally一定会执行吗？回答当然是否定的，假如在try里执行了System.exit(0)就不会再去执行finally了，守护线程中的finally碰到非守护线程全部退出的时候也可能执行不到。又如下面的代码，会打印什么内容？

public class Test {

public static void main(String... args) {

System.out.println(getValue1());

System.out.println(getValue2());

}

public static int getValue1() {

int i1 = 0;

int i2 = 1;

try {

return i1;

} finally {

return i2;

}

}

public static int getValue2() {

int i = 1;

try {

return i;

} finally {

i++;

}

}

}

这个问题可以通过反编译查看字节码指令来解释，编译后再运行javap -c Test即可得到方法要执行的指令，接下来分别对两个方法做个分析

以下对字节码的解释中【】表示栈，左边表示栈顶

public static int getValue1();

Code:

0: iconst_0 //将0入栈，栈内容【0】

1: istore_0 //将栈顶元素弹出，也就是0，存到局部变量区索引为0的变量中（也就是i1），栈内容【】，（0,1）这两个指令是由int i1 = 0生成的

2: iconst_1 //将1入栈，栈内容【1】

3: istore_1 //将栈顶元素弹出，也就是1，存到局部变量区索引为1的变量中（也就是i2），栈内容【】，（2,3）这两个指令是由int i2 = 1生成的

4: iload_0 //将局部变量区索引为0的变量（也就是i1）值入栈，栈内容【0】

5: istore_2 //将栈顶元素弹出，也就是0，存到局部变量区索引为2的变量中（代码中没有声明，这是javac 生成的临时变量，再此记为tmp1），栈内容【】

6: iload_1 //将局部变量区索引为1的变量（也就是i2）值入栈，栈内容【1】

7: ireturn //将栈顶元素弹出，也就是1，并返回

8: astore_3 //（8,9,10）属异常处理部分，这段代码不会出现异常，故执行不到下面的指令

9: iload_1

10: ireturn

Exception table:

from to target type

4 6 8 any

8 9 8 any

可见如果finally和try里都有执行了return，try里的return的值会被废弃。

public static int getValue2();

Code:

0: iconst_1 //将1入栈，栈内容【1】

1: istore_0 //将栈顶元素弹出，也就是1，存到局部变量区索引为0的变量中（也就是i），栈内容【】，（0,1）

这两个指令是由int i = 1生成的

2: iload_0 //将局部变量区索引为0的变量（也就是i）的值入栈，栈内容【1】

3: istore_1 //将栈顶元素保存到局部变量区索引为1的变量中（代码中未声明此变量，在此记为tmp1），栈内容【】

4: iinc 0, 1 //将局部变量区索引为0的变量加1，栈内容【】

7: iload_1 //将局部变量区索引为1的变量（即tmp1）的值入栈，栈内容【1】

8: ireturn //弹出栈顶值并返回，即返回1

9: astore_2 //以下是发生异常时的处理代码，这段代码不会抛出异常，后面的指令就不会执行到了10: iinc 0, 1

13: aload_2

14: athrow

Exception table:

from to target type

2 4 9 any

9 10 9 any

由此可见，在try里返回值会先存到一个临时变量中，finally里改变的是原始变量，改完之后再将临时变量的值返回，也就是说在finally里改变返回值变量并不影响返回值本身。

Crazy_yu说：

第二种情况下，这里的i是临时变量，如果是对象的成员变量，返回的值会变得。个人拙见

POST:2012-09-28 17:32回复

ticmy说：

当然不会，return那条语句的时候分成了两步，一是缓存返回值，二是返回缓存的值。如果是成员变量，返回值也已经缓存起来了。

POST:2012-09-28 19:00回复

匿名说：

我的意思是成员变量返回的是try中的成员变量的值，但是finally里仍然修改了成员变量的值。对于基本数据类型，finally修改的值作为临时变量并没有返回。这样理解应该对吧。

POST:2012-09-28 20:29回复

ticmy说：

没太看明白。不过这很容易写个小程序验证一下

POST:2012-09-29 09:18回复

Viva Hu说：

Eclipse会提示getValue1()的finally block warning（黄色波浪下划线），如果按照其建议自动修改，会自动去掉try finally block 并且返回0，也即i1 的值。这跟实际结果（返回i2的值，也即1）不同。看来Eclipse 的自动修改功能也不安全。

不过退一步说，很少有try 和finally 里同时出现return 的情况吧？如果出现这种代码。说明设计上都有问题，不应从代码的角度上找根源。

第二个例子很好理解，return 了之后才做的累加操作。

POST:2012-08-29 18:23回复

匿名说：

POST:2012-06-29 12:32回复

OneCoder说：

这个讲的高深。。得慢慢看。。不太懂都。。

POST:2012-06-29 11:54回复

运行时异常与一般异常有何异同

Throwable是所有Java程序中错误处理的父类，有两种资类：Error和Exception。

Error：表示由JVM所侦测到的无法预期的错误，由于这是属于JVM层次的严重错误，导致JVM无法继续执行，因此，这是不可捕捉到的，无法采取任何恢复的操作，顶多只能显示错误信息。

Exception：表示可恢复的例外，这是可捕捉到的。

Java提供了两类主要的异常:runtime exception和checked exception。checked 异常也就是我们经常遇到的IO异常，以及SQL异常都是这种异常。对于这种异常，JA VA编译器强制要求我们必需对出现的这些异常进行catch。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。

但是另外一种异常：runtime exception，也称运行时异常，我们可以不处理。当出现这样的异常时，总是由虚拟机接管。比如：我们从来没有人去处理过NullPointerException异常，它就是运行时异常，并且这种异常还是最常见的异常之一。

出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果没有处理块，到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，那么这整个程序也就退出了。运行时异常是Exception的子类，也有一般异常的特点，是可以被Catch块处理的。只不过往往我们不对他处理罢了。也就是说，你如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。

如果不想终止，则必须扑捉所有的运行时异常，决不让这个处理线程退出。队列里面出现异常数据了，正常的处理应该是把异常数据舍弃，然后记录日志。不应该由于异常数据而影响下面对正常数据的处理。在这个场景这样处理可能是一个比较好的应用，但并不代表在所有的场景你都应该如此。如果在其它场景，遇到了一些错误，如果退出程序比较好，这时你就可以不太理会运行时异常，或者是通过对异常的处理显式的控制程序退出。

异常处理的目标之一就是为了把程序从异常中恢复出来。

Throwable类：

用面向对象的方法处理例外，就必须建立类的层次。类Throwable位于这一类层次的最顶层，类Throwable有两个直接子类：Error和Exception。Error类对象（如动态连接错误等），由Java虚拟机生成并抛弃（通常，Java程序不对这类例外进行处理）；Exception类对象是Java程序处理或抛弃的对象。其中类RuntimeException代表运行时由Java虚拟机生成的例外，如算术运算例外ArithmeticException(由除0错等导致)、数组越界例外ArrayIndexOutOfBoundsException等；其它则为非运行时例外，如输入输出例外IOException等。Java编译器要求Java程序必须捕捉或声明所有的非运行时例外，但对运行时例外可以不做处理。

Throwable所提供的方法：

String toString()：代表该Throwable对象的字符串表示法。

String getMessage()：返回和该对象相关的错误信息。

void printStackTrace()：将例外生成所发生的途径显示出来。

void printStackTrace(PrintStream out)：输出到一个PrintStream的数据流中，借此可将信息写到一个文件。

void printStackTrace(PrintWriter out)：输出到一个PrintWriter的数据流中。

当程序需要捕捉数个不同的例外时，需要特别注意这些例外的顺序。应该按照类之间的阶层关系放置，越是基本的类越需放在后面的catch()区段。

catch(Exception e) {

System.err.println("caught an exception");

}

这段代码能捕获所有的异常，所以在实际使用时最好将其置于处理程序列表的末尾，防止跟随在后面的任何特殊异常控制器失效。

一个例外类至少需要包含一个默认的构造函数（用来显示默认的信息）及一个以String对象为参数的构造函数（用来显示用户提供的自订信息）。

反射问题个人归纳

反射：一切的操作都将使用Object完成

如果已经有一个类，则肯定可以通过类创建对象；那么如果现在要求通过一个对象

找一个类的名称，此时就需要用到反射机制了。

public final Class getClass()返回类型是一个Class类，实际上此类是Java反射的源头。

所谓反射从程序的运行结果来看也很好理解，即可以通过对象反射求出类的名称：如下：正常方式：引入需要的"包.类"名称->通过new实例化->取得实例化对象

反射方式：实例化对象->getClass()方法->得到完整的”包.类“名称

提示：所有类的对象实际上都是Class类的实例。

在java中Object类是一切类的父类，那么所有类的对象实际上也就都是

https://www.360docs.net/doc/8e4835772.html,ng.Class类的实例

所以所有的对象都可以转变为https://www.360docs.net/doc/8e4835772.html,ng.Class类型表示

Class本身表示一个类的本身，通过Class可以完整地得到一个类中的完整结构，包括此类中的方法定义和属性定义等。

常用方法：

1) public static Class forName(String className) throws ClassNotFoundException

传入完整的“包.类”名称实例化Class对象

2) public Constructor[] getConstructors()throws

SecurityException

得到一个类中的全部构造方法

3)public Field[] getDeclaredFields()throws SecurityException

得到本类中单独定义的全部属性

4)public Field[] getFields()throws SecurityException

得到本类继承而来的全部属性

5) public Method[] getMethods()throws SecurityException

得到一个类中的全部方法

6) public Method getMethod(String name,Class...parameter Types)

throws NoSuchMethodException,SecurityException

返回一个Method对象，并设置一个方法中的所有参数类型

7) public Class[] getInterfaces() 得到一个类中所有实现的全部接口

8) public String getName() 得到一个类完整的"包.类"名称

9) public Package getPackage() 得到一个类的包

10) public Class getSuperclass() 得到一个类的父类

11) public Object newInstance()throws

InstantiantionException,IllegalAccessException

根据Class 定义的类实例化对象

12) public ClassgetComponentType() 返回表示数组类型的Class

13） public boolean isArray() 判断此Class是否是一个数组

Class类本身没有定义构造方法，所以如果要使用则首先必须通过forName()方法实例化对象，也可以

使用“类.class”或“对象.getClass()”方法实例化

调用有参数构造实例化对象：

只有在操作时需要明确地调用类中的构造方法，并将参数传递进去之后才可以进行实例化操作：

步骤：(1)通过Class类中的getConstructors()取得本类中的全部构造方法

(2)向构造方法中传递一个对象数组进去，里面包含了构造方法中所需的各个参数

(3)之后通过Constructor实例化对象

此处使用了Construtor类，表示构造方法。常用方法如下：

public int getMedifiers() 得到构造方法的修饰符

public String getName() 得到构造方法的名称

public Class[]getParameterType()得到构造方法中参数的类型

pubic String toString() 返回此构造方法的信息

public T newInstance(Object...initrgs)throws

InstantiationException,

IllegalAccessException,IllegalArgumentException,InvocationTargetE xception

向构造方法中传递参数，实例化对象

反射的应用--取得类的结构：在https://www.360docs.net/doc/8e4835772.html,ng.reflect包中有以下几个类：

Constructor:表示类中的构造方法

Field:表示类中的属性

Method:表示类中的方法

这三个类都是AccessibleObject类的子类。

取得所实现的全部接口

要取得一个类所实现的全部接口，则必须使用Class类中的getInterfaces()方法.定义如下：

public Class[] getInterface()

getInterface()返回一个Class类的对象数组，之后直接利用Class类中的getName()方法输出即可

取得父类：

一具类可以实现多个接口，但是只能继承一个父类，所以如果要取得一个类的父类，可以直接使用Class类中的getSuperclass()方法。此方法定义如下：

public ClassgetSuperclass()

getSuperclass()返回的是Class实例，和之前得到一个接口一样，可以通过getName()方法取得名称

取得全部方法

使用Class类中的getMethods()方法，此方法返回一个Method类的对象数组。而如果要进一步取得方法

的具体信息，则就必须依靠Method类，此类常用方法如下：

A) public int getModifiers() 取得本方法的访问修饰符

B) public String getName() 取得方法的名称

C) public Class[] getParameterTypes() 得到方法的全部参数类型

D) public Class getReturnType() 得到方法的返回值类型

E) public Class[] getExceptionTypes() 得到一个方法的全部抛出异常

F) public Object invoke(Object obj,Object...args) throws

IllegalAccessException,IllegalArgumentException,InvocationTargetE xceiption

通过反射调用类中的方法，此方法在后面将为读者介绍

取得全部属性：两种不同的操作

A).得到实现的接口或父类中的公共属性：public Field[] getFields()throws SecurityException

B). 得到本类中的全部属性：public Field[] getDeclaredFields()throws SecurityException

每个Field对象表示类中的一个属性，要取得属性的进一步信息，还需要Field类的常用方法如下：

1）public Object get(Object obj)throws

IllegalArgumentException,IllegalAccessException

得到一个对象中属性的具体内容

2）public void set(Object obj,Object value)throws IllegalArgumentException,IllegalAccessException

设置指定对象中属性的具体内容

3）public int getModifiers()得到属性的修饰符

4）public String getName()返回属性的名称

5）public boolean isAccessible()判断此属性是否可被外部访问

6）public void setAccessible(boolean flag)throws SecurityException设置一个属性是否可以被外部访问

7）public statci void setAccessible(AccessibleObject[]

array,boolean flag)throws SecurityExceiption

设置一组属性是否可被外部访问

8) public String toString() 返回此Field类的信息

通过反射调用类中的方法

操作步骤如下：

1）通过Class类的getMethod(String name,Class...parameterTypes)方法取得一个Method的对象，

并设置此方法操作时所需要的参数类型

2）之后才可以使用invoke进行调用，并方法中传递要设置的参数

通过反射操作属性：

在反射操作中虽然可以用Method调用类中的setter及getter方法设置和取得属性，但是这样操作毕竟很麻烦，所以在

反射机制中也可以直接通过Field类操作类中的属性，通过Field类提供的set()和get()就可以完成设置和取得属性内容的

操作。但是在操作前需要注意的是，在类中的所有属性已经都设置成私有的访问权限，所以在使用set()或get()方法时首先要

使用Field类中的setAccessible(true)方法将需要操作的属性设置成可以被外部访问。

通过反射操作数组：

反射机制不仅只能用在类上，还可以应用在任意的引用数据类型的数据上，当然，这本身就包含了数组，即可以使用反射操作数组。

可以通过Class类的以下方法取得一个数组的Class对象

public Class getComponentType()

在反射操作包https://www.360docs.net/doc/8e4835772.html,ng.reflect中使用Array类表示一个数组，可以通过此类取得数组长度，取得数组内容的操作。

Array类常用方法如下：

public static Object get(Object array,int index)

throws

IllegalArgumetnException,ArrayIndexOutOfBoundsException

根据下标取得数组内容

public static Object newInstance(Class componentType,int length)throws NegativeArraySizeException

根据已有的数组类型开辟新的数组对象

public static void set(Object array,int index,Object value)throws IllegalArgumentException,ArrayIndexOutOfBoundsException

修改指定位置的内容

7. Java 反射 https://www.360docs.net/doc/8e4835772.html,ng.reflect

1) 反射是Java自我管理(类, 对象)的机制

2) * 可以通过反射机制发现对象的类型发现类型的方法/属性/构造器

3) * Java 反射可以创建对象并访问任意对象方法和属性等

4) Class 加载

类加载到内存: java 将磁盘类文件加载到内存中,为一个对象(实例)

这个对象是Class的实例, 也就是这些对象都是Class实例

5)Class 实例代表Java中类型, 基本类型的类型: int.class, long.class

类类型 Class 实例获得如下:

Class cls = String.class;

Class cls = Class.forName("https://www.360docs.net/doc/8e4835772.html,ng.String");

Class cls = "abc".getClass();

以上方法获得cls 是同一个对象, 就是String 类内存加载的结果?

动态代理

之前曾为读者讲解过代理机制的操作，但是所讲解的代理设计属于静态代理，

因为每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理。

最好的做法是可以通过一个代理类完成全部的代理功能，那么此时必须使用动态代理完成。

在java中要想实现动态代理机制，则需要https://www.360docs.net/doc/8e4835772.html,ng.reflect.InvocationHandler 接口和

https://www.360docs.net/doc/8e4835772.html,ng.reflect.Proxy类的支持。

InvocationHandler接口的定义如下：

public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{}

在此接口中只定义了一个invoke()方法，此方法中有3个参数，意义如下：

Object proxy:被代理的对象

Method method:要调用的方法

Object args[]:方法调用时所需要的参数

Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类。Proxy类提供了如下的操作方法：

public static Object newProxyInstance(ClassLoader loader,

Class[] interfaces,InvocationHandler h) throws IllegaArgumentException

通过newProxyInstance()方法可以动态地生成实现类，此方法中的参数意义如下：

ClassLoader loader:类加载器

Class[] interfaces:得到全部的接口

InvocationHandler h :得到InvocationHandler接口的子类实例

提示：类加载器

在Proxy类的newProxyInstance()方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，

在java中主要有以下3种类加载器。

BootStrap ClassLoader:此加载器采用C++编写，一般开发中是看不到的。

Extension ClassLoader:用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类。

AppClassLoader:加载classpath指定的类，是最常使用的一种加载器。

装饰模式

流的构造就是一个装饰模式的完整应用。节点流就像是一个最原始的元素，拥有有限的能力，过滤流就像是各种装饰

元素，它们通过节点流来构造一个功能强大的流，如

BufferedInputStream,DataInputStream. . .

字节流与字符流之间的… 桥接器… ，对于输出流来说，它可以把字节流转变成字符流，（InputStreamReader）

而对于输入流来说，它可以把字符流转换成字节流，，（OutputStreamWriter）;

所以，用一个字节输入流来构造一个字符流如下：

BufferedReader br = new BufferedReader(new InputStreamReader(new InputStream());

如果想从键盘获得收入：可以这样封装一个 BufferedReader;

BufferedReader br = new BufferedReader(new

InputStreamReader(System.in));

当然，对于“桥梁”，是可以指定字符编码方式的

注：我们在多线程讲过，等待数据输入是会产生阻塞的。所以read()方法是会产生阻塞的。

而对于 BufferdReader 中的 readLine() 方法，只有读到换行，它才会打破阻塞！一定要注意！

现在，我们来介绍如何让一个对象持入化呢？

实现一个接口： Serializable 接口

这是一个标记接口，不需要实现任何方法

实现了 Serializable 接口的类的对象就可以序列化，注：如果此类中包含其它的类对象，则那个类也必需要实现

Serializable 接口。

其实，序列化一个对象，就是序列化它所包含的属性。

那么如何有先择地序列化其中某些属性，而某些属性是不序列化呢？

关键字： transient 它用来修饰实例变量表示此实例变量不被序列化。

如： class Student implements Seriailizable {

String name;

int transient age; //在写对象时，age 属性将不被序列化，在读到此属性时，它的值为 0；

}

注：Serializable 接口不能自己定义序列化逻辑，它的子接口：Externalizable 接口，它可以让你自己定义序列化

对象的逻辑。详见 API，这里不多做介绍

小结：

1. 使用 ObjectInputStream 和 ObjectOutputStream 来读写对象

2. 对象必须要实现 Serializable 接口

3. 属性是对象，也要实现 Serializable 接口

4. 关键字 transient 来让属性不序列化

5. 用 Externalizable 来定义自己的序列化逻辑。

类： RandomAccessFile 它实现了 DataInput, DataOutput 接口；可读/可写此类可以访问一个文件中的随机位置（并不一定是从头到尾）

方法：

getFilePoint() //获得此文件中的当前偏移量

seek(long pos); //定位当前指针的偏移量

read(), read(byte[] buf), read(byte[] buf, int off, int len); write(int b), write(byte[] buf), write(byte[] buf, int off, int len);

(一) ObjectInputStream

对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

ObjectOutputStream 和 ObjectInputStream 分别与 FileOutputStream 和FileInputStream 一起使用时，

可以为应用程序提供对对象图形的持久存储。

只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。

readObject 方法用于从流读取对象。应该使用 Java 的安全强制转换来获取所需的类型。

在 Java 中，字符串和数组都是对象，所以在序列化期间将其视为对象。读取时，需要将其强制转换为期望的类型。

可以使用 DataInput 上的适当方法从流读取基本数据类型。

例如，要从由 ObjectOutputStream 中的示例写入的流读取：

FileInputStream fis = new FileInputStream("t.tmp");

ObjectInputStream ois = new ObjectInputStream(fis);

int i = ois.readInt();

String today = (String) ois.readObject();

Date date = (Date) ois.readObject();

ois.close();

(二) ObjectOutputStream extends OutputStream

ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。

writeObject 方法用于将对象写入流中。所有对象（包括 String 和数组）都可以通过writeObject 写入。

可将多个对象或基元写入流中。必须使用与写入对象时相同的类型和顺序从相应ObjectInputstream 中读回对象。

writeObject 方法负责写入特定类的对象状态，以便相应的 readObject 方法可以恢复它

例如，要写入可通过 ObjectInputStream 中的示例读取的对象，请执行以下操作：

FileOutputStream fos = new FileOutputStream("t.tmp");

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeInt(12345);

oos.writeObject("Today");

oos.writeObject(new Date());

oos.close();

(三) ByteArrayInputStream extends InputStream

ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。

关闭 ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。

ByteArrayOutputStream extends OutputStream

此类实现了一个输出流，其中的数据被写入一个 byte 数组。

缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。

toByteArray() 创建一个新分配的 byte 数组。返回：byte[]

抽象类和接口的区别

相同点：

1. 都可以被继承

2. 都不能被实例化

3. 都可以包含方法声明

4. 其派生类必须实现未实现的方法

不同点：

1. abstract class 可以定义字段、属性、方法实现。

Interface 只能定义属性、方法声明、索引器和事件，不能包含字段

2. abstract class 只能被单一继承

interface 可以被多重实现

3. abstract class 是从一类对象中抽象出来的概念，反映的是对象的内在共性

interface 是一种行为规范，是为了满足外部调用而定义的一个功能约定，反映的是事物的外部特性

总结一下：

当在差异较大的对象间寻求功能上的共性时，使用interface

当在共性较多的对象间寻求功能上的差异时，使用abstract class

一些经验：

1. 时刻记住面向对象思想的最重要原则：面向接口编程

2. abstract class 主要应用于密切相关的对象，interface适合为不相关的类提供通讯功能

3. abstract class 多定义了对象的属性，interface 多定义了对象的行为

4. 尽量将interface 设计成功能单一的模块

5. 如果预计会出现版本式问题，最好使用abstract class 来实现

Java中的线程有五种状态

分别是：新建、就绪、运行、死亡、阻塞。

1．新建状态：当利用new关键字创建线程对象实例后，它仅仅作为一个对象实例存在，JVM没有为其分配线程运行资源；对处于创建状态的线程可以进行两种操作：一是启动(start)操作，使其进入可运行状态，二是终止(stop)操作，使其进入消亡状态。如果进入到消亡状态，那么，此后这个线程就不能进入其他状态，也就是说，它不再存在了。（不能进入阻塞状态）

start方法是对应启动操作的方法，其具体功能是为线程分配必要的系统资源；将线程设置为就绪状态，从而可以使系统调度这个线程。

2．就绪状态(可运行状态)：在处于新建状态的线程中调用start方法将线程的状态转换为就绪状态。这时，线程已经得到除CPU时间之外的其它系统资源，只等JVM的线程调度器按照线程的优先级对该线程进行调度，从而能够获得CPU时间片的机会。

在可运行状态可以进行多种操作，最通常的是从run()方法正常退出而使线程结束，进入消亡状态。此外，还可以有如下操作：

挂起操作，通过调用suspend方法来实现；//须通过恢复(resume)操作使线程回到可运行状态。

睡眠操作，通过调用sleep方法来实现；

等待操作，通过调用wait方法来实现；

退让操作，通过调用yield方法来实现；//把CPU控制权提前转交给同级优先权的其他线程。

终止操作，通过调用stop方法来实现。

前面三种操作都会使一个处于可运行状态的线程进入不可运行状态。

3．阻塞状态：线程能够运行，但有某个条件阻止它运行。当线程处于阻塞状态时，调度机制将忽略线程，不会分配给线程任何CPU时间。直到线程重新进入了就绪状态，它才有可能执行操作。

一个处于可运行状态的线程，如果遇到挂起(suspend)操作、睡眠(sleep)操作或者等待(wait)操作，就会进入不可运行状态(阻塞状态)。另外，如果一个线程是和I/O操作有关的，那么，在执行I/O指令时，由于外设速度远远低于处理器速度而使线程受到阻塞，从而进入不可运行状态，只有外设完成输入/输出之后，该线程才会自动回到可运行状态。线程进入不可运行状态后，还可以再回到可运行状态。通常有三种途径使其恢复到可运行状态。

一是自动恢复。通过睡眠(sleep)操作而进入不可运行状态的线程会在过了指定睡眠时间以后自动恢复到可运行状态；由于I/O阻塞而进入不可运行状态的线程在外设完成I/O操作后，自动恢复到可运行状态。

二是用恢复(resume)方法使其恢复。如果一个线程由于挂起(suspend)操作而从可运行状态进入不可运行状态，那么，必须用恢复(resume)操作使其再恢复到可运行状态。

三是用通知(notify或notiyA11)方法使其恢复。如果由于等待(wait)操作转入不可运行状态，那么，必须通过调用notify方法或notifyAll方法才能使其恢复到可运行状态。采用等待操作往往是由于线程需要等待某个条件变量，当获得此条件变量后，便可由notify或notifyAll方法使线程恢复到可运行状态。

在不可运行状态，也可由终止（stop）操作使其进入消亡状态。

4．死亡状态：当线程的run()方法完成时就认为它死去。线程一旦死亡，就不能复生。如果在一个死去的线程上调用start()方法，会抛出https://www.360docs.net/doc/8e4835772.html,ng.IllegalThreadStateException异常。

线程在一定条件下，状态会发生变化。

在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。注意：阻塞态只能进入就绪态。

常见线程名词解释

主线程：JVM调用程序main()所产生的线程。

当前线程：这个是容易混淆的概念。一般指通过Thread.currentThread()来获取的线程。由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。

后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的垃圾回收线程就是一个后台线程。常见的运行时异常

ArithmeticException（除数为0的异常）, BufferOverflowException（缓冲区上溢异常）, BufferUnderflowExc eption（缓冲区下溢异常）, IndexOutOfBoundsException（出界异常）, NullPointerException（空指针异常）,

EmptyStackException（空栈异常）, IllegalArgumentException（不合法的参数异常）, NegativeArraySizeEx ception, NoSuchElementException, SecurityException, SystemException, UndeclaredThrowableException

1. https://www.360docs.net/doc/8e4835772.html,ng.NullPointerException

异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话）

2. https://www.360docs.net/doc/8e4835772.html,ng.ClassNotFoundException异常的解释是"指定的类不存在"。

3. https://www.360docs.net/doc/8e4835772.html,ng.ArithmeticException这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常。

4. https://www.360docs.net/doc/8e4835772.html,ng.ArrayIndexOutOfBoundsException

异常的解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。

5. https://www.360docs.net/doc/8e4835772.html,ng.IllegalArgumentException

这个异常的解释是"方法的参数错误"，比如g.setColor(int red,int green,int blue)这个方法中的三个值，如果有超过２５５的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。

6. https://www.360docs.net/doc/8e4835772.html,ng.IllegalAccessException

这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了Package的情况下要注意这个异常。

异常语句

2.3.1 try语句可能会抛弃一个或多个例外。

2.3.2catch语句，包括一个例外类型和一个例外对象。例外类型必须为Throwable类的子类，它指明了catch语句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕捉，大括号中包含对象的处理，其中可以调用对象的方法。

catch语句可以有多个，分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配的catch语句为止。

也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类。

2.3.3finally语句

finally所指定的代码都要被执行，通常在finally语句中可以进行资源的清除工作。如关闭打开的文

件等。

2.3.4throws语句

throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。假如你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。

2.3.5throw语句

throw总是出现在函数体中，用来抛出一个异常。

3 要害字及其中语句流程详解

3.1try的嵌套

每当碰到一个try语句，异常的框架就放到堆栈上面，直到所有的try语句都完成。假如下一级的try 语句没有对某种异常进行处理，堆栈就会展开，直到碰到有处理这种异常的try语句。下面是一个try语句嵌套的例子。

class MultiNest {

static void procedure() {

try {

int a = 0;

int b = 42/a;

} catch(https://www.360docs.net/doc/8e4835772.html,ng.ArithmeticException e) {

System.out.println("in procedure, catch ArithmeticException: " + e);

}

}

public static void main(String args[]) {

try {

procedure();

} catch(https://www.360docs.net/doc/8e4835772.html,ng. Exception e) {

System.out.println("in main, catch Exception: " + e);

}

}

}

这个例子执行的结果为：

in procedure, catch ArithmeticException: https://www.360docs.net/doc/8e4835772.html,ng.ArithmeticException: / by zero

成员函数procedure里有自己的try/catch控制，所以main不用去处理ArrayIndexOutOfBoundsException；当然如果在procedure中catch到异常时使用throw e;语句将异常抛出，那么main当然还是能够捕捉并处理这个procedure抛出来的异常。例如在procedure函数的catch中的System.out语句后面增加throw e;语句之后，执行结果就变为：

in procedure, catch ArithmeticException: https://www.360docs.net/doc/8e4835772.html,ng.ArithmeticException: / by zero

in main, catch Exception: https://www.360docs.net/doc/8e4835772.html,ng.ArithmeticException: / by zero

我认为try catch和正常的if else一样都是程序流程块，同样他们内部定义的变量对外部都是不可见的。如果try中的程序执行过程中有异常e抛出，如果e是catch中的定义的异常或是其子类，那么程序就会跳转到catch那边执行catch中的程序，如果catch中的程序又有异常抛出，那么就看这个异常有没有新的try catch块来捕获它，如果没有的话，那它就抛出了，程序中止执行。关于finally的理解就是任何调用try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的，编译器把finally中的return实现为一个warning。

3.5 如何抛出异常

如果你知道你写的某个函数有可能抛出异常，而你又不想在这个函数中对异常进行处理，只是想把它抛出去让调用这个函数的上级调用函数进行处理，那么有两种方式可供选择：

第一种方式：直接在函数头中throws SomeException，函数体中不需要try/catch。

第二种方式：使用try/catch，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。

第三种方法：使用try/catch/finally。

Sleep与wait的区别？

1、这两个方法来自不同的类分别是Thread和Object

2、最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

3、wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用（使用范围）

4、sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

sleep方法属于Thread类中方法，表示让一个线程进入睡眠状态，等待一定的时间之后，自动醒来进入到可运行状态，不会马上进入运行状态，因为线程调度机制恢复线程的运行也需要时间，一个线程对象调用了sleep方法之后，并不会释放他所持有的所有对象锁，所以也就不会影响其他进程对象的运行。但在sleep的过程中过程中有可能被其他对象调用它的interrupt(),产生InterruptedException异常，如果你的程序不捕获这个异常，线程就会异常终止，进入TERMINA TED状态，如果你的程序捕获了这个异常，那么程序就会继续执行catch 语句块（可能还有finally语句块）以及以后的代码。

注意sleep()方法是一个静态方法，也就是说他只对当前对象有效，通过t.sleep()让t对象进入sleep，这样的做法是错误的，它只会是使当前线程被sleep 而不是t线程wait属于Object的成员方法，一旦一个对象调用了wait方法，必须要采用notify()和notifyAll()方法唤醒该进程;如果线程拥有某个或某些对象的同步锁，那么在调用了wait()后，这个线程就会释放它持有的所有同步资源，而不限于这个被调用了wait()方法的对象。wait()方法也同样会在wait的过程中有可能被其他对象调用interrupt()方法而产生InterruptedException，效果以及处理方式同sleep()方法

Wait的扩展: 如何实现事件通知模型

Message类：

package com.tarena.thread;

public class Message {

public String msg;

}

MessagerHandler 类：

package com.tarena.thread;

import java.util.concurrent.ConcurrentLinkedQueue;

import java.util.concurrent.atomic.AtomicBoolean;

public class MessagerHandler {

private Object _lockObj = new Object();

private ConcurrentLinkedQueue msgs = new ConcurrentLinkedQueue();

private AtomicBoolean isRunning = new AtomicBoolean(false);

public MessagerHandler() {

new Thread("handlerThread") {

public void run() {

isRunning.set(true);

_handle();

}

}.start();

}

/**

* 发送消息

*

* @param msg

*/

public final void notifyMessage(Message msg) {

msgs.add(msg);

synchronized (_lockObj) {

_lockObj.notify();

}

}

private void _handle() {

while (isRunning.get()) {

if (msgs.isEmpty()) {

synchronized (_lockObj) {

try {

_lockObj.wait();// 等待

} catch (InterruptedException e) {

}

}

} else {

handle(msgs.poll());

}

}

}

protected void handle(Message msg) {

}

}

MessageHandler类：

package com.tarena.thread;

public class TestHandler extends MessagerHandler{ @Override

protected void handle(Message msg) {

System.out.println("接收到的消息为:"+msg.msg);

}

/**

* @param args

*/

public static void main(String[] args) {

Message msg = new Message();

msg.msg = "测试消息驱动";

new TestHandler().notifyMessage(msg);

}