异常处理

最新推荐文章于 2021-12-06 19:51:32 发布

璐哈路哈呦

最新推荐文章于 2021-12-06 19:51:32 发布

阅读量530

点赞数 1

分类专栏：总结文章标签： java 异常处理异常

本文链接：https://blog.csdn.net/qq_39650208/article/details/76468325

版权

总结专栏收录该内容

22 篇文章 0 订阅

订阅专栏

什么是异常？

异常就是在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序。

Java异常处理的五个关键字：

try（执行可能产生异常的代码）
catch（捕获异常）
finally（无论是否发生异常，代码都能执行）
throw（手动抛出异常）
throws（声明方法可能要抛出的各种异常）

try…..catch……finally

try至少要和catch或者finally中的一个一起出现在一个程序中。通过一个小程序来了解异常。

//声明的手动输入是int型，而输入的是字符型或者字符串型，才会捕获异常，如果输入的是int型，但不是给出的几个值，将不会被捕获。
import java.util.InputMismatchException;
import java.util.Scanner;


public class HelloAccp {
    public static void main(String[] args) {
        System.out.print("请输入1至3之间的数字:");
        Scanner in = new Scanner(System.in);
        try{//在可能出现错误的地方添加 try......catch
            int courseCode = in.nextInt(); // 从键盘输入整数

            switch (courseCode) {
            case 1:
                System.out.println("C#编程"); 
                break;
            case 2:
                System.out.println("Java编程"); 
                break;
            case 3:
                System.out.println("sql");
                break;
            }
        }catch(NullPointerException e){
            System.out.println("不是合法字符");
            e.printStackTrace();//打印异常信息
        }/*finally{*/   //如果不加finally，异常出现并且不符合捕获的异常的话，下面的输出是不执行的。
               //反之，如果加了finally，异常出不出现或者捕获的是不是存在的异常的时候，下面的输出语句都会执行

            System.out.println("欢迎提出建议");
        /*}*/
    }
}

结果为：
//这个是finally加上并且异常不匹配的结果，刚开始因为异常不匹配，所以不会执行catch捕获的异常，只是输出了系统捕获的异常（个人陈述）
这里写图片描述

//这个是finally加上且异常匹配的结果，此时会执行catch捕获的异常
这里写图片描述

//这个是没加finally且异常匹配的结果
这里写图片描述

//这个是没加finally且异常不匹配的结果
这里写图片描述

throw和throws的区别

throws是对异常的声明，
语法：(修饰符)(方法名)([参数列表])[throws(异常类)]{……}
public void doA(int a) throws Exception1,Exception3{……}

throw是抛出一个异常，但不进行处理，交给异常类处理。
语法eg：throw new NullException（“不能为空值”）；

throw语句用在方法体内，表示抛出异常，由方法体内的语句处理。
throws语句用在方法声明后面，表示再抛出异常，由该方法的调用者来处理。

throws主要是声明这个方法会抛出这种类型的异常，使它的调用者知道要捕获这个异常。
throw是具体向外抛异常的动作，所以它是抛出一个异常实例。

throws说明你有那个可能，倾向。
throw的话，那就是你把那个倾向变成真实的了。

具体通过小程序来看：

public class TeacherTest {
    public static void main(String args[]){
        Teacher t=new Teacher();
        try {
            t.SetId("00712");
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());   //e.getMessage()和e.printStackTrace();的区别
                                                //e.getMessage()是可以自己手动敲出来的信息，，由前面的类声明该方法可能产生的异常，后面由调用者捕获此异常
                                                //e.printStackTrace();是产生系统的异常

        }

    }
}


public class Teacher {
    private String id;  //教师长度为7
    public void SetId(String Pid){
        if(Pid.length()==7){
            id=Pid;
        }else{
            throw new IllegalArgumentException("教师编号应该为七位");
        }
        System.out.println("测试");
    }
}

结果为：
这里写图片描述

例子：

public class Test02 {
    public static void main(String[] args) {
        try {
            test();//首先需要把test()这个方法执行完，才可以检测是否有异常
        } catch (Exception e) {
            System.out.println("exception"+e.getMessage());
        }
        System.out.println("end");

    }

    public static void test() throws Exception {
        try {
            throw new Exception("qwer");


        } finally {
            System.out.println("finally");
        }
    }

}
结果为： finally
        exceptionqwer
        end

