「Java」九、异常处理

目录显示

异常概述与异常体系结构

异常概述

在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。

异常：在Java语言中，将程序执行中发生的不正常情况称为“异常” 。 (开发过程中的语法错误和逻辑错误不是异常)

Java程序在执行过程中所发生的异常事件可分为两类：

①Error（错误）：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError和OOM。一般不编写针对性的代码进行处理。

 public class ErrorTest{
    public static void main(String[] args){
        //1.栈溢出：java.lang.StackOverflowError
        main(args);
        //2.堆溢出：java.lang.OutOfMemoryError
        Integer[] arr=new Integer[1024*1024*1024];
    }
}

②Exception（狭义的异常）：其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：空指针访问，试图读取不存在的文件，网络连接中断，数组角标越界

对于这些错误，一般有两种解决方法：一是遇到错误就终止程序的运行。另一种方法是由程序员在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理。

捕获错误最理想的是在编译期间，但有的错误只有在运行时才会发生。比如：除数为0，数组下标越界等 ->分类：编译时异常和运行时异常

异常体系结构

编译时异常：执行javac.exe命令时，可能出现的异常

运行时异常：执行java.exe命令时，可能出现的异常

红色：受检(checked)异常

蓝色：非受检(unchecked)异常

1.运行时异常：是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常。
对于这类异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响。
2.编译时异常：是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。
对于这类异常，如果程序不处理，可能会带来意想不到的结果。

 java.lang.Throwable
        |-----java.lang.Error：一般不便携针对性的代码进行处理
        |-----java.lang.Exception：可以进行异常处理
                     |-----编译时异常（checked）
                                  |-----IOException
                                               |-----FileNotFoundException
                                  |-----CLassNotFoundException
                     |-----运行时异常（unchecked）
                                  |-----NullPointerException
                                  |-----ArrayIndexOutOfBoundsException
                                  |-----ClassCastException
                                  |-----NumberFormatException
                                  |-----InputMismatchException
                                  |-----ArithmeticException

常见异常

运行时异常：

NullPointerException

 public class NullRef {
    int i = 1;
    public static void main(String[] args) {
        NullRef t = new NullRef();
        t = null;
        System.out.println(t.i);
    }
}

ArrayIndexOutOfBoundsException

 public class EceptionTest{
    @Test
    public void test2(){
        int[] arr=new int[10];
        System.out.println(arr[10]);
    }
}

StringIndexOutOfBoundsException

 public class EceptionTest{
    @Test
    public void test2(){
        String str="abc";
        System.out.println(str.charAt(3));
    }
}

ClassCastException

 public class EceptionTest{
    @Test
    public void test3(){
        Object obj=new Date();
        String str=(String)obj;
    }
}

NumberFormatException

 public class EceptionTest{
    @Test
    public void test4(){
        String str="123";
        str="abc";
        int num=Integer.parseInt(str);
    }
}

InputMismatchException

 public class EceptionTest{
    @Test
    public void test5(){
        Scanner scanner=new Scanner(System.in);
        int score=scanner.nextInt();
        System.out.println(score);
    }
}

ArithmeticException

 public class EceptionTest{
    @Test
    public void test6(){
        int a=10;
        int b=0;
        System.out.println(a/b);
    }
}

编译时异常FileNotFoundException,IOException e

 public class EceptionTest{
    @Test
    public void test7(){
        File file=new File("hello.txt");
        fis=new FileInputStream(file);
 
        int data=fis.read();
        while(data!=-1){
            System.out.print((char)data);
            data=fis.read();
        }
 
        fis.close();
    }
}

异常处理机制一： try-catch-finally

一、异常的处理：抓抛模型

过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。并将此对象抛出。一旦抛出对象后，其后的代码就不再执行。

关于异常对象的产生：①系统自动生成的异常对象，②手动的生成一个异常对象，并抛出（throw）

过程二：“抓”：可以理解为异常的处理方式：①try-catch-finnally，②throws

二、try-catch-finally的使用

格式：

 try{
    //课程出现异常的代码
}catch(异常类型1 变量名1){
    //处理异常的方式1
}catch(异常类型2 变量名2){
    //处理异常的方式2
}catch(异常类型3 变量名3){
    //处理异常的方式3
}finally{
    //一定会执行的代码
}

两种常用的报错方式：

 try{
 
}catch(Exception e){
    System.out.println(e.getMessage());
    e.printStackTrace();
}

体会1：使用try-catch-finally处理编译时异常，使得程序在编译时就不再报错，但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。

体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally，针对编译时异常，我们一定要考虑异常处理。

RuntimeException类或是它的子类，即使没有使用try和catch捕获，Java自己也能捕获，并且编译通过。非运行时异常，则必须捕获，否则编译错误。也就是说，我们必须处理编译时异常，将异常进行捕捉，转化为运行时异常。

