java中错误(error)和异常(exception)有什么主要区别
1.如图Exception 和 Error都继承自Throwable类，由jdk api文档中对该类的描述可以知道它是异常处理机制的基本组成类型。可以由虚拟机抛出或者编码者自行抛出(throw)
-
jdk8中文发翻译Throwable类的描述：Throwable类是Java语言中所有错误和异常的Throwable类。 只有作为此类（或其一个子类）的实例的对象由Java虚拟机抛出，或者可以由Java throw语句抛出。 类似地，只有这个类或其子类可以是catch子句中的参数类型。
-
在现实编程中我们一般使用 try-with-resources 和 multiple catch来进行一些异常处理(便利的特性)，在编译时期，会自动生成相应的处理逻辑，比如，自动按照约定俗成 close 那些扩展了 AutoCloseable 或者 Closeable 的对象。
-
try-with-resources 是一种处理Closeable实现类关闭资源的一种写法，简单写了一个例子可以发现其实这就是一中语法，这种语法可以自动编译帮忙编译最后关闭流的操作：
-
尽量不要捕获类似 Exception 这样的通用异常，而是应该捕获特定异常
这是因为在日常的开发和合作中，我们读代码的机会往往超过写代码，软件工程是门协作的艺术，所以我们有义务让自己的代码能够直观地体现出尽量多的信息，而泛泛的 Exception 之类，恰恰隐藏了我们的目的。另外，我们也要保证程序不会捕获到我们不希望捕获的异常。比如，你可能更希望 RuntimeException 被扩散出来，而不是被捕获。
-
不要生吞（swallow）异常。这是异常处理中要特别注意的事情，因为很可能会导致非常难以诊断的诡异情况。
如果我们不把异常抛出来，或者也没有输出到日志（Logger）之类，程序可能在后续代码以不可控的方式结束。没人能够轻易判断究竟是哪里抛出了异常，以及是什么原因产生了异常。
-
在写程序时可以通过Objects类(jdk提供),或者断言等提前判断问题，如空指针异常的一些值的处理Objects. requireNonNull(filename);而不是使用之后有问题再系统抛出异常，这可能就会不直观的找到问题所在。即:Throw early, catch late 原则
2.Exception 和 Error 体现了 Java 平台设计者对不同异常情况的分类。Exception 是程序正常运行中，可以预料的意外情况，可能并且应该被捕获，进行相应处理。
3.Error 是指在正常情况下，不大可能出现的情况，绝大部分的 Error 都会导致程序（比如 JVM 自身）处于非正常的、不可恢复状态。既然是非正常情况，所以不便于也不需要捕获，常见的比如 OutOfMemoryError 之类，都是 Error 的子类。
4.Exception 又分为可检查（checked）异常和不检查（unchecked）异常，可检查异常在源代码里必须显式地进行捕获处理，这是编译期检查的一部分。前面我介绍的不可查的 Error，是 Throwable 不是 Exception。
如何处理这些异常？
public static void main(String args) {
try (BufferedReader br = new BufferedReader(new FileReader(“a“));
BufferedWriter writer = new BufferedWriter(new FileWriter(“a“))) {
// Try-with-resources
} catch (IOException e) {// Multiple catch
// Handle it
}
}
编译后class
public static void main(String args) { try {
BufferedReader br = new BufferedReader(new FileReader(“a“));
Throwable var2 = null; try {
BufferedWriter writer = new BufferedWriter(new FileWriter(“a“));
Object var4 = null; if (writer != null) { if (var4 != null) { try {
writer.close();
} catch (Throwable var15) {
((Throwable)var4).addSuppressed(var15);
}
} else {
writer.close();
}
}
} catch (Throwable var16) {
var2 = var16; throw var16;
} finally { if (br != null) { if (var2 != null) { try {
br.close();
} catch (Throwable var14) {
var2.addSuppressed(var14);
}
} else {
br.close();
}
}
}
} catch (IOException var18) {
;
}
}
异常处理的两个基本原则
希望对您有所帮助！~
Java中Exception是什么
Exception是JAVA异常类
是Throwable的子类(Error也是她的子类，Error是比较严重的错误)
异常分为普通异常和运行时异常，运行时异常我们可以不处理，可以让虚拟机来管。
普通异常我们必须捕获(try{}catch(Exception
e){}finally{})
异常(Exception)分几种类型有什么区别写出几个常见异常
Java 中的异常（Exception）又称为例外，是一个在程序执行期间发生的事件，它中断正在执行的程序的正常指令流。为了能够及时有效地处理程序中的运行错误，必须使用异常类。
异常主要分为以下两种异常。
1、运行时异常都是 RuntimeException 类及其子类异常，如
NullPointerException、IndexOutOfBoundsException
等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般由程序逻辑错误引起，程序应该从逻辑角度尽可能避免这类异常的发生。
2、非运行时异常是指 RuntimeException
以外的异常，类型上都属于 Exception 类及其子类。程序就不能编译通过。IOException和ClassNotFoundException 等以及用户自定义的 Exception 异常，一般情况下不自定义检查异常。
扩展资料
java的exception机制：
早期的C语言的异常处理机制，通常是我们人为的对返回结果加一些标志来进行判定，比如发生错误返回什么标志，正常情况下我们又是返回什么标记，而这些都不是语言本身所赋予我们的，这种机制的问题在于，C语言的异常处理机制全是我们人为的定义。
这样就会造成业务逻辑的主线受到异常处理的牵制，或者说是我们难免会将注意力转移，并且造成业务逻辑与异常处理之间有很大程度上的缠绕。
参考资料来源：百度百科-异常
exception error是什么意思
exception ==异常，error==错误。都可归类为不正常状态或是用户不希望看到的东西。区别是error在一般情况下更加严重一些，很可能导致系统直接挂掉；exception伸缩性大，严重的也会是系统宕机，普通的会导致部分流程不正常，更简单的可能用户也感觉不到有什么异常问题。简单就这样理解吧
异常处理机制-Exception
一 简介
Java为我们提供了非常完美的异常处理机制 使得我们可以更加专心的去写程序 有的时候遇到需要添加异常处理块的地方 像eclipse会自动提示你 感觉很幸福！我们看看异常处理的一些类的结构组成
从根部开始分为两大类 Error和Exception Error是程序无法处理的错误 比如OutOfMemoryError ThreadDeath等 这些异常发生时 Java虚拟机（JVM）一般会选择线程终止 Exception是程序本身可以处理的异常 这种异常分两大类 非运行时异常（发生在编译阶段 又称checkException）和运行时异常（发生在程序运行过程中 又叫uncheckException） 非运行时异常一般就是指一些没有遵守Java语言规范的代码 容易看的出来 并且容易解决的异常 运行时异常是那些在程序运行过程中产生的异常 具有不确定性 如空指针异常等 造成空指针的原因很多 所以运行时异常具有不确定性 往往难以排查 还有就是程序中存在的逻辑错误 光从一段代码中看不出问题 需要纵观全局才能发现的错误 也会造成运行时异常 这就要求我们在写程序时多多注意 尽量处理去处理异常 当异常发生时 希望程序能朝理想的方面运行！
二 异常的类型
一方面我们可以将异常分为受控异常和不受控异常 其实一般来讲 受控异常就是非运行时异常 不受控异常就是运行时异常和Error 另一方面 我们直接将异常分为非运行时异常和运行时异常
三 异常处理的过程
使用try/catch/finally语句块安装异常处理程序 每个try块中包含可能出现异常的语句 每个catch块中包含处理异常的程序
public class Test {
public static void main（String args） {
String filename = d:\\test txt ;
try {
FileReader reader = new FileReader（filename）
Scanner in = new Scanner（reader）
String input = in next（）
int value = Integer parseInt（input）
System out println（value）
} catch （FileNotFoundException e） {
e printStackTrace（）
} finally {
System out println（ this is finally block! ）
}
}
}
如果d盘根目录下没有test txt的话 该程序抛出异常
this is finally block!
java io FileNotFoundException: d:\test txt （系统找不到指定的文件 ）
at java io FileInputStream open（Native Method）
at java io FileInputStream 《init》（FileInputStream java: ）
at java io FileInputStream 《init》（FileInputStream java: ）
at java io FileReader 《init》（FileReader java: ）
at Test main（Test java: ）
但是finally块中的语句却输出了 这个暂且不谈 先记着 在d盘下新建文件test txt 并输入内容 再来观察下
输出
this is finally block!
finally块中的语句依然输出 说明 不论程序有无异常 finally块中的语句都会执行 因此finally块中一般放一些关闭资源的语句 接下来我们继续做实验 我们将test txt中的 改成abc 看看结果
this is finally block!
Exception in thread main java lang NumberFormatException: For input string: abc
at java lang NumberFormatException forInputString（NumberFormatException java: ）
at java lang Integer parseInt（Integer java: ）
at java lang Integer parseInt（Integer java: ）
at Test main（Test java: ）
该异常中的两处重点我已经标出来了 一处是红色的Exception in thread main 表明异常抛出的地方 另一处是java lang NumberFormatException: For input string: abc 表明异常的类型 此处我们看看上面之前的那个结果 为什么没有抛出异常出现的地方 仔细观察源程序 我们发现 程序中我们并没有显式声明NumberFormatException 而FileNotFoundException是我们声明过的 此处我总结一下就是说 如果我在程序中声明了某个异常 则抛出异常的时候 不会显式出处 直接抛出 如果我没有在程序中声明 那么程序会同时抛出异常的出处 这是为什么？还有 当我没有显式声明的时候 系统会怎么办？这肯定是有一定的规律的 下面我们继续做实验
public class Test {
public static void main（String args） {
String filename = d:\\test txt ;
// 进行捕捉异常
try {
FileReader reader = new FileReader（filename）
Scanner in = new Scanner（reader）
String input = in next（）
int value = Integer parseInt（input）
System out println（value）
} catch （FileNotFoundException e） { // 捕捉FileNotFoundException
e printStackTrace（）
} catch （NumberFormatException e） { // NumberFormatException
e printStackTrace（） // 打印异常信息 就是形如 at java lang NumberFor…的信息
System out println（ I m here! ）
} finally {
System out println（ this is finally block! ）
}
}
}
我加了一个catch块 转么捕获NumberFormatException 则程序输出
java lang NumberFormatException: For input string: abc
at java lang NumberFormatException forInputString（NumberFormatException java: ）
at java lang Integer parseInt（Integer java: ）
at java lang Integer parseInt（Integer java: ）
at Test main（Test java: ）
I m here!
this is finally block!
没有输出异常抛出的地方 继续改代码
public class Test {
public void open（）{
String filename = d:\\test txt ;
try {
FileReader reader = new FileReader（filename）
Scanner in = new Scanner（reader）
String input = in next（）
int value = Integer parseInt（input）
System out println（value）
} catch （FileNotFoundException e） {
e printStackTrace（）
System out println（ this is test block! ）
}
}
}
public class Test {
public void carry（） {
Test t = new Test （）
try {
t open（）
} catch （Exception e） {
e printStackTrace（）
System out println（ this is test block! ）
}
}
}
public class Test {
public static void main（String args） {
Test t = new Test （）
t carry（）
}
}
思路是 Test 类中处理业务 Test 类调用Test 类的open方法 最后在Test类中调用Test 类的carry方法 但是 我将异常抛在Test 中 看看异常输出的结果
java lang NumberFormatException: For input string: abc
at java lang NumberFormatException forInputString（NumberFormatException java: ）
at java lang Integer parseInt（Integer java: ）
at java lang Integer parseInt（Integer java: ）
at Test open（Test java: ）
at Test carry（Test java: ）
at Test main（Test java: ）
this is test block!
首先 抛出的异常没有地方信息了 其次输出了 this is test block! 说明该异常是从Test 类中的carry方法抛出的 当我们把Test 类中的异常捕获语句注释掉的时候 异常如下
Exception in thread main java lang NumberFormatException: For input string: abc
at java lang NumberFormatException forInputString（NumberFormatException java: ）
at java lang Integer parseInt（Integer java: ）
at java lang Integer parseInt（Integer java: ）
at Test open（Test java: ）
at Test carry（Test java: ）
at Test main（Test java: ）
看到此处 我想读者朋友们应该有一定的感觉了 说了这么多 就是想说明一点 当程序处理不了异常的时候会怎么办？是这样的 当前方法如果声明了相应的异常处理器 如上面的程序如果加了catch（NumberFormatException e） 则直接抛出 但是如果没有声明 则会找到它的调用者 如果调用者也没有做相应的处理 则会一直往前找 直到找到main方法 最后抛出异常 所以上面的现象不难解释！此处我们简单总结下异常处理的过程 在可能出错的方法加上try/catch块语句 来调用异常处理器 当异常发生时 直接跳到相应的异常处理器catch中 如果有则抛出异常 执行该catch块中的语句 如果没哟 则找到它的调用者 直到main方法 如果有finally块 则执行finally块中的语句
注意
一个try可对应多个catch 有try必须至少有一个catch finally块不是必须的 可有可无 一般情况下 当异常发生时 会执行catch块中的语句 特殊情况 当main方法中抛出异常时 如果程序声明了该异常处理器 则执行相应的catch块中的语句 如果程序没有声明相应的异常处理器 则不执行catch块中的语句 直接抛出异常！那么 这个异常来源于哪儿？既然main中有try/catch语句（虽然不是对应的异常处理器） 为什么没有抛出 说明main方法中的try/catch块根本就没有捕捉到异常 那么系统怎么处理？其实是这样的 这种情况下 异常被直接丢给JVM 而JVM的处理方式就是 直接中断你的程序！就是这么简单
四 常见异常
NullPointerException 空指针
空指针异常 当应用试图在要求使用对象的地方使用了null时 抛出该异常 譬如 调用null对象的实例方法 访问null对象的属性 计算null对象的长度 使用throw语句抛出null等等
ClassNotFoundException 找不到类
找不到类异常 当应用试图根据字符串形式的类名构造类 而在遍历CLASSPAH之后找不到对应名称的class文件时 抛出该异常
ClassCastException 类型转换
ArithmeticException 算数条件
算术条件异常 譬如 整数除零等
ArrayIndexOutOfBoundsException 数组越界
数组索引越界异常 当对数组的索引值为负数或大于等于数组大小时抛出
这块内容我们会不断更新 请读者朋友们在阅读的同时 不断提出自己遇到的有意义的异常 不断充实博文 欢迎读者积极补充！
有任何问题 请联系 egg
五 异常和错误
异常 在Java中程序的错误主要是语法错误和语义错误 一个程序在编译和运行时出现的错误我们统一称之为异常 它是JVM（Java虚拟机）通知你的一种方式 通过这种方式 JVM让你知道 你已经犯了个错误 现在有一个机会来修改它 Java中使用异常类来表示异常 不同的异常类代表了不同的异常 但是在Java中所有的异常都有一个基类 叫做Exception
错误 它指的是一个合理的应用程序不能截获的严重的问题 大多数都是反常的情况 错误是JVM的一个故障（虽然它可以是任何系统级的服务） 所以 错误是很难处理的 一般的开发人员是无法处理这些错误的 比如内存溢出
六 Assert（断言）
assert是jdk 才开始支持的新功能 主要在开发和测试时开启 为保证性能 在程序正式发布后通常是关闭的 启用断言比较简单 在启动参数里设置 ea或者 enableassertions就可以了
assert表达式有两种情况
）assert exp 此时的exp 为一个boolean类型的表达式
当其值为true时 运行通过 如果为false 则会抛出一个相应的AssertionError 注意它可以被catch到
）assert exp : exp 此时的exp 同上 而exp 可以为基本类型或一个Object对象 当exp 的值为true时 同上 且exp 不会被运算 而当exp 的值为false时 将会抛出AssertionError 同时将exp 的结果作为AssertionError构造器中的参数 当使用catch该错误时 可利用getMessage（）方法打印出exp 的结果
使用断言应该注意 断言只是用来调试程序的工具 不要作为程序的一部分 或者有人用断言来代替try/catch 这些都是不对的 这和断言的作用相违背 断言在程序发布后 是会被关闭的 如果将它作为程序的一部分 那么当断言被关闭后 程序必然会出问题 有更好的方法 如try/catch 为什么还用断言 所以 最好不要讲断言作为程序的一部分 从心里上你可以把它当做可有可无就行了
七 常见问题
finally和return问题
我们平时说 finally中的内容不论程序有无异常 都会被执行 那么如果我们的程序在try和catch块中return了 finally中的还会执行吗？读者可以先猜猜看 分析一下 接下来我们做实验
public class FinallyTest {
public static void main（String args） {
boolean file = open（）
System out println（ this is main return value: + file）
}
public static boolean open（） {
String filename = d:\\test txtp ;
try {
FileReader reader = new FileReader（filename）
Scanner in = new Scanner（reader）
String input = in next（）
int value = Integer parseInt（input）
System out println（value）
return true;
} catch （FileNotFoundException e） {
System out println（ this is catch_for_filenot… block! ）
return false;
} finally {
System out println（ this is finally block! ）
}
}
}
故意把filename写错 造出异常 输出为下
this is catch_for_filenot… block!
this is finally block!
this is main return value:false
从这儿看出来 程序先输出catch块中的 后又去执行finally块中的 虽然在catch中已经返回了 最后执行mian方法中的 而且输出false 说明catch块中的也成功返回了 所以 面对疑问 我们可以很肯定的回答 即使有return语句 finally块也一定会被执行！
尽量不要将catch和finally一起使用
像我上面演示程序那样 try/catch/finally一起使用 在《Big Java》一书中提到 不建议这样做 因为会影响程序的可读性 最好的做法是 用try/catch嵌套 catch用来捕获异常 finally用来关闭资源 修改如下
public class FinallyTest {
public static void main（String args） {
boolean file = open（）
System out println（ this is main return value: + file）
}
public static boolean open（） {
String filename = d:\\test txtp ;
try {
try {
FileReader reader = new FileReader（filename）
Scanner in = new Scanner（reader）
String input = in next（）
int value = Integer parseInt（input）
System out println（value）
return true;
} finally {
// 一些关闭资源的操作
System out println（ this is finally block! ）
}
} catch （FileNotFoundException e） {
System out println（ this is catch_for_filenot… block! ）
return false;
}
}
}
自定义异常
毕竟系统自带的异常处理器并不能满足所有需求 因为对于我们开发人员来说 抛出的异常越细致 我们越容易找到问题 总不能所有的问题都抛出Exception吧？太笼统了 在实际的开发中 我们可以根据自己的需要 进行自定义异常处理器
/**
* 自定义异常处理器 继承Exception或者RuntimeException 依情况而定
* @author erqing
*
*/
public class NameNotSupportException extends RuntimeException {
private static final long serialVersionUID = L;
public NameNotSupportException（） {
}
public NameNotSupportException（String message） {
super（message）
}
}
public class DefineTest {
public static void main（String args） {
String name = egg ;
if（！ erqing equals（name））{
throw new NameNotSupportException（ erqing ）
}else{
System out println（ name is OK! ）
}
}
}
Exception in thread main NameNotSupportException: erqing
lishixinzhi/Article/program/Java/hx/201311/25806
error和exception有什么区别
Exception和Error都是继承了Throwable类，在java中只有Throwable类型的实例才可以被抛出（throw）或者捕获（catch），他是异常处理机制的基本组成类型。
Exception和Error体现了java平台设计者对不同异常情况的分类，Exception是程序正常运行中，可以预料的意外情况，可能并且应该被捕获，进行相应的处理。
Error是指正常情况下，不大可能出现的情况，绝大部分的Error都会导致程序（比如JVM自身）处于非正常状态，不可恢复状态。既然是非正常情况，所以不便于也不需要捕获，常见的比如OutOfMemoryError之类，都是Error的子类。
Exception又分为可检查（checked）异常和不检查（unchecked）异常，可检查异常在源码里必须显示的进行捕获处理，这里是编译期检查的一部分。前面我们介绍的不可查的Error，是Throwable不是Exception。
不检查异常就是所谓的运行时异常，类似NullPointerException,ArrayIndexOutOfBoundsExceptin之类，通常是可以编码避免的逻辑错误，具体根据需要来判断是否需要捕获，并不会在编译器强制要求。
error和exception有什么区别
Error（错误）表示系统级的错误和程序不必处理的异常，是java运行环境中的内部错误或者硬件问题。比如：内存资源不足等。对于这种错误，程序基本无能为力，除了退出运行外别无选择，它是由Java虚拟机抛出的。
Exception（违例）表示需要捕捉或者需要程序进行处理的异常，它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题，是程序必须处理的。
Exception又分为运行时异常，受检查异常。
运行时异常，表示无法让程序恢复的异常，导致的原因通常是因为执行了错误的操作，建议终止程序，因此，编译器不检查这些异常。
受检查异常，是表示程序可以处理的异常，也即表示程序可以修复（由程序自己接受异常并且做出处理）， 所以称之为受检查异常。
Java中Exception是什么
Exception是JAVA异常类 是Throwable的子类(Error也是她的子类，Error是比较严重的错误)
异常分为普通异常和运行时异常，运行时异常我们可以不处理，可以让虚拟机来管。
普通异常我们必须捕获(try{}catch(Exception e){}finally{})
java中错误(error)和异常(exception)有什么主要区别
Error类和Exception类的父类都是throwable类，他们的区别是：
Error类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。
Exception类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。
Exception类又分为运行时异常（Runtime Exception）和受检查的异常(Checked Exception )，运行时异常;ArithmaticException,IllegalArgumentException，编译能通过，但是一运行就终止了，程序不会处理运行时异常，出现这类异常，程序会终止。而受检查的异常，要么用try。。。catch捕获，要么用throws字句声明抛出，交给它的父类处理，否则编译不会通过。
常见的异常;
ArrayIndexOutOfBoundsException 数组下标越界异常，
ArithmaticException 算数异常 如除数为零
NullPointerException 空指针异常
IllegalArgumentException 不合法参数异常
err和exception有什么区别
err是错误，exception是异常
错误和异常有区别，错误是指计算机程序运行时出错，异常是指计算机程序运行时忽然不按照指定方式运行了，跑到另一个地方去运行了，之后再回来，比如中断，就说产生了异常。