java-使用异常处理程序错误

//异常，try写法

    try {//捕获异常
            //这里写一般正常代码
            //就是可能会出现的异常代码
        } catch (Exception e) {//声明异常
           e.printStackTrace();//抛出异常
        }

比如这个下标越界的异常情况

int aa[]=new int[10];
        try {//捕获异常
            System.out.println(aa[10]);
        } catch (Exception e) {//程序异常就会进入catch进行抛出
            System.out.println("下标越界");
            e.printStackTrace();//打印出现异常信息
        }
        //Exception是异常的父类

  /*打印结果：
            下标越界
          java.lang.ArrayIndexOutOfBoundsException: 10
              at Z.JavaGJBC.jiekou.yic.Try.main(Try.java:19)
  */

一般还有分母不能为0的异常情况

package Z.JavaGJBC.jiekou.yic;

public class TryC {

    public void pp() throws InterruptedException,RuntimeException,Exception{
      //throws InterruptedException,RuntimeException,Exception声明多个异常
      //throws（异常类名，....）一般应用方法后面抛出多个异常，多个异常之间用逗号隔开
        Thread.sleep(1000);//当前线程沉睡一秒
        System.out.println("8888");
        //throw new ...抛出异常对象，需要捕获，一般应用自定义异常
        throw new Exception();
        
    }
    

    public String test() {
        try {
            Thread.sleep(1000);
            System.out.println("1");//代码正常走
            System.out.println(1/0);//出现异常
            System.out.println("2");//代码不执行
            return "222";
        }catch (ArithmeticException e) {//代码异常后进入catch
            System.out.println("3");//执行
            //e.printStackTrace();
        }
        
        //在使用多重（嵌套）catch时，如果进入第一个catch后其他的catch就不在执行
        //在使用多重catch时，catch中异常对象范围必须从小到大.
        
        catch (Exception e) {//代码异常后进入catch
            System.out.println("3");//执行
            //e.printStackTrace();
        }finally {//finally无论是否出现异常，代码都会始终执行
            //finally必须和try...catch...一起使用，不能单独使用
            //finally代码在return之前执行
            System.out.println("4");//继续执行
        }
        System.out.println("5");
        return "555";
    }
    public static void main(String[] args) {
        TryC a=new TryC();
        System.out.println(a.test());
    }
}

我在简单提一下自定义异常类吧

我们先新建一个自定义异常类，就叫MyException

package Z.JavaGJBC.jiekou.yic;

public class MyException extends Exception{//Exception异常祖先类
    //自定义异常：用一个自己建的类继承 Exception或RuntimeException


  //以下都是调用父类的构造方法
    public MyException() {
        
    }

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

    public MyException(String message,Throwable e) {
        super(message,e);
    }
    public static void main(String[] args) {
        
    }

}

那么有了这个自定义异常类可以干什么呢？

当然是可以做题了 哈哈哈

 改造四则运算计算器，添加适当的异常处理，使其系统更加完善
 要求：要检查输入的合法性；对减法要求被减数要大于减数；
 除法的被除数不能为0；乘法不能出现乘数为0，运算不允许出现负数
 所有出现异常的必须使用抛出异常提示（使用自定义异常）

package Z.JavaGJBC.jiekou.yic;

import java.util.Scanner;

public class Counter {

    public void cou() throws Exception {
        Scanner scan =new Scanner(System.in);
        System.out.println("请输入第一个数字:");
        int a = scan.nextInt();
        System.out.println("请输入第二个数字:");
        int b = scan.nextInt();
        System.out.println("输入运算符");
        int fuhao = scan.nextInt();
        switch(fuhao) {
        case 1:
            System.out.println(a+b);
            break;
        case 2:
            if(b<a) {//判断被减数是否小于减数
                throw new MyException("被减数小于减数,抛出异常");
              //注意这里的异常抛出用的都是MyException自定义的.
            }else {
                System.out.println(a-b);
            }
            break;
        case 3:
            if(b==0) {//判断被除数是否为0
                throw new MyException("被除数结果为0,抛出异常");
            }else {
            System.out.println(a/a);
            }
            break;
        case 4:
            if(a==0||a==0) {//判断乘数是否为03
                throw new MyException("乘数结果为0,抛出异常");
            }
            if(a<0||b<0){//判断结果是否为负数
                throw new MyException("结果为负数,抛出异常");
            }else {
            System.out.println(a*b);
            }
        }
    }
    
