本文主要是介绍Java异常，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1 异常和IO

1.1异常的概述和分类

* A:异常的概述

* 异常就是Java程序在运行过程中出现的错误。

* B:异常的分类

* 通过API查看Throwable

* Error

* 服务器宕机,数据库崩溃等

* Exception

C:异常的继承体系

* Throwable

* Error

* Exception

* RuntimeException

1.2 JVM默认是如何处理异常的

* A:JVM默认是如何处理异常的

* main函数收到这个问题时,有两种处理方式:

* a:自己将该问题处理,然后继续运行

* b:自己没有针对的处理方式,只有交给调用main的jvm来处理

* jvm有一个默认的异常处理机制,就将该异常进行处理.

* 并将该异常的名称,异常的信息.异常出现的位置打印在了控制台上,同时将程序停止运行

1.3 try...catch的方式处理异常

* A:异常处理的两种方式

* a:try…catch…finally

* try catch

* try catch finally

* try finally

* b:throws

* B:try...catch处理异常的基本格式

* try…catch…finally

* C:案例演示

* try...catch的方式处理1个异常

try:用来检测异常的

catch:用来捕获异常的

finally:释放资源

public class Demo2_TryCatchF {
    public static void main(String[] args) {
        ArithmeticExceptionDemo a = new ArithmeticExceptionDemo();
        /**
         * 只要try当中的内容出现错误，try下面的语句就不会在执行，就直接跳到catch语句执行
         * try语句如果没有错误，catch的内容就不会执行
         */
        try{
            int v = a.division(55 , 0);
            System.out.println(v);
            System.out.println("+++++++++++++++++++++");
            // Exception e = new ArithmeticException(); 多态，父类引用指向子类对象
        }catch (Exception e){
            //e.printStackTrace();     // 打印出异常的所有信息
            System.out.println(e.getMessage());  // 打印异常信息
            System.out.println("出错了，你除了零了");  // 相当于你把程序的错误已经处理了
        }
        // 当你使用了try...catch异常处理机制后，后面的程序会正常执行。
        System.out.println("-------------------");
    }
}

1.4 编译期异常和运行期异常的区别

* A:编译期异常和运行期异常的区别

* Java中的异常被分为两大类：编译时异常和运行时异常。

* 所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常就是编译时异常

* 编译时异常

* Java程序必须显示处理，否则程序就会发生错误，无法通过编译

* 运行时异常

* 无需显示处理，也可以和编译时异常一样处理

2 Throwable的几个常见方法

* A:Throwable的几个常见方法

* a:getMessage()

* 获取异常信息，返回字符串。

* b:toString()

* 获取异常类名和异常信息，返回字符串。

* c:printStackTrace()

* 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

* B:案例演示

* Throwable的几个常见方法的基本使用

package com.jhedu.day20;
import me.jhedu.article.Student;
public class Demo5_StudentAge {
    public static void main(String[] args) {
        /**
         * 在实际的开发过程中，try和catch的使用率要高于throw和throws
         */
        Student s = new Student();
        try {
            s.setAge(-17);
        } catch (Exception e) {
            //e.printStackTrace();
            System.out.println("年龄不和法");
        }
        System.out.println("++++");
    }
}
public void setAge(int age)  {
    /**
     * 在程序当中设置抛出异常的方法使用的就是throws,具体用在方法的声明上面，也就是在
     * 左边的花括号前面，而在小括号的后面，不同的异常使用，分割开.
     * 而throw的使用是在方法体内，只可以抛出异常类的对象
    */
   if(age >0 && age <= 150) {
        this.age = age;
    }else {
        RuntimeException e = new RuntimeException();
        throw e;  // 属于编译异常，需要在方法声明中添加throws异常
    }

}

2.1 throws的方式处理异常

* A:throws的方式处理异常

* 定义功能方法时，需要把出现的问题暴露出来让调用者去处理。

* 那么就通过throws在方法上标识。

方法中如果抛出运行时对象的话，方法上不用声明一个可以。要是编译时异常的话就必须声明

2.3 throw的概述以及和throws的区别

* A:throw的概述

* 在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

* C:throws和throw的区别

* a:throws

* 用在方法声明后面，跟的是异常类名

* 可以跟多个异常类名，用逗号隔开

* 表示抛出异常，由该方法的调用者来处理

* b:throw

* 用在方法体内，跟的是异常对象名

* 只能抛出一个异常对象名

* 表示抛出异常，由方法体内的语句处理

2.4 finally关键字的特点及作用

* A:finally的特点

* 被finally控制的语句体一定会执行

* 特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))

* B:finally的作用

* 用于释放资源，在IO流操作和数据库操作中会见到

Io流是需要打开的，打开之后需要关闭。在finally里面关闭

Finally强大到用return结束方法也会执行。

2.5 finally关键字的面试题

* A:面试题1

* final,finally和finalize的区别

final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其他资源回收，例如关闭文件等。

* B:面试题2

* 如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后？

finally块的语句在try或catch中的return语句执行之后返回之前执行

若finally语句中没有return，则其执行结果不影响try和catch中已确定的返回值

finally里的修改语句可能影响也可能不影响try或catch中 return已经确定的返回值

若finally里也有return语句则覆盖try或catch中的return语句直接返回。

2.6 自定义异常概述和基本使用

* A:为什么需要自定义异常

异常有很多子类就是为了让你更好的知道抛出的是啥异常

为了有利于你排错，报不同异常代表不同的错误。看了名字就知道犯了什么错误

就是为了有个名字而已。所做的事情父类都去做了。

* 举例：人的年龄---抛一个属于自己的异常

* B:自定义异常概述

* 继承自Exception

* 继承自RuntimeException

* C:案例演示

* 自定义异常的基本使用

package com.jhedu.day20;
/**
 * * A:为什么需要自定义异常
 * 通过名字区分到底是什么异常,有针对的解决办法
 * 举例：人的年龄
 * B:自定义异常概述
 * 继承自Exception
 * 继承自RuntimeException
 * C:案例演示
 * 自定义异常的基本使用
 */
public class Demo7_SelfException {
    /**
     *
     * @param args
     * @throws AgeOutOfBoundsException  自定义异常
     */
    public static void main(String[] args) throws AgeOutOfBoundsException {
        Person p = new Person();
        // 捕获异常
       try{
           p.setAge(17);
           System.out.println(p.getAge());
       }catch (Exception e){
           System.out.println("年龄非法");
       }
    }
}

package com.jhedu.day20;
public class Person {
    private String name;
    private int age;
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) throws AgeOutOfBoundsException {
        if(age >0 && age <= 150) {
            this.age = age;
        }else {
            throw new AgeOutOfBoundsException("年龄非法");
        }
    }
}

package com.jhedu.day20;
public class AgeOutOfBoundsException extends Exception {
    // 空参数的构造方法
    public AgeOutOfBoundsException() {
        super();   // 调用父类Exception的构造方法
    }
    // 有参数的构造方法
    public AgeOutOfBoundsException(String message) {
        super(message);  // 调用父类Exception的有参数构造方法
    }
}

2.7异常的注意事项及如何使用异常处理

* A:异常注意事项

* a:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)

* b:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常

* c:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

* B:如何使用异常处理

* 原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws

* 区别:

* 后续程序需要继续运行就try

* 后续程序不需要继续运行就throws

* 如果JDK没有提供对应的异常，需要自定义异常。

这篇关于Java异常的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！