java有问题 什么处理才行？Java编程中异常处理的优劣之道

这篇文章给大家聊聊关于java有问题 什么处理才行，以及Java编程中异常处理的优劣之道对应的知识点，希望对各位有所帮助，不要忘了收藏本站哦。

在java中,异常处理的机制有哪几种,分别是什么

1引子

try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。不信？那你看看下面的代码，“猜猜”它执行后的结果会是什么？不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。

package myExample.testException;

public class TestException{

public TestException(){

}

boolean testEx() throws Exception{

boolean ret= true;

try{

ret= testEx1();

}catch(Exception e){

System.out.println("testEx, catch exception");

ret= false;

throw e;

}finally{

System.out.println("testEx, finally; return value="+ret);

return ret;

}

}

boolean testEx1() throws Exception{

boolean ret= true;

try{

ret= testEx2();

if(!ret){

return false;

}

System.out.println("testEx1, at the end of try");

return ret;

}catch(Exception e){

System.out.println("testEx1, catch exception");

ret= false;

throw e;

}

finally{

System.out.println("testEx1, finally; return value="+ret);

return ret;

}

}

boolean testEx2() throws Exception{

boolean ret= true;

try{

int b=12;

int c;

for(int i=2;i>=-2;i--){

c=b/i;

System.out.println("i="+i);

}

return true;

}catch(Exception e){

System.out.println("testEx2, catch exception");

ret= false;

throw e;

}

finally{

System.out.println("testEx2, finally; return value="+ret);

return ret;

}

}

public static void main(String[] args){

TestException testException1= new TestException();

try{

testException1.testEx();

}catch(Exception e){

e.printStackTrace();

}

}

}

你的答案是什么？是下面的答案吗？

i=2

i=1

testEx2, catch exception

testEx2, finally; return value=false

testEx1, catch exception

testEx1, finally; return value=false

testEx, catch exception

testEx, finally; return value=false

如果你的答案真的如上面所说，那么你错啦。^_^，那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改、执行、测试，你会发现有很多事情不是原来想象中的那么简单的。

现在公布正确答案：

i=2

i=1

testEx2, catch exception

testEx2, finally; return value=false

testEx1, finally; return value=false

testEx, finally; return value=false

2基础知识

2.1相关概念

例外是在程序运行过程中发生的异常事件，比如除0溢出、数组越界、文件找不到等，这些事件的发生将阻止程序的正常运行。为了加强程序的鲁棒性，程序设计时，必须考虑到可能发生的异常事件并做出相应的处理。C语言中，通过使用if语句来判断是否出现了例外，同时，调用函数通过被调用函数的返回值感知在被调用函数中产生的例外事件并进行处理。全程变量ErroNo常常用来反映一个异常事件的类型。但是，这种错误处理机制会导致不少问题。

Java通过面向对象的方法来处理例外。在一个方法的运行过程中，如果发生了例外，则这个方法生成代表该例外的一个对象，并把它交给运行时系统，运行时系统寻找相应的代码来处理这一例外。我们把生成例外对象并把它提交给运行时系统的过程称为抛弃(throw)一个例外。运行时系统在方法的调用栈中查找，从生成例外的方法开始进行回朔，直到找到包含相应例外处理的方法为止，这一个过程称为捕获(catch)一个例外。

2.2 Throwable类及其子类

用面向对象的方法处理例外，就必须建立类的层次。类 Throwable位于这一类层次的最顶层，只有它的后代才可以做为一个例外被抛弃。图1表示了例外处理的类层次。

从图中可以看出，类Throwable有两个直接子类：Error和Exception。Error类对象（如动态连接错误等），由Java虚拟机生成并抛弃（通常，Java程序不对这类例外进行处理）；Exception类对象是Java程序处理或抛弃的对象。它有各种不同的子类分别对应于不同类型的例外。其中类RuntimeException代表运行时由Java虚拟机生成的例外，如算术运算例外ArithmeticException(由除0错等导致)、数组越界例外ArrayIndexOutOfBoundsException等；其它则为非运行时例外，如输入输出例外IOException等。Java编译器要求Java程序必须捕获或声明所有的非运行时例外，但对运行时例外可以不做处理。

图1例外处理的类层次

2.3异常处理关键字

Java的异常处理是通过5个关键字来实现的：try，catch，throw，throws，finally。JB的在线帮助中对这几个关键字是这样解释的：

Throws: Lists the exceptions a method could throw.

