异常

本帖最后由霍振鹏于 2014-4-20 09:33 编辑

谁有看毕老师视频时，总结的笔记，关于异常那部分，包括自定义异常，给我个链接，我参考学习一下，这里先谢过大家！

曹冬明 · 曹冬明

异常：
是什么？是对问题的描述。将问题进行对象的封装。
------------
异常体系：
Throwable
|--Error
|--Exception
|--RuntimeException
异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。
也就是说可以被throw和throws关键字所操作。
只有异常体系具备这个特点。
--------------
throw和throws的用法：
throw定义在函数内，用于抛出异常对象。
throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。
当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。
注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。
--------------
如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try。
异常有两种：
编译时被检测异常
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
该异常被标识，代表这可以被处理。
运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。
该异常的发生，建议不处理，让程序停止。需要对代码进行修正。
--------------
异常处理语句：
try
{
需要被检测的代码；
}
catch ()
{
处理异常的代码；
}
finally
{
一定会执行的代码；
}
有三个结合格式：
1. try
{
}
catch ()
{
}
2. try
{
}
finally
{
}
3. try
{
}
catch ()
{
}
finally
{
}
注意：
1，finally中定义的通常是关闭资源代码。因为资源必须释放。
2，finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。
--------------
自定义异常：
定义类继承Exception或者RuntimeException
1,为了让该自定义类具备可抛性。
2，让该类具备操作异常的共性方法。
当要定义自定义异常的信息时，可以使用父类已经定义好的功能。
异常异常信息传递给父类的构造函数。
class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}
自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装。
--------------
异常的好处：
1，将问题进行封装。
2，将正常流程代码和问题处理代码相分离，方便于阅读。
异常的处理原则：
1，处理方式有两种：try 或者 throws。
2，调用到抛出异常的功能时，抛出几个，就处理几个。
一个try对应多个catch。
3，多个catch，父类的catch放到最下面。
4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。
也不要不写。
当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
try
{
throw new AException();
}
catch (AException e)
{
throw e;
}
如果该异常处理不了，但并不属于该功能出现的异常。
可以将异常转换后，在抛出和该功能相关的异常。
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，
当调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。
try
{
throw new AException();
}
catch (AException e)
{
// 对AException处理。
throw new BException();
}
比如，汇款的例子。
异常的注意事项：
在子父类覆盖时：
1，子类抛出的异常必须是父类的异常的子类或者子集。
2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。
参阅
ExceptionTest.java 老师用电脑上课
ExceptionTest1.java 图形面积。
class
{
public static void main(String[] args)
{
int x = 0;
try
{
x = 4;
}
catch ()
{
}
finally
{
System.out.println("x="+x);
}
}
}

复制代码

这是毕老师视频的随堂笔记

也许依然 · 也许依然

异常：就是程序在运行时出现不正常情况
1，异常由来：问题也是现实生活中的具体事物，也可以通过java的类的形式进行描述。并封装成对象
其实就是java对不正常情况进行描述后的对象体现

对于问题的划分：两种：一种是严重的问题，一种是非严重的问题

对于严重的，java通过Error类进行描述
对于Error一般不编写针对性的代码对其进行处理

对于非严重的，java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理

无论Error或者Exception都有一些共性内容
比如：不正常的信息，引发原因等

Thowable
|--Error
|--Exception

2，异常的处理：

java提供了特有的语句进行处理

try
{
需要被检测的代码；
}

catch(异常类变量)
{
处理异常的代码；
}

finally
{
一定会执行的语句；
}

3，对捕获到的异常进行常见方法操作
String getMessage(); 获取异常的信息

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

对多异常的处理
1，声明异常时，建议声明更具体的异常。这样处理可以更具体
2，对方声明几个异常，就对应几个catch块。不要定义多余的catch块
如果多个catch中的异常出现继承关系，父类异常catch块放在最下边

建议在进行catch处理时，catch中一定要具体的处理方式
不要简单的定义一句 e.printStackTrace();
也不要简单的就写一条输出语句
代码演示：

class Demo
{
int div ( int a ,int b) throws ArithmeticException , ArrayIndexOutOfBoundsException
//在功能上通过static关键字声明了该功能有可能出现问题
{
int arr [] = new int [a];
System.out.println(arr[4]);
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(ArithmeticException e) //Exception e = new ArithmeticException();
{
System.out.println("除零");
System.out.println(e.getMessage());
System.out.println(e.toString());
e.printStackTrace();
//其实jvm默认的异常处理机制，就是在调用printStackTrace方法。打印异常在堆栈的跟踪信息
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println(e.getMessags());
System.out.println("下标越界");
}
System.out.println("over");
}
}

复制代码

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

自定义异常

需求：在本程序中除数为负数，也视为错误，无法进行运算
那么就需要对这个问题进行自定义的描述

