RABBIT2002-MSI_2020.12.16.刘佳昊

一、方法可变参数

方法可变参数是指方法形参的个数可以变化,个数可以为0,或者n个

1.定义

public double finc(int ...param){
}

2.规则

  1. 一个方法只能有一个可变参数;
  2. 如果一个方法有多个参数,那么可变参数必须定义在最后;
  3. 方法可变参数本质上是一个数组,因此可变参数可以被当作数组来使用。

3.方法可变参数的调用

  • 不传入参数

  • 传入多个离散值

  • 传入数组对象

    例如

    public static void area(int ...c){
      if (c!=null&&c.length>0){
    for (int i = 0; i < c.length; i++) {
    System.out.println(c[i]);
    }
    }
    }
    public static void main(String[] args) {
      area();               //无参调用,此时area()方法的参数c是空指针
    area(1,2,3,4,5); //传入多个离散值,此时area()方法参数c是一个数组,传入的参数是数组元素。
    int score[] = {67,78,56};
    area(score); // 传入数组对象,此时area()方法参数c是一个数组。
    }

二、异常

1.概念

异常是指程序在运行过程中出现的非正常现象。如果一个程序有异常发生,那么程序就无法正常运行,会导致程序强行终止运行。但是当程序发生异常时,被捕获异常,程序中就没有了异常,便可以继续运行。

2.异常的体系结构

所有异常都是Throwable类的子类,它派生出两个子类Error类和Exception类。

1>.Error类:表示仅仅靠程序本身无法恢复的严重错误,如内存溢出、动态链接失败、虚拟机错误。

2>.Exception类:该类是所有异常类的父类。其中Exception类又可分为两大类异常:

(1)运行时异常:也称为unchecked异常,包括RuntimeException及其所有子类。

(2)设计时异常:也称作Checked异常(非运行时异常):除了运行时异常外的其他从Exception类继承的异常类。

规定:编译时异常必须捕获,如果不捕获会导致程序无法编译,也就无法运行了。

例如:

使用try、catch解决