Throw: Transfers control of the method to the exception handler.

Try： Opening exception-handling statement.

Catch： Captures the exception.

Finally： Runs its code before terminating the program.

2.3.1 try语句

try语句用大括号{}指定了一段代码，该段代码可能会抛弃一个或多个例外。

2.3.2 catch语句

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

catch语句可以有多个，分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配的catch语句为止。这里，类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序应该是从特殊到一般。

也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类，程序设计中要根据具体的情况来选择catch语句的例外处理类型。

2.3.3 finally语句

try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。通过finally语句可以指定一块代码。无论try所指定的程序块中抛弃或不抛弃例外，也无论catch语句的例外类型是否与所抛弃的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。

2.3.4 throws语句

throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。对大多数Exception子类来说，Java编译器会强迫你声明在一个成员函数中抛出的异常的类型。如果异常的类型是Error或 RuntimeException，或它们的子类，这个规则不起作用，因为这在程序的正常部分中是不期待出现的。如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。

2.3.5 throw语句

throw总是出现在函数体中，用来抛出一个异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。

3关键字及其中语句流程详解

3.1 try的嵌套

你可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部，写另一个try语句保护其他代码。每当遇到一个try语句，异常的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种异常进行处理，堆栈就会展开，直到遇到有处理这种异常的try语句。下面是一个try语句嵌套的例子。

class MultiNest{

static void procedure(){

try{

int a= 0;

int b= 42/a;

} catch(java.lang.ArithmeticException e){

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

}

}

public static void main(String args[]){

try{

procedure();

} catch(java.lang. Exception e){

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

}

}

}

这个例子执行的结果为：

in procedure, catch ArithmeticException: java.lang.ArithmeticException:/ by zero

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

in procedure, catch ArithmeticException: java.lang.ArithmeticException:/ by zero

in main, catch Exception: java.lang.ArithmeticException:/ by zero

3.2 try-catch程序块的执行流程以及执行结果

相对于try-catch-finally程序块而言，try-catch的执行流程以及执行结果还是比较简单的。

首先执行的是try语句块中的语句，这时可能会有以下三种情况：

1．如果try块中所有语句正常执行完毕，那么就不会有其他的“动做”被执行，整个try-catch程序块正常完成。

2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：

²如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；如果catch块执行正常，那么try-catch程序块的结果就是“正常完成”；如果该catch块由于原因R突然中止，那么try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。

²如果异常V没有catch块与之匹配，那么这个try-catch程序块的结果就是“由于抛出异常V而突然中止（completes abruptly）”。

3．如果try由于其他原因R突然中止（completes abruptly），那么这个try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。

3.3 try-catch-finally程序块的执行流程以及执行结果

try-catch-finally程序块的执行流程以及执行结果比较复杂。

首先执行的是try语句块中的语句，这时可能会有以下三种情况：

1．如果try块中所有语句正常执行完毕，那么finally块的居于就会被执行，这时分为以下两种情况：

²如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。

²如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”

2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：

²如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；这时就会有两种执行结果：

²如果catch块执行正常，那么finally块将会被执行，这时分为两种情况：

²如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。

²如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”

²如果catch块由于原因R突然中止，那么finally模块将被执行，分为两种情况：

²如果如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。

²如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。

（注意，这里就正好和我们的例子相符合，虽然我们在testEx2中使用throw e抛出了异常，但是由于testEx2中有finally块，而finally块的执行结果是complete abruptly的（别小看这个用得最多的return，它也是一种导致complete abruptly的原因之一啊——后文中有关于导致complete abruptly的原因分析），所以整个try-catch-finally程序块的结果是“complete abruptly”，所以在testEx1中调用testEx2时是捕捉不到testEx1中抛出的那个异常的，而只能将finally中的return结果获取到。

如果在你的代码中期望通过捕捉被调用的下级函数的异常来给定返回值，那么一定要注意你所调用的下级函数中的finally语句，它有可能会使你throw出来的异常并不能真正被上级调用函数可见的。当然这种情况是可以避免的，以testEx2为例：如果你一定要使用finally而且又要将catch中throw的e在testEx1中被捕获到，那么你去掉testEx2中的finally中的return就可以了。

这个事情已经在OMC2.0的MIB中出现过啦：服务器的异常不能完全被反馈到客户端。）

²如果异常V没有catch块与之匹配，那么finally模块将被执行，分为两种情况：

²如果finally块执行顺利，那么整个try-catch-finally程序块的结局就是“由于抛出异常V而突然中止（completes abruptly）”。

