Java异常:Throwable

一、概述

1、Throwable接口

1)Error 类

2)Exception 类

  • 编译期问题:

    • 不是 RuntimeException 的异常
    • 必须进行处理的,因为你不处理,编译就不能通过。
  • 运行期问题:
    • RuntimeException 异常
    • 这种问题我们也不处理,因为是你的问题,而且这个问题出现肯定是我们的代码不够严谨,需要修正代码的。

二、异常的处理: 

(一)异常的处理方式

1、JVM的默认处理:报错。

把异常的名称,原因,位置等信息输出在控制台,程序不能继续执行了。

2、自己处理

1)方式1:

  • try...catch...finally :自己编写处理代码,后面的程序可以继续执行 。
  • spring事务中不可以继续执行,其默认只要是RuntimeException ,都会回滚。

2)方式2:

  • throws :把自己处理不了的,在方法上声明,告诉调用者,这里有问题。

3、面试题:编译期异常和运行期异常的区别?

  • 编译期异常: 必须要处理的,否则编译不通过
  • 运行期异常: 可以不处理,也可以处理

(二)处理详解

1、try...catch...finally 处理(实例)

<span style="font-size:18px;"><span style="font-family:Arial;">	/*
	 * 多个异常
	 * 		b:写一个try,多个catch
	 * 			try{
	 * 				...
	 * 			}catch(异常类名 变量名) {
	 * 				...
	 * 			}
	 * 			catch(异常类名 变量名) {
	 * 				...
	 * 			}
	 * 			...
	 *
	 * 			注意事项:
	 * 				1:能明确的尽量明确,不要用大的来处理。
	 * 				2:平级关系的异常谁前谁后无所谓,如果出现了子父关系,父必须在后面。
	 *
	 * 注意:
	 * 		一旦try里面出了问题,就会在这里把问题给抛出去,然后和catch里面的问题进行匹配,
	 * 		一旦有匹配的,就执行catch里面的处理,然后结束了try...catch
	 * 		继续执行后面的语句。
	 */
	public void test3(){

		int a = 10;
		int b = 0;
		int[] arr = { 1, 2, 3 };

		// 爷爷一定要在最后
		try {
			System.out.println(a / b);
			System.out.println(arr[3]);
			System.out.println("这里出现了一个异常,你不太清楚是谁,该怎么办呢?");
		} catch (ArithmeticException e) {//兄弟,有异常就不会去另外的catch 了
			System.out.println("除数不能为0");
		} catch (ArrayIndexOutOfBoundsException e) {//兄弟
			System.out.println("你访问了不该的访问的索引");
		} catch (Exception e) {//爷爷一定要在后面
			System.out.println("出问题了");
		}

		System.out.println("over");//继续执行
	}
</span></span>

2、JDK7的新的异常

1)格式:try{   }catch(异常名1 | 异常名2 | ... 变量 ) {  }

2)注意

  • 处理方式是一致的。(实际开发中,好多时候可能就是针对同类型的问题,给出同一个处理)
  • 多个异常间必须是平级关系,父类异常没有办法处理。

3、异常常用方法

1)public String getMessage():异常的消息字符串

2)public String toString():返回异常的简单信息描述

  • 此对象的类的 name(全路径名) ": "(冒号和一个空格)
  • 调用此对象 getLocalizedMessage()方法的结果 (默认返回的是getMessage()的内容)

3)printStackTrace(): 获取异常类名和异常信息,以及异常出现在程序中的位置。返回值void。把信息输出在控制台。

4、throws 抛出(在方法的定义上)

1)格式: throws 异常类名,可以一次抛出多个

  • 这个格式必须跟在方法的括号后面。
  • public void test7() throws ArithmeticException {}

2)注意:

  • 调用该方法的方法,需要处理该异常,如不处理,继续抛出。

3)小结:

  • 编译期异常抛出,将来调用者必须处理。
  • 运行期异常抛出,将来调用可以不用处理。

5、throw(在方法体内)

1)格式:throw 异常对象

  • 如果出现了异常情况,我们可以把该异常抛出,这个时候的抛出的应该是异常的对象。
  • throw new ArithmeticException();
  • 一般用于自定义的异常使用

2)面试题:throw和throws是的区别

  • throw:

    • 在方法体中,后面跟的是异常对象名,并且只能是一个。
    • 抛出的是一个异常对象,说明这里肯定有一个异常产生了。
  • throws:
    • 在方法声明上,后面跟的是异常的类名,可以是多个。
    • 是声明方法有异常,是一种可能性,这个异常并不一定会产生。

(三)finally关键字及其面试题