class Demo1{
    public static void main(String[] args) {
        try {
            Class.forName("java.lang.String");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

3.捕获异常

(1)try、catch、finally异常处理

用法1:try-catch

try {

}catch (Exception e){
    
}

用法2:try-catch-finally

try {

}catch (Exception e){

}finally {
    
}

用法3:try-finally

try {

    }finally {

    }
}

注:

  1. try中用于包裹住可能发生异常的代码。
  2. catch中用于捕获异常,并对异常进行处理
  3. finally中用于回收资源
  4. try与catch组合时,一个try可以与多个catch组合,但是try只能有一个
  5. try与finally组合时,一个try只能与一个finally组合,且try与finally都只能有一个
  6. try不能单独使用,catch不能单独使用,finally不能单独使用,catch和finally不能组合使用

示例1:不捕获异常

class Demo3 {
    public static void main(String[] args) {
        int i=1,j=0,res;
        System.out.println("begin");
        res = i/j;
        System.out.println("end");
    }
}

运行结果

begin

Exception in thread "main" java.lang.ArithmeticException: / by zero

​ at homework01.Demo1.main(Demo1.java:6)

输出了begin,没有输出end,说明程序发了异常,也没有捕获,导致程序强行终止运行。提示异常信息为算术异常,除零异常,发生在demo1的第6行。

示例2:使用try和catch捕获异常

public static void main(String[] args) {
    try {
        int i = 1, j = 0, res;
        System.out.println("begin");
        res = i / j;//抛出异常
        System.out.println("end");
    } catch (Exception e) {//捕获异常
        System.out.println("catched");
        e.printStackTrace();
    }
    System.out.println("over");
}

运行结果

begin

catched

java.lang.ArithmeticException: / by zero

​ at homework01.Test.main(Test.java:7)

over

解析:

(1) try中放了可能发生异常的代码

(2) 如果try中发生了异常,那么程序就会立即被catch捕获,异常被捕获后异常就没有了,所有程序就可以继续运行。

(3) 异常发生后,程序进入到catch,导致从异常发生位置开始到catch位置之间的代码无法运行。

(4) 当try中没有发生异常时,程序不会进入到catch中执行

示例3:finally

public static void main(String[] args) {
    try {
        int i = 1, j = 0, res;
        System.out.println("begin");
        res = i / j;
        System.out.println("end");
    } catch (ArithmeticException e) {
        System.out.println("catched");
        e.printStackTrace();
    } finally {
        System.out.println("finally");
    }
    System.out.println("over");
}

begin

catched

java.lang.ArithmeticException: / by zero

​ at homework01.Test.main(Test.java:7)

finally

over

解析:

当try中有finally时,finally是必须要执行的,

如果没有发生异常,执行顺序是try-finally

如果发生了异常,执行顺序是try-catch-finally

示例4:多重catch

public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    try {
        System.out.println("计算开始");
        int i, j, res;
        System.out.println("请输入被除数");
        i = input.nextInt();
        System.out.println("请输入除数");
        j = input.nextInt();
        res = i / j;
        System.out.println(i + "/" + j + "=" + res);
        System.out.println("计算结束");
    } catch (InputMismatchException e) {
        System.out.println("除数和被除数必须都是整数");
    } catch (ArithmeticException e) {
        System.out.println("除数不能为零");
    } catch (Exception e) {
        System.out.println("其他异常" + e.getMessage());
    } finally {
        System.out.println("感谢使用本程序");
    }
    System.out.println("程序结束");
}

解析:

一个try可以配置多个catch,但是多个catch是有先后顺序的,必须把子类的catch写在前面,把父类的catch写在后面,并列的catch没有先后顺序。

(2)throw、throws异常处理

throws

用于定义在方法声明的后面,表示该方法可能会抛出异常,并告诉主调方法需要处理该方法抛出的异常。

throws不能单独写一行代码,后面是抛出异常的类型,可抛出多个异常类型,多个之间用逗号分隔。

throw

throw用在方法内部,后面紧跟一个异常对象,表示要抛出这个异常。

示例1:被调方法不处理异常,将异常抛给主调方法

public static void main(String[] args) {
    try {
        divide();
    } catch (ArithmeticException e) {
        e.printStackTrace();
    }
}
public static void divide() throws ArithmeticException{
    System.out.println("start");
    int i=1,j=0;
    int res = i/j;
    System.out.println("over");
}

start

java.lang.ArithmeticException: / by zero

​ at homework01.Test.divide(Test.java:19)

​ at homework01.Test.main(Test.java:10)

解析:

(1) main方法是主调方法

(2) divide是被调方法,被调方法内部发生异常时,被调方法没有处理异常,而是将异常抛给主调方法,由主调方法处理异常。

示例2:被调方法抓住异常后再次抛给主调方法(常用)

需求:将除0的错误描述显示为中文。

public static void main(String[] args) {
    try {
        divide();
    } catch (ArithmeticException e) {
        e.printStackTrace();
    }
}
public static void divide() throws ArithmeticException{
    try {
        System.out.println("start");
        int i=1,j=0;
        int res = i/j;
        System.out.println("over");
    } catch (Exception e) {
        ArithmeticException ex = new ArithmeticException("除零异常");
        throw ex;
    }
}

运行结果

​ start

java.lang.ArithmeticException: 除零异常

​ at homework01.Test.divide(Test.java:23)

​ at homework01.Test.main(Test.java:10)

分析:

(1)被调方法先自己处理异常,在抛出异常该主调方法

(2) int res = i/j 由于 j=0,jvm 抛出 ArithmeticException 异常,该异常被 catch 抓住,所以 catch 中的 e 就是 i/j** 时抛出的异常,但是这个异常由于是jvm创建并抛出的,因此是英文提示。

(3) 如何改为中文提示。方法是开发人员自定义一个异常对象,在异常对象的构造函数中输入中文异常描述信息,再将这个异常对象使用throw关键字抛出。

(4) 在主调方法中捕获的异常就是中文信息。

4.自定义异常

Java关于异常提供了很多API,如果这些异常API不能满足你的需要,此时你可以自己定义异常类。用于满足你自己的业务需要。

第一步:定义异常类,继承Exception或者RuntimeException

​ 继承Exception表示自定义编译时异常。

​ 继承RuntimeException表示自定义运行时异常。

第二步:设置异常的描述信息

​ 在Throwable类中定义了描述异常信息的属性,名字是message。可以将自定义异常的描述存储在该属性中。通过构造函数可将异常描述信息传递到throwable中赋值给message属性。

示例:

​ 为学生实体对象性别赋值时,只要不是男或者女就是错误的,需要抛出性别异常。

先自定义一个性别异常,命名为GenderException

class GenderException extends RuntimeException{
    public  GenderException(String message){
        super(message);
    }
}
class Student{
    private String gender;
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        if("男".equals(gender) ||"女".equals(gender)) {
            this.gender = gender;
        }
        else {
            throw new GenderException("性别错误,必须是男或女");//抛出异常
        }
    }
}
class Test1 {
    public static void main(String[] args) {
        try {
            Student s =new Student();
            s.setGender("公");
        } catch (GenderException e) {
            String message = e.getMessage();
            System.out.println(message);
            e.printStackTrace();
        }
    }
}

date12_16.GenderException: 性别错误,必须是男或女
性别错误,必须是男或女
at date12_16.Student.setGender(Test.java:122)
at date12_16.Test1.main(Test.java:130)

5.异常相关的方法

getMesage():获取异常描述信息

printStackTrace():输出异常的堆栈信息

标签

评论

© 2021 成都云创动力科技有限公司 蜀ICP备20006351号-1