try…..catch和throws的区别

try…..catch在执行完异常后，还会执行下面的语句，而throws遇到异常还会执行异常后面的语句。
eg：

throws

public class Myexception extends Exception {

    private int i;
    Myexception(int a){
        i=a;
    }
    public String toString(){
        return i+"大于10啦";
    }
}


public class MyexceptionTest {

    static void go(int a) throws Myexception{
        System.out.println("a="+a);
        if(a>10){
            throw new Myexception(a);//当a=20时，捕获了异常，就不再执行下面的输出语句了..........当a=1时，输出正常结束。
        }
            System.out.println("正常结束");

    }
    public static void main(String args[]){
        try{

            go(1);
            go(20);
        }catch(Myexception e){
            System.out.println("捕获异常"+e);
        }
    }

}

结果为：
当a=20时，捕获异常，就不再执行后面的句子了
这里写图片描述

try….catch


import java.util.InputMismatchException;
import java.util.Scanner;


public class HelloAccp {
    public static void main(String[] args) {
        System.out.print("请输入1至3之间的数字:");
        Scanner in = new Scanner(System.in);
        try{//在可能出现错误的地方添加 try......catch
            int courseCode = in.nextInt(); // 从键盘输入整数

            switch (courseCode) {
            case 1:
                System.out.println("C#编程"); 
                break;
            case 2:
                System.out.println("Java编程"); 
                break;
            case 3:
                System.out.println("sql");
                break;
            }
        }catch(Exception e){
            System.out.println("不是合法字符");
            e.printStackTrace();
        }/*finally{ */  //如果不加finally，异常出现并且不符合捕获的异常的话，下面的输出是不执行的。
               //反之，如果加了finally，异常出不出现或者捕获的是不是存在的异常的时候，下面的输出语句都会执行

            System.out.println("欢迎提出建议");
        /*}*/
    }
}

结果为：
捕获了异常，并且执行了，还是会执行下面的输出“欢迎提出建议”句子
这里写图片描述

异常练习：

1.编写如下异常类：

