java 从零开始，学习笔记之基础入门<异常>（十五）

异常

异常: 指的是程序员由于编程错误或者一般性操作导致的问题。异常时可以解决或者避免的。

错误: 是程序员不能通过修改代码解决的，一般性的错误如: 内存溢出，JVM错误等这些就是错误。

异常的分类: 运行时异常和编译异常

异常的例子:

public class ExceptionDemo01 {

publicstatic void main(String[] args) {

inti=12;

intj=0;

intm=i/j;

System.out.println(m);

}

}

运行时出现的异常如下:

Exception in thread "main" java.lang.ArithmeticException: / by zero

at com.ibm.exceptions.ExceptionDemo01.main(ExceptionDemo01.java:7)

此时程序发生异常了，发生的异常给我们的提示是被除数不能为0

String k="%%";

intl=Integer.parseInt(k);

System.out.println(l+1);

Exception in thread "main" java.lang.NumberFormatException: For input string: "%%"

at java.lang.NumberFormatException.forInputString(Unknown Source)

at java.lang.Integer.parseInt(Unknown Source)

at java.lang.Integer.parseInt(Unknown Source)

at com.ibm.exceptions.ExceptionDemo01.main(ExceptionDemo01.java:11)

这个异常时数字格式化异常

常见的一些异常:

v RuntimeException

§ ArithmeticException：数学计算异常

§ NullPointerException：空指针异常

§ NegativeArraySizeException：负数组长度异常

§ ArrayOutOfBoundsException：数组索引越界异常

§ ClassNotFoundException：类文件未找到异常

§ ClassCastException：造型异常

v IOException

§ FileNotFoundException：文件未找到异常

§ EOFException：读写文件尾异常

§ MalformedURLException：URL格式错误异常

§ SocketException：Socket异常

异常的处理机制:

如果一段程序运行的时候,在运行到可能出现异常的代码的时候，会产生一个异常类的对象，由Throw将对象向外抛，对应的由catch块将异常对象捕获到，然后对应的执行catch块里面的内容，如果catch块能够处理该异常，则直接处理，如果不能则程序停止。程序员只能处理异常不能处理错误。

异常处理的常用的语句

Try{

}catch(异常1 对象1){

//如果抛出异常1则执行此catch块里面的内容

}catch(异常2 对象2){

//如果抛出异常2 则执行此catch块里面的内容

}catch (异常3 对象3){

//如果抛出异常3 则执行此catch块里面的内容

}finally{

//不管你抛异常还是不抛异常都要执行的内容

}

使用throws关键字向外抛出异常

package com.ibm.exceptions;

import java.io.EOFException;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

public class ExceptionDemo02 {

publicvoidshow() throws FileNotFoundException,EOFException{

//此行代码有可能报异常。处理方式就有二种

// 1 直接在此处使用try {}catch(){}语句块捕获异常

// 2 使用throws关键字向外抛出异常 throws写在方法名的后面，

//Throws后面跟的是一个或者多个异常类的类名

//throw 和throws的区别？ throw后面跟的是一个异常类的对象 throws跟的是一个或者多个异常类

FileInputStream fis=new FileInputStream("c:\\aa.txt");

}

public static void main(String[] args) {

//调用show方法，就应该处理show方法向外抛出的异常

try {

ExceptionDemo02 ed02=new ExceptionDemo02();

ed02.show();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (EOFException e) {

e.printStackTrace();

}

}

}

v 可以对下列情形在方法定义中抛出异常：

§ 方法中调用了一个会抛出“已检查异常”的方法

§ 程序运行过程中发生了错误，并且用throw子句抛出了一个“已检查异常”

publicvoid show3()throws Exception{

//使用throw子句抛异常

throw new Exception();

}

v 不要抛出如下异常：

§ 从Error中派生的那些异常

AnnotationFormatError,AssertionError, AWTError, CoderMalfunctionError,FactoryConfigurationError,FactoryConfigurationError,IOError, LinkageError, ServiceConfigurationError,ThreadDeath, TransformerFactoryConfigurationError, VirtualMachineError

§ 从RuntimeException中派生的那些异常，如NullPointerException等

v 如果一个异常没有在当前的try-catch模块中得到处理，则它会抛出到它的调用方法。

v 如果一个异常回到了main()方法，仍没有得到处理，则程序会异常终止。

public class ExceptionDemo03 {

publicvoidshow() throws FileNotFoundException

{

FileInputStreamfis=newFileInputStream("C:\\AA.TXT");

}

publicstatic void main(String[] args)throws FileNotFoundException {

new ExceptionDemo03().show();

}

}

捕获和抛出异常结合使用

public class ExceptionDemo03 {

publicvoidshow() throws FileNotFoundException

{

FileInputStream fis=new FileInputStream("C:\\AA.TXT");

}

publicstatic void main(String[] args) {

try {

new ExceptionDemo03().show();

} catch (FileNotFoundException e) {

e.printStackTrace();

}

}

}

方法覆盖中的异常:

package com.ibm.exceptions;

import java.io.IOException;

public class FatherException {

publicvoidshow() throws IOException{

System.out.println("f");

}

}

package com.ibm.exceptions;

import java.io.FileNotFoundException;

import java.io.IOException;

public class SonExceptionextends FatherException {

//在子类中需要将父类中的方法覆盖

//覆盖时，如果父类中的方法抛出异常了，但子类中的同名的方法没有抛出异常

//那么此时子类中的方法没有将父类中的方法覆盖

//那么如果子类中想要覆盖父类中抛出异常的方法，那么子类中同名的方法也需要抛异常

//在子类方法中throws抛出的异常类要么和父类中的相同要么是父类方法抛出的异常类的子类

public void show()throws IOException,FileNotFoundException{

System.out.println("s");

}

public static void main(String[] args) {

FatherException fe=new SonException();

try {

fe.show();

} catch (IOException e) {

e.printStackTrace();

}

}

}

自定义异常: 自己定义一个异常类，每一个自定义的异常类都需要继承某一个异常类，一般情况下继承的是Exception类，但是如果我们创建自定义的异常类，那么我们就需要在自定义的异常类中写和Exception类相同的构造器，并且需要调用父类构造器

package com.ibm.exceptions;

public classMyException extends Exception {

publicMyException(){

//调用父类的无参构造器

super();

}

publicMyException(String message){

super(message);

}

public MyException(String message,Throwable cause){

super(message,cause);

}

public MyException(Throwable cause){

super(cause);

}

}

package com.ibm.exceptions;

public class MyExceptionTest {

public staticvoid main(String[] args) {

try {

throw new MyException("throw MyException!");

} catch (MyException e) {

e.printStackTrace();

}

}

}