²如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，异常V将被抛弃。

3．如果try由于其他原因R突然中止（completes abruptly），那么finally块被执行，分为两种情况：

²如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。

²如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。

3.4 try-catch-finally程序块中的return

从上面的try-catch-finally程序块的执行流程以及执行结果一节中可以看出无论try或catch中发生了什么情况，finally都是会被执行的，那么写在try或者catch中的return语句也就不会真正的从该函数中跳出了，它的作用在这种情况下就变成了将控制权（语句流程）转到finally块中；这种情况下一定要注意返回值的处理。

例如，在try或者catch中return false了，而在finally中又return true，那么这种情况下不要期待你的try或者catch中的return false的返回值false被上级调用函数获取到，上级调用函数能够获取到的只是finally中的返回值，因为try或者catch中的return语句只是转移控制权的作用。

3.5如何抛出异常

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

第一种方式：直接在函数头中throws SomeException，函数体中不需要try/catch。比如将最开始的例子中的testEx2改为下面的方式，那么testEx1就能捕捉到testEx2抛出的异常了。

boolean testEx2() throws Exception{

boolean ret= true;

int b=12;

int c;

for(int i=2;i>=-2;i--){

c=b/i;

System.out.println("i="+i);

}

return true;

}

第二种方式：使用try/catch，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：

boolean testEx2() throws Exception{

boolean ret= true;

try{

int b=12;

int c;

for(int i=2;i>=-2;i--){

c=b/i;

System.out.println("i="+i);

}

return true;

}catch(Exception e){

System.out.println("testEx2, catch exception");

Throw e;

}

}

第三种方法：使用try/catch/finally，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：

boolean testEx2() throws Exception{

boolean ret= true;

try{

int b=12;

int c;

for(int i=2;i>=-2;i--){

c=b/i;

System.out.println("i="+i);

throw new Exception("aaa");

}

return true;

}catch(java.lang.ArithmeticException e){

System.out.println("testEx2, catch exception");

ret= false;

throw new Exception("aaa");

}finally{

System.out.println("testEx2, finally; return value="+ret);

}

}

4关于abrupt completion

前面提到了complete abruptly（暂且理解为“突然中止”或者“异常结束”吧），它主要包含了两种大的情形：abrupt completion of expressions and statements，下面就分两种情况进行解释。

4.1 Normal and Abrupt Completion of Evaluation

每一个表达式（expression）都有一种使得其包含的计算得以一步步进行的正常模式，如果每一步计算都被执行且没有异常抛出，那么就称这个表达式“正常结束（complete normally）”；如果这个表达式的计算抛出了异常，就称为“异常结束（complete abruptly）”。异常结束通常有一个相关联的原因（associated reason），通常也就是抛出一个异常V。

与表达式、操作符相关的运行期异常有：

² A class instance creation expression, array creation expression, or string concatenation operatior expression throws an OutOfMemoryError if there is insufficient memory available.

² An array creation expression throws a NegativeArraySizeException if the value of any dimension expression is less than zero.

² A field access throws a NullPointerException if the value of the object reference expression is null.

² A method invocation expression that invokes an instance method throws a NullPointerException if the target reference is null.

² An array access throws a NullPointerException if the value of the array reference expression is null.

² An array access throws an ArrayIndexOutOfBoundsException if the value of the array index expression is negative or greater than or equal to the length of the array.

² A cast throws a ClassCastException if a cast is found to be impermissible at run time.

² An integer division or integer remainder operator throws an ArithmeticException if the value of the right-hand operand expression is zero.

² An assignment to an array component of reference type throws an ArrayStoreException when the value to be assigned is not compatible with the component type of the array.

4.2 Normal and Abrupt Completion of Statements

正常情况我们就不多说了，在这里主要是列出了abrupt completion的几种情况：

² break, continue, and return语句将导致控制权的转换，从而使得statements不能正常地、完整地执行。

²某些表达式的计算也可能从java虚拟机抛出异常，这些表达式在上一小节中已经总结过了；一个显式的的throw语句也将导致异常的抛出。抛出异常也是导致控制权的转换的原因（或者说是阻止statement正常结束的原因）。

如果上述事件发生了，那么这些statement就有可能使得其正常情况下应该都执行的语句不能完全被执行到，那么这些statement也就是被称为是complete abruptly.

导致abrupt completion的几种原因：

² A break with no label

² A break with a given label