1、finally用于释放资源,它的代码永远会执行。特殊情况:在执行到finally之前jvm退出了

2、面试题

  • final,finally,finalize的区别?

    • final:最终的意思,可以修饰类,成员变量,成员方法

      • 修饰类,类不能被继承
      • 修饰变量,变量是常量
      • 修饰方法,方法不能被重写
    • finally:是异常处理的一部分,用于释放资源。
      • 一般来说,代码肯定会执行,特殊情况:在执行到finally之前jvm退出了
    • finalize:是Object类的一个方法,用于垃圾回收。
  • 如果在catch里面有return,请问finally还执行吗?如果执行,在return前还是后

    • 会执行,在 return 前面执行。
    • 注意:返回路径就形成问题。*
<span style="font-size:18px;"><span style="font-family:Arial;">	/*
	 * 面试题:
	 * 1:final,finally和finalize的区别
	 * final:最终的意思,可以修饰类,成员变量,成员方法
	 * 		修饰类,类不能被继承
	 * 		修饰变量,变量是常量
	 * 		修饰方法,方法不能被重写
	 * finally:是异常处理的一部分,用于释放资源。
	 * 		一般来说,代码肯定会执行,特殊情况:在执行到finally之前jvm退出了
	 * finalize:是Object类的一个方法,用于垃圾回收
	 *
	 * 2:如果catch里面有return语句,请问finally里面的代码还会执行吗?
	 *   如果会,请问是在return前,还是return后。
	 * 	   会。前。
	 *
	 * 	 准确的说,应该是在中间。
	 *
	 * 3:try...catch...finally的格式变形
	 * 		A:try...catch...finally
	 * 		B:try...catch
	 * 		C:try...catch...catch...
	 * 		D:try...catch...catch...finally
	 * 		E:try...finally
	 * 			这种做法的目前是为了释放资源。
	 */
	public int test10(){
		int a = 10;
		try {
			System.out.println(a / 0);
			a = 20;
		} catch (ArithmeticException e) {
			a = 30;
			return a;
			/*
			 * return a在程序执行到这一步的时候,这里不是return a而是return 30;这个返回路径就形成了。
			 * 但是呢,它发现后面还有finally,所以继续执行finally的内容,a=40
			 * 再次回到以前的返回路径,继续走return 30;
			 */
		} finally {
			a = 40;
			return a;//如果这样结果就是40了。
		}
//		 return a;
	}
</span></span>

(四)自定义异常:

1)继承自Exception或者RuntimeException,只需要提供无参构造和一个带参构造即可。

2)实例:

6、异常的注意实现

1)父的方法有异常抛出,子的重写方法在抛出异常的时候必须要小于等于父的异常

2)父的方法没有异常抛出,子的重写方法不能有异常抛出

3)父的方法抛出多个异常,子的重写方法必须比父少或者小

<span style="font-size:18px;"><span style="font-family:Arial;">/*
 * java不可能对所有的情况都考虑到,所以,在实际的开发中,我们可能需要自己定义异常。
 * 而我们自己随意的写一个类,是不能作为异常类来看的,要想你的类是一个异常类,就必须继承自Exception或者RuntimeException
 * 只需要提供无参构造和一个带参构造即可。
 *
 * 两种方式:
 * A:继承Exception,在throw的时候,需要处理
 * B:继承RuntimeException,运行期异常,在throw的时候,需要处理
 */
//public class MyException extends Exception {
	public class MyException extends RuntimeException {

	//只需要提供无参构造和一个带参构造即可。
	public MyException() {
	}

	public MyException(String message) {
		super(message);
	}
}</span></span>

三、Spring事务

(一)事务

1、传播行为:propagation=Propagation.REQUIRED

2、隔离机制:isolation=Isolation.DEFAULT

1)只读属性 :readOnly

2)回滚机制:

  • rollbackFor
  • noRollbackFor

(二)面试

1、回滚机制。

1)try catch..无效,因为spring 的回滚机制为只要是运行期异常就会滚。

2)解决:只要修改其回滚机制即可。

2)这个面试题,经常被问到(苏州)。我被面到的公司有:苏州中集、苏州科达(监控)、盟拓等。

时间: 2024-10-17 21:18:19

Java异常:Throwable的相关文章

java.lang.Throwable 异常/深入

有几个现象是需要总结的: -------------------------------------- 在java语言中,错误类的基类是java.lang.Error,异常类的基类是java.lang.Exception. 相同点:java.lang.Error和java.lang.Exception都是java.lang.Throwable的子类,因此java.lang.Error和java.lang.Exception自身及其子类都可以作为throw的使用对象,如:throw new MyE

