java异常分类,异常处理,面试中常见异常问题!

简介: java异常分类,异常处理,面试中常见异常问题!

什么是异常?

程序运行过程中产生的不正常的情况统称为异常!

Throwable 类是 Java 语言中所有错误或异常的超类。提供了错误堆栈实现等一系列方法。 有两个直接子类:Error & Exception


程序错误一般分为三种:

1.编译错误;2.运行时错误;3.逻辑错误。


(1)编译错误是因为程序没有遵循语法规则,编译程序能够自己发现并且提示我们错误的原因和位置,这个也是我们在刚接触编程语言最常遇到的问题。


(2)运行时错误是因为程序在执行时,运行环境发现了不能执行的操作。


(3)逻辑错误是因为程序没有按照预期的逻辑顺序执行。异常也就是指程序运行时发生错误,而异常处理就是对这些错误进行处理和控制。


先说一下java异常体系结构图吧:

两个子类区别:


Error: 程序不应该捕捉的错误,应该交由JVM来处理。一般可能指非常重大的错误。这个错误我们一般获取不到,也无法处理!


Exception:程序中应该要捕获的错误。这个异常类及它的子类是我们需要学习获取要处理的。


(1)RuntimeException:运行时异常,也叫未检查异常,是Exception的子类,但不需捕捉的异常超类,但是实际发生异常时,还是会导致程序停止运行的的,只是编译时没有报错而已。比如除数为零,数组空指针等等,这些都是在运行之后才会报错。此类异常,可以处理也可以不处理,并且可以避免。


(2)在Exception的所有子类中 除了RuntimeException类和它的子类,其他类都叫做非运行时异常,或者叫已检查异常,通常被定义为Checked类,是必须要处理可能出现的异常,否则编译就报错了。Checked类主要包含:IO类和SQL类的异常情况,这些在使用时经常要先处理异常(使用throws或try catch捕获)。


java几种常见的异常:

运行时异常:

1,java.lang.ArrayIndexOutOfBoundsException 数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。

2,ArithmeticException 算术错误情形,如以零作除数,算术条件异常。

3 java.lang.SecurityException 安全性异常

4,IllegalArgumentException 方法接收到非法参数,非法参数异常!

5,java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常

6,java.lang.NegativeArraySizeException 数组长度为负异常

7 java.lang.ClassNotFoundException 找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。

8 java.lang.NullPointerException 空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。

9,java.lang.NumberFormatException(数字格式转换异常)

10,java.lang.ClassCastException(强制类型转换异常)


IOException

1, IOException 操作输入流和输出流时可能出现的异常

2, EOFException 文件已结束异常

3, FileNotFoundException 文件未找到异常

异常的产生:

自动产生:当程序遇到错误代码,会产生异常,程序终止

手动产生:throw new 异常类名();

throw必须定义在在方法体中,用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。


下面看一个手动抛出异常的例子:

package prac;
public class t2 {
  public static void main(String[] args) throws Exception {
    // TODO Auto-generated method stub
    m1();
  }
  public static void m1() throws Exception {
    System.out.println("m1----------start");
    m2();
    // 手动抛出受查异常
    throw new Exception();
    //System.out.println("m1----------end");
  }
  public static void m2() {
    System.out.println("m2----------start");
    // 手动抛出运行时异常,需要携带信息“程序因为异常而终止”
    throw new RuntimeException("程序因为异常而终止");
    //System.out.println("m2----------end");
  }
}
程序运行结果为:
m1----------start
m2----------start
Exception in thread "main" java.lang.RuntimeException: 程序因为异常而终止
  at prac.t2.m2(t2.java:31)
  at prac.t2.m1(t2.java:21)
  at prac.t2.main(t2.java:16)

异常的处理:

异常的处理分为消极的处理(自己处理不了,就往调用它的地方上抛throws,异常没有解决,只是抛出)和积极处理(异常捕获,捕捉异常通过try-catch语句或者try-catch-finally语句实现)


消极的处理:

语法:public void m1() throws 异常类名1,异常类名2{}

特点:相当于推卸责任,最终问题依然无法得到解决。

允许编译通过。

当上抛的异常为非运行(已检查)时异常时,调用此方法的调用者必须处理。

当上抛的异常为运行(未检查)时异常时,可以处理可以不处理。


积极的处理:(异常捕获)

将异常直接捕获,并且做出处理

语法:

try{
    //异常代码
  }catch(异常类名 引用名){  
    //当异常产生执行的代码
  }

try 后的catch代码块 只能匹配成功一个

catch后声明的异常为父类时,它能够捕捉的异常为它本身+所有子类异常(多态的体现)

注意:catch代码块捕获异常时,子类异常必须定义在父类异常前面,否则会编译出错


finally代码块:一定会执行此代码块中的代码,常用来关闭资源,

  try{
  }catch(){
  }finally{
    //无论是否产生异常,一定会去执行的代码
  }