² A continue with no label

² A continue with a given label

² A return with no value

² A return with a given value A

² throw with a given value, including exceptions thrown by the Java virtual machine

5关于我们的编程的一点建议

弄清楚try-catch-finally的执行情况后我们才能正确使用它。

如果我们使用的是try-catch-finally语句块，而我们又需要保证有异常时能够抛出异常，那么在finally语句中就不要使用return语句了（finally语句块的最重要的作用应该是释放申请的资源），因为finally中的return语句会导致我们的throw e被抛弃，在这个try-catch-finally的外面将只能看到finally中的返回值（除非在finally中抛出异常）。（我们需要记住：不仅throw语句是abrupt completion的原因，return、break、continue等这些看起来很正常的语句也是导致abrupt completion的原因。）

关于java 的一些问题

Java的起源

计算机发展需要2哥基本因素的驱动：

适应不断变化的环境和需求；

编程艺术的不断完善与提高

Java的由来

语法继承了c，面向对象的特性继承了c++，而且Java语言的产生与过去几十年计算机编程语言的改进和发展密切相关，语言设计的每一次革新是因为旧的语言无法解决某个基本问题所引起的，Java也不例外。

C

替代汇编语言，开发系统程序特性：易用性和功能安全性和效率稳定性和可扩展性FORTRAN：科学计算应用方面可以编写出相当高效的程序，但它不适合编写系统程序，BASIC虽然易学，但功能不够强大，并且谈不上结构化，应用到大程序令人怀疑，汇编语言虽能写出高效率的程序，但是学习或者高效地使用不容易，而且调试汇编程序也相当困难。

早期设计的计算机语言（如BASIC、COBOL、FORTRAN）没有考虑结构化，使用GOTO语句，这样做的结果是一大堆混乱的跳转语句和条件分支语句使得程序几乎不可能被读懂。Pascal虽然是结构化语言，但它的设计效率较低，而且缺少几个必需的特性，因而无法在大的编程范围内使用。20世纪70年代初期，计算机革命开始，使用早期语言进行软件开发无法满足这种需求，当然硬件资源充足，是促使c诞生的一个也许最重要的因素。

Dennis Ritchie在运行UNIX操作系统的DECPDP-11上发明并首次实现了c，而Martin Richards设计的BCPL语言导致了c语言开发成功受BCPL影响，由Brian Kernighan发明的B语言也逐渐向c语言发展演变，在此后的许多年里，Brian Kernighan和Dennis Ritchie编写的The C Programming Language（Prentice-Hall，1978）被认为是事实上的C语言标准，89年12月美国国家标准化组织（ANSI）制定了C语言的标准。

C语言的特性由实际运用该语言的人们不断提炼、测试、思考、再思考使其成为程序员们喜欢使用的语言。

C++：更上一层楼

20世纪70年代末和80年代初，C语言成为主流计算机编程语言，至今仍被广泛使用，你也许会问，既然C是一种如此成功且有用的语言，为什么还需要新的计算机语言？答案是：复杂性，纵观编程的历史，正是程序日益增加的复杂性驱使人们寻求管理复杂性的更好方法。c++正是适应了这一需求，为什么管理程序复杂性是C++产生的基本条件呢？

计算机出生：面板触发器（人工打孔）——》对于只有几百行的程序，这种办法是可行的，随着程序不断变大，人们发明汇编语言，它使用符号来代替机器指令，这样程序员就能处理更大更复杂的程序，随着程序进一步变大，高级语言产生了，它给程序员提供了更多的工具来处理复杂性问题。20世纪80年代初，许多工程项目都令结构化方法到达了极限。为解决这个问题，一种面向对象编程的新编程方法诞生，在这里先给出一个简短的定义：面向对象的编程是通过使用继承性、封装性和多态性来组织复杂程序的编程方法。

尽管C伟大，但是处理复杂性的能力有限。一旦一个程序的代码超过25000~100000行，就因为过于复杂从而很难把握，C++突破了这个限制，可以帮助程序员理解和管理更大的程序。

1979年Bjiarne Stroustrup发明C++，最初成为带类的C，83年改名C++，通过增加面向对象的特性扩充了C。因为C++建立在C的基础之上，所以包括C的所有特性、属性和优点，这是C++作为一种语言的成功的关键原因，发明C++不是企图创造一种全新的编程语言，相反，它是对一个已经高度成功的语言的改进。

Java出现的时机已经到来