java 异常的捕获及处理

在没有异常处理的程序中如果要回避异常,需要使用大量的判断语句,配合所想到的错误状况来捕捉程序中可能发生的错误.但是这样势必会导致程序运行效率降低.java异常处理机制具有易于使用,可自定义异常类,处理抛出的异常的同时,又不会降低程序运行效率等优点.因而在java程序设计时,应充分的利用异常处理机会,以增进程序的稳定性及效率.1.异常处理示例及基本格式: package javaBasics; public class test5 { public static void main(String[

java异常面试常见题目

在Java核心知识的面试中,你总能碰到关于 处理Exception和Error的面试题.Exception处理是Java应用开发中一个非常重要的方面,也是编写强健而稳定的Java程序的关键,这自然使它成为面试题中的常客.关于Java中Error和Exception的面试题目多是关于Exception和Error的概念,如何处理Exception,以及 处理Exception时需要遵守的最佳实践等等.尽管关于多线程.垃圾回收.JVM概念和面向对象设计等方面的问题依然主宰着这类面试,你仍然需要为回答

Java 异常面试题

1.final, finally, finalize的区别. final 用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承. 内部类要访问局部变量,局部变量必须定义成final类型,例如,一段代码-- finally是异常处理语句结构的一部分,表示总是执行. finalize是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖此方法提供垃圾收集时的其他资源回收,例如关闭文件等.JVM不保证此方法总被调用. 2.error和exception有什

Java异常打印输出中常见方法的分析

Java异常是在Java应用中的警报器,在出现异常的情况下,可以帮助我们程序猿们快速定位问题的类型以及位置.但是一般在我们的项目中,由于经验阅历等多方面的原因,依然有若干的童鞋在代码中没有正确的使用异常打印方法,导致在项目的后台日志中,没有收到日志或者日志信息不完整等情况的发生,这些都给项目埋下了若干隐患.本文将深入分析在异常日志打印过程中的若干情况,并给出若干的使用建议. 1. Java异常Exception的结构分析 我们通常所说的Exception主要是继承于Throwable而来,可以参

Java异常总结

http://blog.csdn.net/hguisu/article/details/6155636 [-] 1 引子 2JAVA异常 4处理异常机制 1 捕获异常trycatch 和 finally try-catch语句 trycatch-finally语句 try-catch-finally 规则异常处理语句的语法规则 trycatchfinally语句块的执行顺序 2 抛出异常 throws抛出异常 使用throw抛出异常 4 Throwable类中的常用方法 5Java常见异常 ru

Java异常分类

Throwable是所有异常的根,java.lang.ThrowableError是错误,java.lang.ErrorException是异常,java.lang.Exception 一.Error Error是throwable的子类,代表编译时间和系统错误,用于指示合理的应用程序不应该试图捕获的严重问题,包括堆内存溢出,栈内存溢出 二.Exception 1.可检查异常CheckedException IOException.ClassNotFoundexception.NoSuchMet

Java异常初步

所谓异常就是程序在运行时出现的不正常情况; 1.异常的体系: Throwable: 1) Error:通常指JVM出现重大问题如:运行的类不存在或者内存溢出等,这种异常是程序员无法处理的 2) Exception:在运行时运行出现的一些情况,可以通过try,catch,finally处理.比如在计算除法时把除数置0,参数传值是类型不符等. Java异常其实是对不正常情况的一种描述,并将其封装成对象 Java在 设计异常体系时,将容易出现的异常情况都封装成了对象 下面的代码在运行时会将除数置0,在

Java 异常分类

1.java异常层次结构: 粉红色的是已检查异常(checked exceptions),其必须被 try{}catch语句块所捕获,或者在方法签名里通过throws子句声明.已检查异常必须在编译时被捕捉处理,命名为 CHecked Exception 是因为Java编译器要进行检查,Java虚拟机也要进行检查,以确保这个规则得到遵守. 绿色的是未检查异常(unchecked exceptions),需要程序员自己分析代码决定是否捕获和处理,比如 空指针,被0除... 声明为Error的,属于严

黑马程序员-Java异常详解

--Java培训.Android培训.iOS培训..Net培训.期待与您交流! --- 异常的介绍 Java中的异常就是那些会阻碍当前程序运行,使程序执行可能失败的一些可能情况,如程序中出现除零错误,数组下标越界等.异常在Java中被封装成了一个类,继承自Throwable,名为Exception,它有很多子类,分别描述了系统中很多常见的异常情况,这些异常机制的出现使得编写程序时对一些问题的处理变得尤为方便,下面是一些简单的使用情况. 异常捕获的一般格式 /** * javac Exceptio