注意:finally代码块中不要定义return语句

下面一个程序详细介绍异常的处理:

package work;
import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;
import java.util.Scanner;
/**
 * @author 超伟
 * @date 2019年5月13日  
 * @version 1.0.0  
 */
public class t4 {
  public static void main(String[] args) {
    System.out.println("main1");
    int n;
    Scanner sc = new Scanner(System.in);
    n = sc.nextInt();
    ma(n);
    System.out.println("main2");
  }
  public static void ma(int n){
    try {
      System.out.println("m1");
      mb(n);
      System.out.println("m2");
    } catch (EOFException e) {
      //e.printStackTrace();
      System.out.println("EOFException    ");
    } catch (IOException e) {
      System.out.println("IOException e111");
    }catch (SQLException e) {
      System.out.println("SQLException");
    }catch (Exception e) {
      System.out.println("Exception");
    }finally{
      System.out.println("in finally");
    }
  }
  public static void mb(int n) throws Exception {
    System.out.println("mb1");
    if (n==1) {
      throw new EOFException();
    }
    if (n==2) {
      throw new FileNotFoundException();
    }
    if (n==3) {
      throw new SQLException();
    }
    if (n==4) {
      throw new NullPointerException();
    }
    System.out.println("mb2");
  } 
}
程序运行结果为:
main1
1
m1
mb1
EOFException    
in finally
main2

throw和throws的区别

这只是有点相似的关键字,并没有任何关联,要学会区分。

throw是用在方法体里面的,一般是放在判断情况的后面,手动抛出异常。

throws只能用在需要捕获异常的方法的方法名的括号后面使用。


自定义异常:

为什么要自定义异常?

当Java内置的异常都不能明确的说明异常情况的时候,需要创建自己的异常。


自定义一个异常类,需要继承于Exception或者其子类。

若想要这个异常类为运行时异常,需继承于RuntimeException或者其子类。

一般定义为运行时异常


自定义的异常类需要至少无参有参两个构造方法

例如:

package work;
import java.io.EOFException;
import java.util.Scanner;
public class t5 {
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    try {
      m(n);
    } catch (MyException1 e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      System.out.println(e.getMessage());
    }catch (MyException2 e) {
      // TODO: handle exception
      e.printStackTrace();
      System.out.println(e.getMessage());
    } 
  }
  public static void m(int n) throws MyException1{
    if (n==1) {
      throw new MyException1("我自己定义的非运行时异常");
    }
    else {
      throw new MyException2("这是我定义的一个运行时异常!!!");
    }
  }
}
//自定义异常
//已检查异常,非运行时异常
class MyException1 extends EOFException{
  public MyException1() {
    super();
  }
  public MyException1(String s) {
    super(s);
  }
}
//未检查异常
//运行时异常
class MyException2 extends RuntimeException{
  public MyException2() {
  }
  public MyException2(String message) {
    super(message);
  }
}

方法覆盖,在继承中的异常的提现:

方法覆盖需要满足的3个条件

1.返回值类型 方法名 参数列表完全一致

2.访问修饰符相同或更宽

3.子类中方法不能抛出比父类更多、更宽的异常

package work;
import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;
/**
 * @author 超伟
 * @date 2019年5月13日  
 * @version 1.0.0  
 */
public class t8 {
  /**
   * @param args 
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
  }
}
class Super{
  public void ma() throws IOException{
  }
}
interface IA{
  void mb();
}
class MySub extends Super implements IA{
  //父类抛出一个非运行时异常,子类可以抛出一个或者多个父类抛出的异常的子类异常
  /*public void ma() throws IOException,FileNotFoundException,EOFException{
  }*/
  //父类抛出一个非运行时异常,子类可以抛出一个或者多个运行时异常
  public void ma() throws SecurityException,ClassCastException{
  }
  public void mb() {
  }
}

Java异常处理的原则和技巧

1,避免过大的try块。不要把不会出现异常的代码放到try块里面,尽量保持一个try块对应一个或多个异常。

2,细化异常的类型。不要不管什么类型的异常都写成Excetpion。

3,catch块尽量保持一个块捕获一类异常。不要忽略捕获的异常,捕获到后要么处理,要么转译,要么重新抛出新类型的异常。

4,不要把自己能处理的异常抛给别人。

5,不要用try…catch参与控制程序流程。异常控制的根本目的是处理程序的非正常情况。


所以像那些可以预料的错误,尽量在执行之前就做好相应的处理,


比如除数为零或空指针问题,要做事前判断再运行程序。


final, finally, finalize 的区别。

final 用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承。内部类要访问局部变量,局部变量必须定义成 final 类型


finally 是异常处理语句结构的一部分,表示总是执行。


finalize 是 Object 类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖此方法提供垃圾收集时的其他资源回收,例如关闭文件等。JVM 不保证此方法总被调用