20世纪80年代末和90年代初，使用面向对象编程的C++语言占主导地位，甚至有一段时间程序员似乎都认为已经找到了一种完美的语言。然而，推动计算机语言进化的力量正在酝酿。在随后的几年里，万维网和Internet事件促成了编程的另一场革命。

Java诞生

Java是由Jamcs Gosling、Patrick Naughton、Chris Warth、Ed Frank和Mike Sheridan于1991年在Sun Microsystems公司设计出来，最初推动力并非Internet而是源于对独立于平台语言的需要，这种语言可开发能嵌入微波炉、遥控器等各种家用电器设备软件。用作控制器的CPU是多种多样的，但是c和c++（以及其他绝大多数语言）的缺点是只能对特定目标进行编译。尽管为任何类型的cpu是多种多样的，但c和c++的缺点只能对特定目标进行编译，尽管为任何类型的cpu编译c++程序是可能的，但是需要一个完整的以该cpu为目标的c++编译器，而创建编译器是一项既耗费又耗时的工作，因此需要一种简单且更为经济高效的解决方案。为了找到这种方案，Gosling和其他人一起致力于开发一种致力于开发一种可移植的、平台独立的语言，该语言能够生成运行于不同环境、不同cpu上的代码，他们的努力最终促成了Java的诞生。

www诞生对java的未来起到至关重要的作用

Java与C++不兼容，对Java影响最大的是c#，二者使用相同的语法，而且均支持分布式程序设计，使用相同的对象模型等。

Java对Internet重要性

二者互补原因简单，Java扩展了可以在电脑空间自由流动的对象的世界在网络中有两大类对象在服务器和个人计算机之间传输：被动的信息和动态的、主动的程序例如，当阅读电子邮件时，是在看被动的数据，甚至当你下载一个程序时，该程序的代码也是被动的数据，直到你执行它为止。可以传输到个人计算机的另一类对象是动态的，自运行的程序，虽然这类程序是客户机上的活动代理，但却是由服务器来初始化的例如，服务器提供用来正确地显示服务器传送数据的程序。网络程序在动态上是令人满意的，但是在可移植上和安全性上却带来了严重的问题，在java出现之前有一半以上的电脑实体无法进入网络世界，是java为它们打开了便利之门，而且在这个过程中定义了一种全新的程序形式：applet（小应用程序）

Java applet

applet是可以在Internet中传输并可以兼容Java的web浏览器中运行的特殊Java程序，applet可以随需下载，就像图像、声音文件和视频文件。换句话说，它能对用户的输入做出反应，并且能动态的变化，而不是一遍又一遍地播放同一动画或声音。

如果java不能解决两个关于applet最棘手的问题：安全性和可移植性，那么applet就不会如此令人激动了

安全性

众所周知，每次下载一个正常的程序时，都要冒着被病毒感染的危险，在java出现之前，大多数用户并不经常下载可执行的程序文件，即使下载也要进行病毒检查，尽管如此，大多数用户还是担心，除了病毒还有恶意程序也要警惕，这种程序通过搜索计算机本地文件系统的内容来收集你的私人信息，例如信用卡号码，银行账户结算和口令而Java在网络应用程序和用户的计算机之间提供了一道防火墙（firewall），消除了用户这些顾虑

将java程序编译成字节码有助于更容易地在一个大的范围环境下运行程序原因非常简单，只要在各种操作平台上实现java虚拟机就可以了。在一个给定的系统中，只要系统运行时包存在，任何java程序就可以在该系统上运行。记住，尽管不同平台的java虚拟机的细节有所不同，但它们都理解相同的java字节码，如果java程序被编译为本机代码，那么对于连接到Internet上的每种cpu类型都要有该程序的对应版本，这当然不是一种可行的解决方案。因此，通过JVM执行字节码是编写真正可移植性程序最容易的方法

JVM执行java程序有助于提高安全性，因为 jvm控制java程序的运行，所以它可以包含这个程序并且能阻止它在系统之外产生负作用，而java语言特有的某些限制增强了它的安全性

java专门用语

简单（simple）安全（secure）可移植（Portable）面向对象（Object-oriented）健壮（Robust）多线程（Multithread）体系结构中立（Architecture-neutral）解释执行（Interpreted）高性能（High perforance分布式（Distributed）动态（Dynamic）