    public static void main(String[] args) {
        Counter ss=new Counter();
        try {//捕获异常
            ss.cou();//调用方法
        } catch (MyException e) {//声明异常
            e.printStackTrace();//抛出异常
        }
    }
}

代码执行结果自行复制去运行.

再整一个不用自定义异常类的，直接用异常祖先类

package Z.JavaGJBC.jiekou.yic;

import java.util.Scanner;

public class Figure {
        /*猜数字游戏，100以内数字，最多猜5次，超过5次抛出异常提示
        游戏断电，游戏卡死等异常都要有友好提示（抛出异常提示）
        游戏3次以内猜对提示有奖品，游戏4-5次猜对提示还需要加油*/
    int u=88;//定义要猜的数字
    int p=0;//记录次数
    Scanner scan=new Scanner(System.in);
    public void fig() throws Exception {//Exception异常祖先类
         do{
            System.out.println("请输入你要猜的数字");
            p++;
            int a=scan.nextInt();
            if(a!=u) {
                System.out.print("猜错了\t");
            }else if(p<=3 && a==u) {
                System.out.println("三次以内猜对了，有奖品");
                break;
            }else if(p==4 || p==5 && a==u) {
                System.out.println("4-5次猜对，没有奖品");
                break;
            }
            if(p>5) {
                throw new Exception("超过5次，游戏卡死了，出现异常");
            }
         }while(true);
    }
    public static void main(String[] args) {
        Figure test=new Figure();
        try {
            test.fig();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

因为这个代码执行结果会有异常的

我也懒的截图，你们自己复制去运行吧.

在写最后一道题

属性：长、宽(均为正值，用double类型)
方法：计算面积、计算周长
要求：如果面积小于1或大于1000，则表示该长方形太小或太大，
无法显示，要抛出异常并进行处理；如果周长大于200，则表示超出预算，
给定材料不足，在该方法中声明要抛出异常，并在调用该方法时使用try/catch捕获。
编写测试类进行测试.

package Z.JavaGJBC.jiekou.yic;

import java.rmi.MarshalException;

public class Rectangle {

    private double len;//长
    private double width;//宽

    public double mianji() throws Exception {//面积
        double mj=len*width;
        if(mj<1) {
            throw new Exception("长方形太小了...");
            //throw 抛出异常后，代码不在向下执行
        }else if(mj>1000) {
            throw new Exception("长方形太大了...");
        }
        return mj;//满足上方异常就不会执行这个
    }
    public double getRec() throws Exception {//周长
        double zc=(len+width)*2;
        if(zc>200) throw new Exception("材料不足");
        //throw 抛出异常后，代码不在向下执行
        return zc;
    }
}

package Z.JavaGJBC.jiekou.yic;

public class RectangleTest{

    public static void main(String[] args) throws Exception {

        Rectangle test=new Rectangle();
        try {//捕获异常
            double a=test.mianji();
        } catch (MyException e) {//抛出异常
            e.printStackTrace();
        }//面积
        
        try {//捕获异常
            double b=test.getRec();
        } catch (MyException e) {//抛出异常
            e.printStackTrace();
        }//周长
    }
}

然后你们别忘了去看看思维导图.

我在导图里做了各个异常类的父子关系.做的也很细节

异常这个东西，在以后的大量编程当中会经常用到的

所以一定要理解和掌握.

下面这张图是各个异常类的错误描述