Java面向对象 异常
Java面向对象 异常
知识概要:
(1)异常的概述
(2)异常的体系
(3)异常的处理
(4)Runtime异常
(5)自定义异常
(6)异常 - finally
(7)异常总结
1.异常的概述:
异常:就是程序在运行时出现不正常情况。
异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述。并封装成对象。
其实就是java对不正常情况进行描述后的对象体现。
2.异常的体系和结构
对于问题的划分:两种:一种是严重的问题,一种非严重的问题。
对于严重的,java通过Error类进行描述。
对于Error一般不编写针对性的代码对其进行处理。
对与非严重的,java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理。
无论Error或者Exception都具有一些共性内容。
比如:不正常情况的信息,引发原因等。
Throwable
|--Error
|--Exception
Throwable中的方法
getMessage()
• 获取异常信息,返回字符串。
toString()
• 获取异常类名和异常信息,返回字符串。
printStackTrace()
• 获取异常类名和异常信息,以及异常出现在程序中的位置。返回值void。
printStackTrace(PrintStream s)
• 通常用该方法将异常内容保存在日志文件中,以便查阅。
class Demo { int div(int a,int b)throws Exception //在功能上通过throws的关键字声明了该功能有可能会出现问题。 { return a/b; } } class ExceptionDemo { public static void main(String[] args) { Demo d = new Demo(); try { int x = d.div(4,0); System.out.println("x="+x); } catch (Exception e) //Exception e = new ArithmeticException(); { System.out.println("除零啦"); System.out.println(e.getMessage()); // by zero; System.out.println(e.toString()); // 异常名称 : 异常信息。 e.printStackTrace(); //异常名称,异常信息,异常出现的位置。 //其实jvm默认的异常处理机制,就是在调用printStackTrace方法。 //打印异常的堆栈的跟踪信息。 } System.out.println("over"); } }
3,异常的处理
java 提供了特有的语句进行处理。
try
{
需要被检测的代码;
}
catch(异常类 变量)
{
处理异常的代码;(处理方式)
}
finally
{
一定会执行的语句;
}
throws和throw
throws用于标识函数暴露出的异常。
throw用于抛出异常对象。
throws与throw的区别:
• thorws用在函数上,后面跟异常类名。
• throw用在函数内,后面跟异常对象。
在函数上声明异常。
便于提高安全性,让调用出进行处理。不处理编译失败。
对多异常的处理。
1,声明异常时,建议声明更为具体的异常。这样处理的可以更具体。
2,对方声明几个异常,就对应有几个catch块。不要定义多余的catch块。
如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面。
建立在进行catch处理时,catch中一定要定义具体处理方式。
不要简单定义一句 e.printStackTrace(),
也不要简单的就书写一条输出语句。
<span style="font-size:18px;">class Demo { int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//在功能上通过throws的关键字声明了该功能有可能会出现问题。 { int[] arr = new int[a]; System.out.println(arr[4]); return a/b; } } class ExceptionDemo2 { public static void main(String[] args) //throws Exception { Demo d = new Demo(); try { int x = d.div(5,0); System.out.println("x="+x); } catch(Exception e)//出错 { System.out.println("hahah:"+e.toString()); } catch (ArithmeticException e) { System.out.println(e.toString()); System.out.println("被零除了!!"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println(e.toString()); System.out.println("角标越界啦!!"); } /**/ System.out.println("over"); } } </span>
5.自定义异常
自定义异常
需求:在本程序中,对于除数是-1,也视为是错误的是无法进行运算的。
那么就需要对这个问题进行自定义的描述。
当在函数内部出现了throw抛出异常对象,那么就必须要给对应的处理动作。
要么在内部try catch处理 ,要么在函数上声明让调用者处理。
一般情况在,函数内出现异常,函数上需要声明。
发现打印的结果中只有异常的名称,却没有异常的信息。
因为自定义的异常并未定义信息。
如何定义异常信息呢?
因为父类中已经把异常信息的操作都完成了。
所以子类只要在构造时,将异常信息传递给父类通过super语句。
那么就可以直接通过getMessage方法获取自定义的异常信息。
自定义异常:
必须是自定义类继承Exception。
继承Exception原因:
异常体系有一个特点:因为异常类和异常对象都被抛出。
他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
class FuShuException extends Exception //getMessage(); { private int value; FuShuException() { super(); } FuShuException(String msg,int value) { super(msg); this.value = value; } public int getValue() { return value; } } class Demo { int div(int a,int b)throws FuShuException { if(b<0) throw new FuShuException("出现了除数是负数的情况------ / by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。 return a/b; } } class ExceptionDemo3 { public static void main(String[] args) { Demo d = new Demo(); try { int x = d.div(4,-9); System.out.println("x="+x); } catch (FuShuException e) { System.out.println(e.toString()); //System.out.println("除数出现负数了"); System.out.println("错误的负数是:"+e.getValue()); } System.out.println("over"); } } /* class Throwable { private String message; Throwable(String message) { this.message = message; } public String getMessage() { return message; } } class Exception extends Throwable { Exception(String message) { super(message); } } class Person { String name; Person(String name) { this.name = name; } public String getName() { return name; } } class Student extends Person { Student (String name) { super(name); } }
Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常。
如果在函数内容抛出该异常,函数上可以不用声明,编译一样通过。
如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过;
之所以不用在函数声明,是因为不需要让调用者处理。
当该异常发生,希望程序停止。因为运行时,出现无法继续运算的情况,希望停止程序后,对代码进行修正。
自定义异常时:如果该异常的发生,无法在继续进行运算,
就让自定义异常继承RuntimeException。
总结对于异常分两种:
1,编译时被检测的异常。
2,编译时不被检测的异常(运行时异常。RuntimeException以及其子类)
代码实例:
class FuShuException extends RuntimeException { FuShuException(String msg) { super(msg); } } class Demo { int div(int a,int b)throws Exception//throws ArithmeticException { if(b<0) throw new Exception("出现了除数为负数了"); if(b==0) throw new ArithmeticException("被零除啦"); return a/b; } } class ExceptionDemo4 { public static void main(String[] args) { Demo d = new Demo(); int x = d.div(4,-9); System.out.println("x="+x); System.out.println("over"); } } /* class Person { public void checkName(String name) { //if(name.equals("lisi"))//NullPointerException if("lisi".equals(name))//if(name!=null && name.equals("lisi")) System.out.println("YES"); else System.out.println("no"); } } main() { Person p = new Person(); p.checkName(null); }
异常在子父类覆盖中的体现;
1,子类在覆盖父类时,如果父类方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该异常的子类。
2,如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出父类异常的子集。
3,如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常。
如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。