当在函数内部出现throw抛出异常对象，那么就必须要给对应的处理动作
要么在内部try catch 处理
要么在函数上声明让调用者处理

一般情况下，函数类出现异常，函数上需要声明

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

如何定义异常信息呢？

因为父类已经把异常信息的操作都完成了
所以子类只要在构造时，将异常信息传递给父类通过super语句
就可以通过getMessage方法获取自定义的异常信息

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

继承Exception的原因：
异常体系有一个特点：因为异常类和异常对象都需要被抛出
他们都具备科抛性。这个可抛性是Throwable体系中独有的特点

只有这个体系中类和对象才可以被throws和throw多操作

throw和throws的区别
throws使用在函数上
throw使用在函数内

throws后跟异常类；可跟多个；用逗号隔开
throw后跟的是异常对象

代码演示：

class FuShuException extends Exception
{
private String msg;
FuShuException( String msg)
{
this.msg=msg;
}
public String getMessage()
{
return msg;
}
}
class Demo
{
int div( int a , int b ) throws FuShuException
{
if (b<0)
throw new FuShuException("出现了除数是负数的情况");
return a/b;
}
}
class ExceptionDemo2
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div( 4,-1);
System.out.println("x= "+x);
}
catch( FuShuException e)
{
System.out.println( e.toString());
System.out.println("除数为负数了");
}
System.out.println("over ");
}
}

复制代码

Exception中有一个特殊的子类异常，RuntimeException
如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过
如果在函数上声明了该异常；调用者可以不用进行处理

之所以不用在函数上声明，是因为不需要调用者处理
当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况
希望停止程序后，对代码进行修正

自定义异常时：如果该异常的发生，无法再继续进行运算
就让自定义异常类继承RuntimeException

对于异常分两种：
1，编译时被检测的异常
2，编译时不被检测的异常（运行时异常。RuntimeException及其子类

姜姗姗 · 姜姗姗