运行时异常与一般异常有何异同?


异常表示程序运行过程中可能出现的非正常状态,运行时异常表示虚拟机的通常操作中可能遇到的异常,是一种常见运行错误。java 编译器要求方法必须声明抛出可能发生的非运行时异常,但是并不要求必须声明抛出未被捕获的运行时异常。


error 和 exception 有什么区别?


error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。

exception 表示一种设计或实现问题。也就是说,它表示如果程序运行正常,从不会发生的情况。


Java 中的异常处理机制的简单原理和应用。

异常是指 java 程序运行时(非编译)所发生的非正常情况或错误,与现实生活中的事件很相似,现实生活中的事件可以包含事件发生的时间、地点、人物、情节等信息,可以用一个对象来表示,Java 使用面向对象的方式来处理异常,它把程序中发生的每个异常也都分别封装到一个对象来表示的,该对象中包含有异常的信息。


Java 对异常进行了分类,不同类型的异常分别用不同的 Java 类表示,所有异常的根类为 java.lang.Throwable,

Throwable 下面又派生了两个子类:Error 和 Exception,Error 表示应用程序本身无法克服和恢复的一种严重问

题,程序只有死的份了,例如,说内存溢出和线程死锁等系统问题。Exception 表示程序还能够克服和恢复的问题,其中又分为系统异常和普通异常,系统异常是软件本身缺陷所导致的问题,也就是软件开发人员考虑不周所导致的问题,软件使用者无法克服和恢复这种问题,但在这种问题下还可以让软件系统继续运行或者让软件死掉,例如,数组脚本越界 ( ArrayIndexOutOfBoundsException ) , 空 指 针 异 常 ( NullPointerException ) 、 类 转 换 异 常(ClassCastException);普通异常是运行环境的变化或异常所导致的问题,是用户能够克服的问题,例如,网络断线,硬盘空间不够,发生这样的异常后,程序不应该死掉。


java 为系统异常和普通异常提供了不同的解决方案,编译器强制普通异常必须 try…catch 处理或用 throws 声明继

续抛给上层调用方法处理,所以普通异常也称为 checked 异常,而系统异常可以处理也可以不处理,所以,编译器不强制用 try…catch 处理或用 throws 声明,所以系统异常也称为 unchecked 异常。


就按照三个级别去思考:虚拟机必须宕机(就是死机)的错误,程序可以死掉也可以不死掉的错误,程序

不应该死掉的错误;


JAVA 语言如何进行异常处理,关键字:throws,throw,try,catch,finally 分别代表什么意义?

throws 是获取异常

throw 是抛出异常

try 是将会发生异常的语句括起来,从而进行异常的处理,也可以在 try 块中抛出新的异常

catch 是如果有异常就会执行他里面的语句

finally 不论是否有异常都会进行执行的语句

目录
相关文章
|
2天前
|
架构师 Java 数据库连接
Java异常处理的20个最佳实践:告别系统崩溃
你是否在为如何处理异常而困扰? 你是否曾被面试官问道Java异常处理的最佳实践有哪些? 本文汇总了Java异常处理的20个最佳实践:让你告别系统崩溃,面试游刃有余
19 2
Java异常处理的20个最佳实践:告别系统崩溃
|
2天前
|
存储 缓存 Java
面试官:什么是Java内存模型?
面试官:什么是Java内存模型?
15 0
面试官:什么是Java内存模型?
|
1天前
|
JSON 监控 Java
Java Web开发中的异常处理与日志记录最佳实践
Java Web开发中的异常处理与日志记录最佳实践
|
1天前
|
Java 编译器 开发者
Java中的异常处理机制详解
Java中的异常处理机制详解
|
3天前
|
缓存 监控 架构师
阿里面试:Java开发中,应如何避免OOM
在Java开发中,OutOfMemoryError(OOM)错误一直是令开发者头疼的问题,也是Java面试中出现核心频率很高的问题。 那么我们究竟怎么样才能够有效正确的管理内存,日常开发中究竟要注意哪些核心技巧来避免OOM错误。 本文将带大家一起学习10个避免OOM的实用小技巧,让大家在工作中能够有的放矢,避免OOM错误的飞来横祸。
21 1
|
4天前
|
Java
|
19天前
|
存储 监控 Java
【Java SE语法篇】11.异常
【Java SE语法篇】11.异常
|
22天前
|
人工智能 运维 Java
Java异常
Java异常
30 0
|
22天前
|
安全 IDE Java
终结空指针异常:Java开发者的生存指南
终结空指针异常:Java开发者的生存指南
39 1
|
22天前
|
安全 IDE Java
【2024java面试题无需C币下载】终结空指针异常:Java开发者的生存指南
【2024java面试题无需C币下载】终结空指针异常:Java开发者的生存指南
27 1

相关产品

  • 云迁移中心