说明：

finally是可选的
finally中声明的是一定会被执行的代码。即使“catch中又出现异常了，try中又return语句，catch中又return”等情况。即，finally=="等等！我先执行"
一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（在没有写finally的情况），继续执行其后的代码
catch中的异常类型如果没有子父类关系，则声明无论先后；否则要求子类一定声明在父类上面，不然会报错
常用的异常对象处理的方式：①String getMessage()，②printStackTrace()
在try结构中声明的变量，出了try结构以后，就不能再被调用
try-catch-finally结构可以嵌套

可以用选中代码快->右键->Surround With->Try/catch Block，自动生成。

finally的再说明：

finally是可选的
finally中声明的是一定会被执行的代码
像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动回收的，我们需要自己手动的进行资源的释放。此时的资源释放，就需要声明在finally中

 public void test2(){
    FileInputStream fis=null;
    try{
        File file=new File("hello.txt");
        fis=new FileInputStream(file);
 
        int data=fis.read();
        while(data!=-1){
            System.out.print((char)data);
            data=fis.read();
        }
    }catch(FileNotFoundException e){
        e.printStackTrace();
    }catch(IOException e){
        e.printStackTrace();
    }finally{
        try{
            if(fis!=null)
                fis.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

hello.txt在当前的工程下。在工程下创建文件（先别写中文，因为字节流读不了字符）

异常处理机制二： throws

“throws + 异常类型“写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。
一旦当方法被执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码，就不再执行。
对比两种处理方式：try-catch-finally：真正的把异常处理掉了。throws的方式只是将异常抛给了方法的调用者，并没有真正的将异常处理掉。
ps.子父类抛出的异常大小关系：子类重写的方法抛出的异常类型不大于父类
开发中如何选择使用try-catch-finally和throws？
3.1 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理
3.2 执行的方法a中，先后调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理

手动抛出异常

Java异常类对象，除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要使用人工创建并抛出。（throw）

throw和throws区别：

throw表示抛出一个异常类的对象，生成异常对象的过程。声明在方法体内。

throws属于异常处理的一种方式，声明在方法的声明处。

 public class StudentTest{
    public static void main(String[] args){
        try{
            Student s=new Student();
            s.regist(-1001);
            System.out.println(s);
        }catch(Exception e){
            System.out.prinln(e.getMessage());
        }
    }
}
class Student{
    private int id;
    public void regist(int id) throws Exception{
        if(id>0){
            this.id=id;
        }else{
            throw new Exception("您输入的数据非法")；
        }
    }
}

用户自定义异常类

如何自定义异常类？

继承于现有的异常结构：RunTimeExcption、Exception
提供全局常量：serialVersionUID
提供重载的构造器

 public class MyException extends RuntimeException{
 
    static final long serialVersionUID = -9271957429329742L;
 
    public MyException(){
 
    }
 
    public MyException(String message){
        super(message);
    }
}
 
class Student{
    private int id;
    public void regist(int id) throws Exception{
        if(id>0){
            this.id=id;
        }else{
            throw new MyException("您输入的数据非法")；//抛出自定义的异常类型
        }
    }
}

练习：

 public class EcmDef{
    public sataic void main(String[] args){
        try{
            int i=Integer.parseInt(args[0]);
            int j=Integer.parseInt(args[1]);
 
            int result=ecm(i,j);
 
            System.out.prinln(result);
        }catch(NumberFormatException e){
            System.out.prinln("数据类型不一致")；
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.prinln("缺少命令行参数")；
        }catch(ArithmeticException e){
            System.out.prinln("除0");
        }catch(EcDef e){
            System.out.prinln(e.getMessage());
        }
    }
    public static int ecm(int i,int j) throws EcDef{
        if(i<0||j<0){
            throw new EcDef("分子或分母为负数了")；
        }
        return(i/j);
    }
}

 //自定义异常类
public class EcDef extends Exception{
    static final long serialVersionUID = -32285492089542L;
    public EcDef(){
 
    }
    public EcDef(String msg){
        super(msg);
    }
}

面试题总结：

类似型：

final、finally、finalize
throw、throws
Collection、Collections
String、StringBuffer、StringBuilder
ArrayList、LinkedList
HashMap、LinkedHashMap
重写、重载

结构不相似的：

抽象类、接口
==、equals()
sleep()、wait()

Sinkers

「Java」九、异常处理

异常概述与异常体系结构

异常概述

异常体系结构

常见异常

异常处理机制一： try-catch-finally

异常处理机制二： throws

手动抛出异常

用户自定义异常类

「自动机」第三章

如何不使用第三方工具，彻底卸载360？

Comments NOTHING

取消回复

	public class ErrorTest{
	public static void main(String[] args){
	//1.栈溢出：java.lang.StackOverflowError
	main(args);
	//2.堆溢出：java.lang.OutOfMemoryError
	Integer[] arr=new Integer[102410241024];
	}
	}

	java.lang.Throwable
	\|-----java.lang.Error：一般不便携针对性的代码进行处理
	\|-----java.lang.Exception：可以进行异常处理
	\|-----编译时异常（checked）
	\|-----IOException
	\|-----FileNotFoundException
	\|-----CLassNotFoundException
	\|-----运行时异常（unchecked）
	\|-----NullPointerException
	\|-----ArrayIndexOutOfBoundsException
	\|-----ClassCastException
	\|-----NumberFormatException
	\|-----InputMismatchException
	\|-----ArithmeticException

	public class NullRef {
	int i = 1;
	public static void main(String[] args) {
	NullRef t = new NullRef();
	t = null;
	System.out.println(t.i);
	}
	}

	public class EceptionTest{
	@Test
	public void test2(){
	int[] arr=new int[10];
	System.out.println(arr[10]);
	}
	}

	public class EceptionTest{
	@Test
	public void test3(){
	Object obj=new Date();
	String str=(String)obj;
	}
	}

	public class EceptionTest{
	@Test
	public void test4(){
	String str="123";
	str="abc";
	int num=Integer.parseInt(str);
	}
	}

	public class EceptionTest{
	@Test
	public void test5(){
	Scanner scanner=new Scanner(System.in);
	int score=scanner.nextInt();
	System.out.println(score);
	}
	}

	public class EceptionTest{
	@Test
	public void test6(){
	int a=10;
	int b=0;
	System.out.println(a/b);
	}
	}

	public class EceptionTest{
	@Test
	public void test7(){
	File file=new File("hello.txt");
	fis=new FileInputStream(file);

	int data=fis.read();
	while(data!=-1){
	System.out.print((char)data);
	data=fis.read();
	}

	fis.close();
	}
	}

	try{
	//课程出现异常的代码
	}catch(异常类型1 变量名1){
	//处理异常的方式1
	}catch(异常类型2 变量名2){
	//处理异常的方式2
	}catch(异常类型3 变量名3){
	//处理异常的方式3
	}finally{
	//一定会执行的代码
	}

	try{

	}catch(Exception e){
	System.out.println(e.getMessage());
	e.printStackTrace();
	}

	public void test2(){
	FileInputStream fis=null;
	try{
	File file=new File("hello.txt");
	fis=new FileInputStream(file);

	int data=fis.read();
	while(data!=-1){
	System.out.print((char)data);
	data=fis.read();
	}
	}catch(FileNotFoundException e){
	e.printStackTrace();
	}catch(IOException e){
	e.printStackTrace();
	}finally{
	try{
	if(fis!=null)
	fis.close();
	}catch(IOException e){
	e.printStackTrace();
	}
	}
	}

	public class StudentTest{
	public static void main(String[] args){
	try{
	Student s=new Student();
	s.regist(-1001);
	System.out.println(s);
	}catch(Exception e){
	System.out.prinln(e.getMessage());
	}
	}
	}
	class Student{
	private int id;
	public void regist(int id) throws Exception{
	if(id>0){
	this.id=id;
	}else{
	throw new Exception("您输入的数据非法")；
	}
	}
	}

	public class MyException extends RuntimeException{

	static final long serialVersionUID = -9271957429329742L;

	public MyException(){

	}

	public MyException(String message){
	super(message);
	}
	}

	class Student{
	private int id;
	public void regist(int id) throws Exception{
	if(id>0){
	this.id=id;
	}else{
	throw new MyException("您输入的数据非法")；//抛出自定义的异常类型
	}
	}
	}

	public class EcmDef{
	public sataic void main(String[] args){
	try{
	int i=Integer.parseInt(args[0]);
	int j=Integer.parseInt(args[1]);

	int result=ecm(i,j);

	System.out.prinln(result);
	}catch(NumberFormatException e){
	System.out.prinln("数据类型不一致")；
	}catch(ArrayIndexOutOfBoundsException e){
	System.out.prinln("缺少命令行参数")；
	}catch(ArithmeticException e){
	System.out.prinln("除0");
	}catch(EcDef e){
	System.out.prinln(e.getMessage());
	}
	}
	public static int ecm(int i,int j) throws EcDef{
	if(i<0\|\|j<0){
	throw new EcDef("分子或分母为负数了")；
	}
	return(i/j);
	}
	}

	//自定义异常类
	public class EcDef extends Exception{
	static final long serialVersionUID = -32285492089542L;
	public EcDef(){

	}
	public EcDef(String msg){
	super(msg);
	}
	}