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

目录

一、Java异常概念

二、异常的体系

三、异常处理

四、throws

五、自定义异常

一、Java异常概念

异常：程序在运行时出现的，可以使用异常处理机制处理的不正常情况

广义上的异常：程序中出现的任何不正常的错误

可分为两类：error(错误):一旦程序运行时出现错误，程序是无法解决的

exception（狭义异常）：程序在运行时出现不正常的情况，但可以通过异常机制来解决

狭义上的异常：指的是程序在运行时出现的不正常情况，可以使用异常处理机制来处理

public class ErrorDemo1 {
    public static void main(String[] args) {
        /*ErrorDemo1 errorDemo1 = new ErrorDemo1();
        errorDemo1.sum(10);*/
        /*一般的运行时异常，是可以处理的，虚拟机默认的处理方式是停止运行，出现的异常会说明发生异常的类型，异常的原因，以及异常的位置*/
        /*NullPointerException空指针异常*/
        /*String s = null;
        System.out.println(s.length());*/
        /*ArrayIndexOutOfBoundsException:数组下标越界异常，表示数组所以大于或等于数组长度*/
        int [] a = new int[5];
        a[5]=8;
        /*数学运算异常:ArithmeticException*/
        /*int g = 10;
        int h = 0;
        System.out.println(g/h);*/
        /*类型转换异常:ClassCastException*/
        /*Object s = "abc";
        Integer i1 = (Integer)s;
        System.out.println(i1);*/
    }
    /*错误的案例：递归调用，过多，栈内存不够用，会出现这个错误，StackOverflowError，表示内存不够用，程序无法运行，是我们无法解决的*/
    /*public int sum(int num){
        return num+sum(num-1);*/
   // }
}
​

二、异常的体系

异常的分类：编译时异常：在编译期间必须处理，在写代码时，就会强制提示进行处理，throws/try catch 

运行时异常：编写代码时，可以不用处理，继承了RuntimeException，在写代码时不提示处理

三、异常处理

有两种方式，第一种是声明异常,第二种是给可能出现异常的地方加上try{}catch(){}

public class BianyiDemo {
    /*public static void main(String[] args) throws UnsupportedEncodingException {
        String s = "abc";
        byte [] b = s.getBytes("UTF-8");
    }*/
    public static void main(String[] args) {
        String s = "abc";
        try {
            byte [] b = s.getBytes("UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

/*当有多个catch时，父类类型的异常需要放在最下面*/
try{
    编写可能出现异常的代码
}catch(异常类型 形参){
    捕获try中对应类型的异常，进行处理
}
/*发生异常，但没有处理，程序不能向后运行，但是finally中的代码可以执行*/
try{
    编写可能出现异常的代码
}catch(异常类型 形参){
    捕获try中对应类型的异常，进行处理
}finally{
    最终必须执行的代码
}
try{
    编写可能出现异常的代码
}finally{
    最终必须执行的代码
}

不加finally的案例：

public class DealDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try {
            int c = a/b;
        }catch (ArithmeticException e){
            System.out.println("运算异常");
        }
        System.out.println("执行后面的代码块");
    }
}

加finally的案例：

public class FinallyDemo {
    public static void main(String[] args) {
    int a = 10;
    int b = 0;
        try {
        int c = a/b;
    }catch (ArithmeticException e){
        e.printStackTrace();
    }finally {
            System.out.println("必须执行的代码块");
        }
    }
}

四、throws

声明这个方法可能出现异常，方法的声明处，抛出异常不处理，强调在编译期间处理

模拟是一个偏底层方法，这样的一般不try{}catch(){}，继续声明此方法可能出现异常作为方法的声明（定义）

throws+UnsupportEncodingException （编译期异常）

提示方法调用的地方，在编译期间就要做出处理

throws+NullpointerException (运行期异常)

在编译期间不显示提示处理

public class ThrowsDemo {
    public static void main(String[] args) {
        try {
            ThrowsDemo.test1();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
    public static void test1() throws UnsupportedEncodingException {
        ThrowsDemo.test2();
    }
    public static void test2() throws UnsupportedEncodingException {
        System.out.println("格式正确");
    }
}

方法重写：方法名相同，返回值相同，参数列表相同

访问权限等于或者大于父类所声明的

声明的异常类型等于或者小于父类所声明的异常类型

public abstract class P {
    public abstract void run() throws UnsupportedEncodingException ;
    public abstract void eat() throws NullPointerException;
    public abstract void sleep() throws IOException;
}
public class S extends P {
    @Override
    public void run() throws UnsupportedEncodingException {
    }
    @Override
    public void eat() throws NullPointerException {
    }
    @Override
    /*public void sleep() throws IOException {
    }*/
    public void sleep() throws UnsupportedEncodingException {
    }
}

五、throw

直接抛出异常，在方法中显示的抛出一个异常类的对象，表示此处实际发生了异常

new+有参的构造方法（描述异常的原因）

e.printStackTrace(); 在控制台打印异常信息

public class ThrowDemo {
    public static void main(String[] args) {
        try {
            ThrowDemo.judge(101);
        } catch (UnsupportedEncodingException e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
    }
    public static void judge(int score) throws UnsupportedEncodingException {
        if (score<0 || score > 100) {
           throw new UnsupportedEncodingException("非法分数");
        }else if (score >= 90){
            System.out.println("A");
        }else{
            System.out.println("B");
        }
    }
}

五、自定义异常

我们在业务开发过程中，可以根据实际业务需求自己开发一个异常类，表示某一类问题

public class ScoreException extends Exception{
   /*分数不合法抛出此类的对象 例如 百分制试卷 传入一个小于0  或大于100的分数 */
        public ScoreException() {
            super();
        }
        public ScoreException(String message) {
            super(message);
        }
}
public class Test {
    public static void main(String[] args) {
        try {
            trans(101);
        } catch (ScoreException e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }
    public static  String trans(int socre) throws ScoreException {
        if(socre<0||socre>100){
            throw new ScoreException("非法分数");
        }
        if(socre>=90){
            return "A";
        }else{
            return "B";
        }
    }
}

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