黑马程序员----异常

最新推荐文章于 2022-03-30 15:33:59 发布

原创最新推荐文章于 2022-03-30 15:33:59 发布 · 339 阅读

0 ·

CC 4.0 BY-SA版权

------- android培训、java培训、期待与您交流！ ----------

一、异常

1、什么是异常：

程序在运行过程中，出现的错误，看成一种不正常现象。程序运行中，只有两种结果，正常输出，另一种出现异常。异常也是一个具体事物 OOP思想，万物皆对象，异常也是对象。JAVA中，程序出问题，产生异常，异常进行对象的描述和封装。

常见的异常：

空指针， NullPointerException
越界异常，IndexOutOfBoundsException -String Array
类型转换 , ClassCastException
并发修改异常,ConcurrentModificationException

2、java中的异常继承体系

java.lang.Throwable类是JAVA中所有异常和错误的父类。

Throwable类有2个子类
Error 错误类程序出现了严重问题，不改代码，运行不了。
Exception 异常类程序出现了一般问题，处理掉，继续运行。

Exception类，是JAVA中所有异常的父类子类名字，都是以Exception后缀。
3、Java中的异常分类：

编译异常，不是RuntimeException或者他的子类，都是编译异常。
运行异常，凡是出现的异常是RuntimeException或者他的子类。

编译时期异常：当调用一个抛出异常的方法的时候，调用者必须处理这个异常，如果不处理，编译失败。

运行时期异常：由于程序自身问题导致后面的计算无法执行，抛出运行时期异常，停止程序请修改源代码，设计的初衷。一旦程序发生运行时期异常，必须改源码。项目运行工作期间，运行时期异常，是不能出现的。

4、异常的处理：

1）throw关键字

在方法的内部，用于方法中抛出异常。关键字 throw 后面写异常类的对象 new 。方法使用关键字throw手动抛出一个异常，方法不想处理这个异常，让调用者处理，告诉调用者有异常，请处理。

throws关键字

关键字写在方法的声明上，不是内部。 throws 后面，写的是异常类，不是对象，没有new 。调用方法只有声明出throws调用者就必须处理，可以throws继续抛出。

public static void main(String[] args)
{
try{
show(1);
}catch(Exception e){}
System.out.println("Hello World!");
}
public static void show(int x)throws Exception{
if(x==0){
//手动抛出异常
throw new Exception();
}

}

2）try..catch方法

格式：try
{
需要被检测的代码;
}
catch(异常类变量)
{
处理代码块;
}finally
{
一定会执行的语句;
}

在函数上声明异常，便于提高安全性，让调用者进行处理，不处理编译失败。

public static void main(String[] args)
{
try{
show(0);
}catch(Exception e){
System.out.println("出现异常了");
}finally{

System.out.println("Hello World!");
}
}
public static void show(int x)throws Exception{
if(x == 0)
throw new Exception();
}

5、自定义异常：

因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象，所以对于这些特有的问题可以按照java对问题封装的思想，将特有的问题进行自定义的异常封装。

当函数内部出现了throw抛出异常对象，那么久必须给出对应的处理动作。
要么在内部try catch 处理，要么在函数上声明让调用者处理。
一半情况下函数内出现异常，函数上需要声明。

发现打印的结果中只有异常名称，却没有异常信息。
因为自定义的异常并未定义信息；

如何定义异常信息？
因为父类中已经把异常信息的操作完成了。所以子类只需要在构造时，通过super语句将异常信息提供给父类。那么就可以直接通过getMessage方法获取自定义异常。

自定义异常类必须是自定义类继承Exception

为什么要继承Exception：
异常体系有一个特点，因为异常类和异常对象都需要被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中的独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。

class ScoreException extends Exception
{
//使用构造方法，+ super语句，异常信息送到父类中
ScoreException(String s){
super(s);
}
}
class ExceptionDemo7
{
public static void main(String[] args)
{
try{
method(561);
}catch(ScoreException e){
e.printStackTrace();
}
//System.out.println("Hello World!");
}

public static void method(int score)throws ScoreException{
if(score < 0 || score > 100)
throw new ScoreException("成绩超过范围");
}
}

6、异常在子父类覆盖中的体现

1）子类在覆盖父类时，如果父类的方法跑出异常，那么子类的覆盖方法，只能跑出父类的异常货这异常的子类。早期代码不能处理后期异常。如果子类发生新异常，那么只能在内部处理，不能向外抛出。
2）如果父类方法跑出多个异常，那么子类在覆盖该方法时，只能抛出父类抛出异常的子集。
3）如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。
如果子类方法发生了异常，就必须进行try处理，绝对不能抛。

class AException extends Exception //A异常继承异常
{
}
class BException extends AException//B异常继承A异常
{
}
class Fu{
void show()throws AException{
}
}
class Zi extends Fu{//子类继承父类
void show()throws AException//或者抛出BException
{
}
}
class Test{
void method(Fu f){
try{
f.show()
}
catch (AException e){
}
}
}
class ExceptionDemo {
new Test().method(new Zi());
}