健壮性：先考虑使程序失败的两个重要原因：内存管理错误，和误操作引起的异常情况（运行时错误）。在传统的编程环境下，内存管理是一项困难乏味的任务。例如：在c++/c中程序员必须手工分配和释放所有的动态内存。就会出现问题，因为程序员可能忘记释放原来分配的内存，或者释放了其他正在使用的内存，而通过Java管理内存分配和释放，可以从根本上消除这些问题（事实上释放内存是完全自动的，因为Java为闲置的对象提供了内存垃圾自动收集）。在传统的环境下，异常情况可能经常由“除零”或“文件未找到”这样的情况所引起，而我们又必须用既笨拙又难以理解的一大堆指令来对它们进行管理，Java通过提供面向对象的异常处理机制解决这个问题。在编写良好的Java程序中，所有的运行时错误都可以并且应该有程序自身进行管理

多线程

设计Java的目标之一是满足人们对创建交互式网络程序的需要，为此，Java支持多线程编程，因而用Java编写的应用程序可以同时执行多个任务，Java运行时系统在多线程同步方面具有成熟的解决方案，能够创建出运行平稳的交互式系统，Java的多线程机制非常好用，所以只需关注程序特定的行为，不用担心多任务子系统

体系结构中立

Java设计者考虑主要问题是程序代码的持久性和可移植性。程序员面临的问题是不能保证今天的程序明天能否在同一台机器上顺利运行。操作系统升级、处理器升级以及核心系统资源的变化，都可能导致程序无法继续运行，Java设计者对这个问题做过多种尝试，Java虚拟机就是用来解决这个问题的。它们的目标是“只要写一次程序，在任何地方、任何时间该程序永远都能执行”这在很大程度上，Java实现了这个目标

解释执行和高性能

前面说过，通过把程序编译为Java字节码，Java可以产生跨平台运行的程序。该代码可以在提供Java虚拟机的任何一种系统上执行，其他的跨平台解决方案对性能要求都很高，而Java的字节码经过设计后，很容易用JIT编译器将字节码直接转换成高性能的本机代码，Java运行时，系统在提供这个特性的同时仍具有平台独立性

分布式

Java是为Internet的分布式环境而设计，因为它能处理TCP/IP协议事实上，通过URL地址访问资源与直接访问一个文件的差别并不太大。Java还支持远程方法调用（Remote Method Invocation，RMI）使程序能够跨网络调用方法。

动态：

Java程序带有多种运行时类型信息，用于在运行时校验和解决对象访问问题。这使得在一种安全，有效的方式下动态地链接代码成为可能，同时对applet环境的健壮性十分重要，因为在运行的系统中，可以动态地更新字节码内的小段程序

java的演化

Java的最初发布本不亚于一场革命，但是它并不标志着Java快速革新时代的结束。与其他软件系统经常进行小的改进不同，Java以爆炸式的步伐向前发展。Java1.0发布后不久，Java的设计者开发出了Java1.1Java1.1新增的特性远比普通意义上的版本修订的内容丰富许多，Java1.1增加了许多新的库元素，重新定义了applet处理事件的方法，并且重新设置了1.0版中库的许多特性，同时它也放弃了原来的由Java1.0定义的若干过时的特征。

java的第二个版本是java2，“2”代表是第二代，java2是一个分水岭，它标志着java现代时的开始！java2第一版本号是1.2，其原因是1.2最初指的是java库的内部版本号，后来才用作整个发行版。Sun公司将其java产品重新组装为J2SE（java2平台标准版）

java2增加了很多新特性，例如Swing和集合框架（collection framework），并且还提高了java虚拟机和各种编程工具的性能。java2也包含了一些不赞成继续使用的内容主要是Thread类中suspend（）、resume（）和stop（）等方法

Java下一个版本是J2SE1.3这个版本是Java2最初版本的第一次主要升级。该版本增强了Java大部分现有的功能，并且限制了开发环境。总的说来。版本1.2和1.3的程序源代码是兼容的

J2se1.4发布进一步增强了java此发行版包括了许多重要的升级、改进和新增功能例如，新增了关键词assert、链式异常和一个基于心道的i/o子系统，它同时对集合框架和网络类作乐改动。另外还有不计其数的小改动贯穿其中。尽管引进了很多新功能，但版本1.4几乎与先前版本几乎保持了百分之百的源代码兼容。Java的最新版本是J2se 5，它无疑是另一场革命！

J2SE最新版本是J2SE5，它无疑是另一场革命！

J2SE5革命