一. 异常定义:
异常是程序运行时发生的意外或错误，导致程序运行失败，称为异常。
异常也是现实生活中、程序开发或使用中一个真实的存在的事物，Java也用类的方式进行了描述，并用对象的方法进行了封装体现。
二. 异常处理机制
当程序发生错误时，程序如何处理错误，具体来说，当程序发生错误后，异常处理机制将调整程序的执行流程，程序的控制权转移到异常处理器，异常处理机制将会按照给定的处理方式让程序安全退出，并将错误信息返回给用户或程序的维护员，加以分析维护。
三. 异常体系:
异常和异常之间都存在一些共性，从而进行向上抽取，Java就存在一个Throwable这么一个类，Throwable是所有异常类的超类，继承该类的任何类或对象都具备可抛性。
Throwable
|---Error
…(其他子类)
|---Exception
…(其他子类)
|---RuntimeException
…(其他子类)
Error:Error体系描述了Java运行系统中的内部错误，内存不足，资源耗尽等异常，程序或程序员是无能去阻止或处理异常的发生，所以这种异常，在程序设计时候，一定不给于任何代码做处理或声明，RuntimeException与Error可以在任何代码中产生，它们不需要由程序员显示的抛出，一旦出现错误，那么相应的异常会被自动抛出，程序员一般是无能为力去处理的，Java虚拟机出做响应的处理。
RuntimeException:这个体系包括错误类型的转换、数组下标越界，引用类型的空指针异常等等，如果出现RuntimeException，那么一定是程序员的错误。例如，可以通过检查数组下标和数组边界来避免数组越界访问异常，这种异常在设计时，不用给与声明和处理，应该立即结束程序，告诉程序开发维护人员，进行程序的修正。
四. throws和throw的区别:
使用位置:
àthrows使用在函数上
[java] view plaincopy
public void show()throwsNoSuchFieldException
{
……….
}
àthrow使用在函数内部
[java] view plaincopy
public void show()
{
throw newNoSuchFieldException(“没有找到指定的属性”);
}
使用方法:
àthrows用来抛出异常类，抛出多个用逗号隔开
[java] view plaincopy
public void show()throwsNoSuchFieldException, NoSuchMethodException
{
……….
}
àthrow用来抛出异常对象，只能抛出一个异常对象
[java] view plaincopy
public void show()
{
throw newNoSuchFieldException(“没有找到指定的属性”);
}
五. 异常的分类:
1. 将异常按照问题发生的严重性划分:
严重异常: Errorà无法处理，无法补救，也无需捕获，只能交给JVM处理，如果JVM都无法处理，那么只能让程序停止，一般JVM的处理方式的停止程序运行，现实错误信息，及堆栈信息追踪。
可处理异常: Exceptionà可以或有可能进行处理的异常，对于这种异常需要对其进行捕获try{}和处理catch(Exception e){}或者说也可以不处理，可以不处理的主要针对RuntimeException。
2. 可处理异常又可以分为编译时异常和运行时异常
编译时异常(CheckedException):
编译时异常，就是在程序编译时，如果未对throw抛出的异常进行声明(throws)或者未异常语句块进行try{}和catch(Exception e){}处理的话，编译将无法通过，提示必须进行处理或者异常声明，该异常被表示，代表该异常可以被处理。
运行时异常(UncheckException):
运行时异常，就是发生的异常或错误，不用进行处理或声明，在编译的时候编译器不会去做是否有被声明或处理的动作，该异常的发生，建议不需要处理，停止程序运行，提示修正代码。
六. 异常的处理
方式1:
[java] view plaincopy
try
{
//这里定义可能发生异常的代码;(异常捕获检测)
}
catch (Exception e)
{
//这里定义异常处理语句;
}
finally
{
//这里定义的是无论如何都会执行到的语句;
}
方式2:
[java] view plaincopy
try
{
//这里定义可能发生异常的代码;(异常捕获检测)
}
catch (Exception e)
{
//这里定义异常处理语句;
}
方式3:
[java] view plaincopy
try
{
//这里定义可能发生异常的代码;(异常捕获检测)
}
finally
{
//这里定义的是无论如何都会执行到的语句;
}
注意: finally语句块中书写代码的都是一定会被执行的，一般会定义用来关闭资源，如关闭数据库连接，流资源关闭等，用来释放代码，但是当在try或catch语句中出现System.exit(0);退出语句时，finally语句块中的代买将不会被执行。
七. 自定义异常
1. 定义:自定义异常就是Java定义自身定义的异常之外的特有异常，是程序开发人员未符合程序开发需求和逻辑设计需求，定义的一种特有异常，继承自Exception类或RuntimeException子类。
2. 如何定义一个自定义异常
A. 一个类如果要称为一个一场类，那么该类一定要具备异常的共性特点，和Java异常类存在所属关系，必须继承Exception类或RuntimeException子类，让其具备可抛性，具备异常异常操作的共性方法，可以使用父类已经具备的功能。
[java] view plaincopy
class MyExceptionextends Exception
{
MyException(String message)
{
super(message);
}
}
八. 异常处理的原则
1. 多个异常声明存在，必须需要多个对应的catch语句进行处理(一个try对应多个catch)。
2. 一个try对应多个catch语句块的时候，更父类的catch语句块要放在下面，否则，子类的语句块将永远无法执行到，编译将不会通过。
3. catch语句块中的异常处理方法，尽可能的有意义，尽可能的有针对性，不能简单的使用printStackTrace();等异常输出语句，更不能不书写任何语句。
4. 当某个异常捕获到之后，无法处理时，可以继续在catch语句中抛出，
[java] view plaincopy
try
{
thrownew MyException("异常");
}
catch(MyException e)
{
throw e;
}
如果该异常处理不了，但并不属于该功能应该出现的异常，可以先将异常转换后，再抛出和该功能相关的异常;或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，当调用者知道并处理，也可以将捕获异常处理后，转为新的异常。
[java] view plaincopy
try
{
thrownew AException("A");
}
catch(AException e)
{
//先对AException进行处理
thrownew BException("B");
}
5. throw后面不能跟其他任何语句
[java] view plaincopy
try
{
thrownew AException("A");
//System.out.println("异常抛出了");
//上面这行输出语句是永远也执行不到的，
//因为throw new AException("A");抛出一个异常之后程序就跳转了
//所以就永远无法被执行，编译无法通过。
}
九. 在子父类覆盖时需要注意的事项
1. 子类抛出的异常必须是父类的异常的子类或者子集。
2. 如果父类或接口没有异常抛出时，子类在覆盖的时候，只能try{}、catch(Exception e){};进行捕获处理，或者编译不通过。
十. 关于throw语句后的语句永远无法执行到的问题
1.
[java] view plaincopy
try
{
throw new AException(“XXX错误”);
System.out.println(“这句话永远都执行不到….”);
}
这种写法是错误的，因为异常使用throw抛出后，程序就进行了跳转，进入了catch语句块，或者进入finally语句块，所以throw后面的代码是永远都无法执行到的，编译失败，建议这个地方不要书写代码。
2.
[java] view plaincopy
class Demo
{
public static void main(String[] args)
{
try
{
//这里调用showExce()后抛出异常，这个中方式是将异常封装在了方法里面，//但是对于程序来判定，这个方法是有可能会发生异常，下面的语句还有可//能被执行到，所以编译通过
showExce();
System.out.println("A");
}
catch(Exception e)
{
System.out.println("B");
}
finally
{
System.out.println("C");
}
System.out.println("D");
}
//showExce()方法抛出并声明了异常
public static void showExce()throws Exception
{
throw new Exception();
}
}

复制代码

帐号		自动登录	找回密码
密码			加入黑马

异常

3 个回复

评分

评分

评分