空异常(NullException ，年龄低异常(LowAgeException)，年龄高异常(HeightAgeException)，
工资低异常(LowSalaryException)，工资高异常(HighSalaryException)，身份证非法异常(IdCardException)

2．编写一个员工类，

(1) 有属性：
编号，姓名，年龄，工资，身份证号码，员工人数（10），员工工资总额（10000）
(2) 有构造器：

构造器1：设置编号，年龄，姓名；如果年龄小于18，抛出年龄低异常；如果年龄大于60
抛出年龄高异常，如果姓名为null或为空字符串，抛出空异常。

构造器2：设置工资，设置身份证号码；如果工资低于600，抛出工资低异常。
如果身份证不是18位，抛出身份证非法异常。

(3) 有方法
增加工资 addSalary(double addSalary)，抛出工资高异常，当增加后的工资大于员工工资总额时，抛出此异常。

减少工资 minusSalary(double minusSalary), 抛出工资低异常，当减少后的工资低于政府最低工资时，抛出工资低异常。

显示员工工资总额方法：showTotalSalary(),抛出空异常，当工资总额为0时，抛出此异常。

显示员工人数：voidshowTotalEmployee（），抛出空异常。当员工人数为0时，抛出此异常

3.编写main主测试类

分别生成3个员工，测试构造方法的异常抛出。
每个员工分别增加，减少工资，测试方法的异常。
显示员工的人数和工资总额。

package employee;

import exceptio.HeightAgeException;
import exceptio.HighSalaryException;
import exceptio.IdCardException;
import exceptio.LowAgeException;
import exceptio.LowSalaryException;
import exceptio.NullException;

public class Employee {
    /*
     * 编号，姓名，年龄，工资，身份证号码，员工人数（10），员工工资总额（10000）
     */
    private int id;
    private String name;
    private int age;
    private String idcard;
    private double salary;
    private int num=10;
    private double count=10000;
    public Employee() {
    }
    public Employee(String idcard, double salary) throws LowSalaryException,IdCardException{
        this.salary=salary;
        if(salary<600){
            throw new LowSalaryException("工资太低");
        }
        if(idcard.length()!=18){
            throw new IdCardException("身份证号应该是18位");
        }

    }
    public Employee(int id, String name, int age) throws LowAgeException,HeightAgeException,NullException{

        if (age<18){
            throw new LowAgeException("年龄太小！");
        }
        if(age>60){
            throw new HeightAgeException("年龄有点大！");
        }
        if(name==null || name==""){
            throw new NullException("名字不能为空！");
        }
    }

    public void addSalary(double addSalary) throws HighSalaryException{
        salary+=addSalary;
        if(salary>count){
            System.out.println(salary);
            throw new HighSalaryException("增加后的工资总额大于10000");
        }else{
            System.out.println(salary);
        }
    }
    public void minusSalary(double minusSalary) throws LowSalaryException{
        salary-=minusSalary;
        if(salary<700){
            throw new LowSalaryException("减少后的工资低于政府最低工资！");
        }
    }

    public void showTotalSalary() throws NullException{


            if(count==0){
                throw new NullException("总额为0");
            }else{


                System.out.println(count);
        }
    }

    public void showTotalEmployee(int num) throws  NullException{

        if(num==0){
            throw new NullException("总额为0");
        }else{


            System.out.println(num);
    }
    }


    /*public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getIdcard() {
        return idcard;
    }
    public void setIdcard(String idcard) {
        this.idcard = idcard;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public double getCount() {
        return count;
    }
    public void setCount(double count) {
        this.count = count;
    }*/

}



package exceptio;

public class HeightAgeException extends Exception {
    public HeightAgeException(){
        super();
    }
    public HeightAgeException(String message){
        super(message);
    }
}

package exceptio;

public class HighSalaryException extends Exception {
    public HighSalaryException(){
        super();
    }
    public HighSalaryException(String message){
        super(message);
    }
}

package exceptio;

public class IdCardException extends Exception {
    public IdCardException(){
        super();
    }
    public IdCardException(String message){
        super(message);
    }
}
package exceptio;

public class LowAgeException extends Exception {
    public LowAgeException(){
        super();
    }
    public LowAgeException(String message){
        super(message);
    }
}

package exceptio;

public class LowSalaryException extends Exception {
    public LowSalaryException(){
        super();
    }
    public LowSalaryException(String message){
        super(message);
    }
}

package exceptio;

public class NullException extends Exception {
    public NullException(){
        super();
    }
    public NullException(String message){
        super(message);
    }
}


package test;

import employee.Employee;
import exceptio.HeightAgeException;
import exceptio.HighSalaryException;
import exceptio.IdCardException;
import exceptio.LowAgeException;
import exceptio.LowSalaryException;
import exceptio.NullException;

public class Main {
    public static void main(String[] args) throws HeightAgeException, NullException, LowSalaryException, IdCardException, HighSalaryException {
        int num=0;
        try {
            Employee emp=new Employee(001, "lulu", 30);
            num+=1;
            Employee emp1=new Employee("123456798789456123",800);
            num+=1;
            Employee emp2=new Employee(002, "haha", 20);
            num+=1;
            emp1.addSalary(9000);
            emp1.showTotalSalary();
            emp.showTotalEmployee(num);
        }catch (LowAgeException e) {
            System.out.println("年龄低"+e.getMessage());
            e.printStackTrace();
        }catch(HeightAgeException e1){
            System.out.println("奶奶年纪大了"+e1.getMessage());
            e1.printStackTrace();
        }catch(NullException e2){
            System.out.println("空"+e2.getMessage());
            e2.printStackTrace();
        }catch(LowSalaryException e3){
            System.out.println("gongzidi"+e3.getMessage());
            e3.printStackTrace();
        }catch(IdCardException e4){
            System.out.println("idcard不够"+e4.getMessage());
            e4.printStackTrace();
        }


    }
}

结果为：
捕获异常，判断符合哪个异常。
这里写图片描述

Java异常类

这里写图片描述

璐哈路哈呦

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
异常处理

什么是异常？异常就是在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序。Java异常处理的五个关键字：try（执行可能产生异常的代码）catch（捕获异常）finally（无论是否发生异常，代码都能执行）throw（手动抛出异常）throws（声明方法可能要抛出的各种异常）try…..catch……finallytry至少要和catch或者finally中的一个一起出现在一个
复制链接

扫一扫