是java生命里程碑上一个重要的事件。与java先前大多数升级不同，j2se5提供的不是递增式的改进，而是从根本上拓展了java语言的作用域，功能和范围，java的任何一次发行都无法与J2SE5相提并论。为了领会关注一下新特性

泛型冗数据自动装箱和自动拆箱（Autoboxing和Auto-unboxing）枚举增强的for-each风格的for循环变长参数静态导入格式化I/O并行工具对API的升级

上述这些特性不是枝节的改动和递增式的升级，每一项都代表着对java语言的重大引进。比如泛型。增强的for循环类型，和变长参数，引进了新的语法元素，自动装箱和自动拆箱，改变了java的语言的句法冗数据将一种全新的标准引入到编程领域，所有这些新增特性，不仅造成了直接影响，而且还改变了java本身的基本特性

这些新增的特性重要性反映了在版本号“5”的才用上，下一个版本号正常情况应为1.5，但这些变化和新增的特性是在是太重要了仅从1.4转向1.5不足以说明变化之大，因此，Sun公司选择将发行号增至5来强调，当前产品被称为J2SE 5，开发者工具箱被称为JDK 5，不过处于维持一致性的考虑，Sun决定将内部版本号定为1.5，即“5”是外部版本号，“1.5”是内部版本号。

文化革新

从一开始，Java就处于文化革新的中心位置。它的第一个发行版重新定义了面向Internet的程序设计，Java虚拟机（JVM和字节码）改变了我们对安全性和可移植性的认识，applet（包括其后的servlet）给Web带来了盎然生机，Java社区项目重新定义了Java语言吸收新理念的方式，Java世界从来都不是静止不前一成不变的。

随着J2SE的发行，Java又一次获得涅馨，适应了变化莫测的编程前景的需求，也又一次成功地站到了计算机语言设计领域的最前沿。

Java编程中异常处理的优劣之道

Java编程中的异常处理是一个很常见的话题了，几乎任何一门介绍性的Java课程都会提到异常处理。不过，我认为很多人其实并没有真正掌握正确处理异常情况的方法和策略，最多也就不过了解个大概，知道点概念。本文就对三种不同程度和质量的Java异常处理进行了讨论，所阐述的处理异常的方式按手法的高下分为：

好，不好和恶劣三种。

同时向你提供了一些解决这些问题的技巧。

首先解释一些java异常处理中必须搞清楚的定义和机制。Java语言规范将自Error类或RuntimeException类衍生出来的任何违例都称作“不可检查”（Unchecked）异常；其他所有异常则称作“可检查”（Checked）异常。

所谓可检查异常，是指我们应该自行处理的异常。至于处理的手段，要么加以控制（try catch），要么通告（throws）他们有可能产生。通常，应捕捉那些已知如何处理的异常，而通告那些不知如何处理的异常。

而对那些不可检查异常来说，他们要么在我们的控制之外（Error），要么是我们首先就不该允许的情况（RuntimeException）。

至于异常的指定，Java的规则非常简单：一个方法必须通告自己可能产生的所有可检查异常。编写自己的方法时，并不一定要通告出方法实际可能产生的每一个异常对象，要想理解什么时候必须要方法的throws丛句来通告异常，就必须知道对一个异常来说，他只有可能在下面四种情况下才会产生：

1.调用了可能产生异常的方法。比如BufferedReader类的readLine方法。该方法通告java.io.IOException异常

2.侦测到一个错误，并用throw语句产生异常。

3.出现一个编程错误。比如a[-1]= 0。

4.Java产生内部错误。

如果出现头两种情况之一，必须告诉打算使用自己方法的人：假如使用这个方法，可能造成一个异常的产生（即在方法头上使用throws），一个简单的记忆方法：

只要含有throw,就要通告throws。如果一个方法必须同时处理多个异常，就必须在头内指出所有异常。就像下例展示的那样，用逗号对他们进行分割：

1234567

class Animation

{

public Image loadImage（Strint s） throws EOFException,MalformedURLException

{

}

}

然而，我们不需要通告内部java错误，也不应该通告自RuntimeException衍生出来的异常。

好的异常处理

好异常处理提供了处理程序错误的统一机制。事实上，Java语言通过向调用者提出异常警告的方式而显着地提升了软件开发中的异常处理能力。这种方式把Java语言中的“方法（method）”进行了扩展和增强，使之包括了自身的错误条件。下面就让我们看一个例子，这个例子说明了这种情况。

以下是FileInputStream构造器之一的原型：

public FileInputStream（String name） throws FileNotFoundException Java

