/*
*异常:java程序在运行时期发生的不正常情况。
* java就按照面向对象的思想对不正常情况进行描述和对象的封装。
*问题分两种:
*Throwable:定义了对于问题的共性的功能。 java中所有异常的超类
* Error:由系统底层发生,通常出现重大问题,运行的类不存在或者内存溢出。
* 告诉jvm,jvm告诉使用者,不做针对性处理,直接修改代码。
* Exception:jvm发生,告诉使用者,可以进行针对性处理
*/
public class ExceptionDemo1 {
*异常:java程序在运行时期发生的不正常情况。
* java就按照面向对象的思想对不正常情况进行描述和对象的封装。
*问题分两种:
*Throwable:定义了对于问题的共性的功能。 java中所有异常的超类
* Error:由系统底层发生,通常出现重大问题,运行的类不存在或者内存溢出。
* 告诉jvm,jvm告诉使用者,不做针对性处理,直接修改代码。
* Exception:jvm发生,告诉使用者,可以进行针对性处理
*/
public class ExceptionDemo1 {
public static void main(String[] args) {
// int[] arr = new int[1];//ArrayIndexOutOfBoundsException 数组脚标越界异常
int[] arr = new int[1024*1024*100];//OutOfMemoryError 内存溢出
//Memory---内存 heap---堆
System.out.println(arr[1]);
}
// int[] arr = new int[1];//ArrayIndexOutOfBoundsException 数组脚标越界异常
int[] arr = new int[1024*1024*100];//OutOfMemoryError 内存溢出
//Memory---内存 heap---堆
System.out.println(arr[1]);
}
}
* 异常的处理:
* 两种:
* 1.遇到问题不进行具体的处理,而是继续抛给调用者。
* 其实就是在函数上通过throws关键字声明异常。告诉调用者处理。
* 2.针对性的处理方式:捕获!
* try
* {
* //有可能发生异常的代码
* }
* catch(异常类 变量)
* {
* //这是真正的捕获,处理异常的代码。
* }
* finally
* {
* //一定会被执行的代码
* }
* 两种:
* 1.遇到问题不进行具体的处理,而是继续抛给调用者。
* 其实就是在函数上通过throws关键字声明异常。告诉调用者处理。
* 2.针对性的处理方式:捕获!
* try
* {
* //有可能发生异常的代码
* }
* catch(异常类 变量)
* {
* //这是真正的捕获,处理异常的代码。
* }
* finally
* {
* //一定会被执行的代码
* }
在编写功能时,编写者知道该功能有可能发生问题,而这个问题很容易来自于调用者传递的参数。
而导致功能无法运行。这时发生的问题就应该让调用者知道,并最好让调用有预先的处理方式。
所以在定义功能时,需要在功能上对其有可能发生的问题进行声明。
声明问题需要关键字。throws 异常类,声明的目的:就是让调用者可以进行处理
*/
而导致功能无法运行。这时发生的问题就应该让调用者知道,并最好让调用有预先的处理方式。
所以在定义功能时,需要在功能上对其有可能发生的问题进行声明。
声明问题需要关键字。throws 异常类,声明的目的:就是让调用者可以进行处理
*/
* 2.针对性的处理方式:捕获!
* try
* {
* //有可能发生异常的代码
* }
* catch(异常类 变量)
* {
* //这是真正的捕获,处理异常的代码。
* }
* finally
* {
* //一定会被执行的代码
* }
*/
class Demo3{
public int show(int a,int b)throws Exception //该功能可能发生问题,声明异常
{
return a/b;//new ArithmeticExceptin("/ by zero")抛给调用者。
}
}
* try
* {
* //有可能发生异常的代码
* }
* catch(异常类 变量)
* {
* //这是真正的捕获,处理异常的代码。
* }
* finally
* {
* //一定会被执行的代码
* }
*/
class Demo3{
public int show(int a,int b)throws Exception //该功能可能发生问题,声明异常
{
return a/b;//new ArithmeticExceptin("/ by zero")抛给调用者。
}
}
public class ExceptionDemo3 {
public static void main(String[] args) {
Demo3 d = new Demo3();
try //有可能发生异常的代码
{
int num = d.show(5, 0);
System.out.println(num);
}
catch(Exception e) //Exception e = new ArithmeticExceptin("/ by zero");
{
System.out.println("出错了!");
}
System.out.println("over");
}
Demo3 d = new Demo3();
try //有可能发生异常的代码
{
int num = d.show(5, 0);
System.out.println(num);
}
catch(Exception e) //Exception e = new ArithmeticExceptin("/ by zero");
{
System.out.println("出错了!");
}
System.out.println("over");
}
}
/*
throw和throws有什么区别呢?
throw和throws有什么区别呢?
1.位置不同。
throws用在函数上,后面跟的是异常类,可以跟多个。
throw用在函数内,后面跟的是异常对象。
2.功能不同
throws用来声明异常,让调用者只知道该功能有可能出现的问题,并有调用者可以给出预先的处理方式。
throw抛出具体问题对象,执行到throw功能就已经结束了,跳转到调用者,并将具体的问题对象也抛给调用者。
throws用在函数上,后面跟的是异常类,可以跟多个。
throw用在函数内,后面跟的是异常对象。
2.功能不同
throws用来声明异常,让调用者只知道该功能有可能出现的问题,并有调用者可以给出预先的处理方式。
throw抛出具体问题对象,执行到throw功能就已经结束了,跳转到调用者,并将具体的问题对象也抛给调用者。
也就是说throw语句独立存在时,下面不要定义其他语句,因为执行不到。
异常体系最大的特点就是体系中的类以及类产生的对象,都具备可抛性,可抛性的意思是可以被throws和throw所操作。
*/
/*
* 异常的原则
* 1.功能内部有异常throw抛出,功能上一定要有throws声明。
* 内部抛什么,功能上就声明什么。(throws XXX 与 throw XXX 一致)
* 声明的目的就是为了让调用者处理,如果调用者不处理,编译失败。
* 2.特殊情况
* 当函数内通过throw抛出RuntimeException及其子类的异常对象时,函数上可以不用throws声明。
* 不声明的目的就是不让调用者处理,让调用者的程序停止,要对代码进行修改。
*
* 异常的原则
* 1.功能内部有异常throw抛出,功能上一定要有throws声明。
* 内部抛什么,功能上就声明什么。(throws XXX 与 throw XXX 一致)
* 声明的目的就是为了让调用者处理,如果调用者不处理,编译失败。
* 2.特殊情况
* 当函数内通过throw抛出RuntimeException及其子类的异常对象时,函数上可以不用throws声明。
* 不声明的目的就是不让调用者处理,让调用者的程序停止,要对代码进行修改。
*
*小节:
*异常: 其实就将问题封装成对象,并抛给调用者。
* 如果声明了,就需要调用者处理(继续声明or捕获)
* 什么时候声明,什么时候捕获?
* 功能内部可以解决,就捕获,不能解决,或者解决了还必须告诉调用者问题这时就应该声明。
*异常: 其实就将问题封装成对象,并抛给调用者。
* 如果声明了,就需要调用者处理(继续声明or捕获)
* 什么时候声明,什么时候捕获?
* 功能内部可以解决,就捕获,不能解决,或者解决了还必须告诉调用者问题这时就应该声明。
/*
异常的针对性处理方式:
try,catch,fianlly的几种组合方式
1.有资源需要释放,仅仅是处理异常
try
{
}
catch()
{
}
2.一个try多个catch,一般对应的是被调用的函数,抛出多个异常的情况,分别处理。
try
{
}
catch()
{
}
catch()
{
}
catch()
{
}
注意:在多catch语法上特殊的地方,如果catch中的异常类存在子类。
父类的catch一定要放子类的下面,否则编译失败。
3.不一定要处理异常,但是有资源需要释放。
try
{
}
finally
{
}
*/
class Demo9{
int a,b;
int show(int a,int b)throws ArithmeticException
{
if(b==0)
{
throw new ArithmeticException("错了123");//声明的异常和抛出的异常要相同:throws 的和 throw 的异常要相同
}
return a/b;
}
}
public class ExceptionDemo9 {
public static void main(String[] agrs)
{
Demo9 d = new Demo9();
try
{
int num=d.show(4,0);
System.out.println(num);
}
catch(ArithmeticException e) //Exception e = new ArithmeticException("错了123");
//throw new 什么,catch参数里就是什么,当然也可以写它的父类(Exception)
{
System.out.println(e.toString());
System.out.println(e.getMessage());
}
}
}
异常的针对性处理方式:
try,catch,fianlly的几种组合方式
1.有资源需要释放,仅仅是处理异常
try
{
}
catch()
{
}
2.一个try多个catch,一般对应的是被调用的函数,抛出多个异常的情况,分别处理。
try
{
}
catch()
{
}
catch()
{
}
catch()
{
}
注意:在多catch语法上特殊的地方,如果catch中的异常类存在子类。
父类的catch一定要放子类的下面,否则编译失败。
3.不一定要处理异常,但是有资源需要释放。
try
{
}
finally
{
}
*/
class Demo9{
int a,b;
int show(int a,int b)throws ArithmeticException
{
if(b==0)
{
throw new ArithmeticException("错了123");//声明的异常和抛出的异常要相同:throws 的和 throw 的异常要相同
}
return a/b;
}
}
public class ExceptionDemo9 {
public static void main(String[] agrs)
{
Demo9 d = new Demo9();
try
{
int num=d.show(4,0);
System.out.println(num);
}
catch(ArithmeticException e) //Exception e = new ArithmeticException("错了123");
//throw new 什么,catch参数里就是什么,当然也可以写它的父类(Exception)
{
System.out.println(e.toString());
System.out.println(e.getMessage());
}
}
}