的方法和构造器必须声明他们在被调用时可能“扔出”的异常，采用的关键字就是“throws”。这种在方法原型中出现的异常提示增加了编程的可靠性。

显而易见，这种方式是向方法的调用者提示了可能出现的异常条件，这样调用者就可以对这些异常作出适当的相应处理。以下代码示意我们是如何捕获并且处理FileNotFoundException这一异常的：

1234567891011

try

{

FileInputStream fis= new FileInputStream（args[0]）；

// other code here

}

catch（FileNotFoundException fnfe）

{

System.out.println（"File:"+ args[0]+" not found. Aborting."）；

System.exit（1）；

}

Java异常处理还有其他一些优秀的特性，这就是可检查异常、用户定义异常和在JDK 1.4中推出的新型Java记录API（Java Logging API）。java.lang.Exception的所有子类都属于可检查异常。可检查异常（checked exception）是扔出该异常的方法所必须提示的异常，这种异常必须被捕获或者向调用者提示。用户定义异常（User-defined exceptions）是定制的异常类，这种异常类扩展了java.lang.Exception类。优良的Java程序规定定制异常封装、报告和处理他们自己独有的情况。最新的Java记录API（logging API）则可以集中记录异常。不好的Java异常处理

不好的一面包括两种情况：滥用不可检查异常（unchecked exceptions）和滥用catchall构造器等。这两种方式都使得问题变得复杂起来。

有一种类别的异常属于RuntimeException的子类，这种异常不会受到编译器的检查。比如，NullPointerException和 ArrayStoreException就是这种类型异常的实例。程序员可以对RuntimeException进行子类化以回避检查异常的限制，从而便于产生这些异常的方法为其调用者所使用。

专业的开发团队应当只允许在很少的情况下才可以这样做。

第二种异常处理的陋习是catchall构造器。所谓的“catchall构造器”就是一种异常捕获代码模块，它可以处理所有扔给它的可能异常。

以下是catchall处理器的实例：

123456789

try

{

// code here with checked exceptions

}

catch（Throwable t）

{

t.printStackTrace（）；

}

我得承认，我自己在编写一般程序的时候就曾经用过这种技术；但是，在编写关键程序的时候这种类型的构造器一定要避免使用，除非他们被授权可以和中央错误处理器联合使用才可以这样做。

除此之外，catchall构造器不过只是一种通过避免错误处理而加快编程进度的机制。

异常处理的一个不足之处是难以采用优良的错误处理策略。从低容内存状态恢复、写入错误和算法错误等异常情况都不是轻易能得到解决的。你可以尝试一下循环、垃圾收集和提醒用户等常用技术来应付以上的局面。

恶劣的处理方法

和许多Java特性及其API类似，Java的异常处理机制也有“霸王硬上弓”类的滑稽错误。比方说，为了扔出某个异常竟然毫不犹豫地用“new”关键词为其分配内存就是这样的例子。

我自己不知道有多少次就因为犯了这种错误而在严肃的编译器面前屡屡碰壁。在这种情况下，我们其实都是在伺候语言而不是让语言为我们所用。还有我们碰到的OutOfMemoryErrors就是异常处理的缺陷。这一处理过程是：

使用finally模块关闭文件，解析异常以得到出现问题的方法和代码行。在这一过程之内最大的缺陷是需要捕获OutOfMemoryError，而这一异常却并不是可检查异常！想想看，内存耗尽是相当常见的情况。任何与内存使用状态紧密相关的程序都应当捕获和处理这一错误。

使用异常时的一些建议

1.异常控制的设计宗旨并不是用来代替一些简单的测试。只有在异常情况下才使用异常！

2.不要过分细化异常。不要在每个语句上都加上异常处理，最好将整个任务都放在try块内。如果其中有一项操作失败，可以随即放弃任务。

3.不要“压制”异常。对于需要通告异常的方法，我们可以改用捕捉的方法来将异常强行关闭，如果真的出现异常，那个异常会被“静悄悄”的忽略。如果觉得产生的异常会非常重要，就必须多费些功夫，对其进行正确的控制。

4.不要介意异常的传递。如果调用的方法会产生异常，比如readLine方法，他们天生就能捕捉自己可能产生的异常，在这种情况下，一种更好地做法是将这些异常传递出去，而不是自己动手来捕捉它。

好了，关于java有问题 什么处理才行和Java编程中异常处理的优劣之道的问题到这里结束啦，希望可以解决您的问题哈！