2020.12.16

一,方法可变参数

概念:

方法可变参数的形式参数的个数可以变化,如0个,或者N 个.

代码格式:

public double area(int ... param){

}

使用...定义方法可变参数.

使用规则:

规则1:

一个方法只能有一个可变参数

public double area(int ... param){

}

规则2:

若有多个参数可变参数必须定义在最后.

public void area(int a,int b, int ...c) {

}

规则3:

方法的可变参数本质上是一个数组,可变参数课被当作数组使用.

public void area(int ... b){

​ if(b != null && b.length>0){

​ for(int i = 0;i<b.length;i++){

​ system.out.println(c[i]);

​ }

​ }

}

方法可变参数的调用:

方法1:不传入参数

方法2:传入多个离散值

方法3:传入数组对象

例:

public void area(int ... b){

​       if(b != null && b.length>0){

​               for(int i = 0;i<b.length;i++){

​                       system.out.println(c[i]);

​               }

​       }

}
public static void main(String[] args) {
    area();//无参调用，area()方法的参数b是空指针
    area(13,2,33,42,5);//传入多个离散值,此时area()方法参数b是一个数组，传入的参数是数组元素。
    int score[] = {67,78,56};
    area(score);// 传入数组对象,此时area()方法参数b是一个数组。
}

二, 异常

定义:exception

指程序在编译时，或运行时发生的不寻常的事情。

异常的处理:捕获

发生异常后,程序无法正常运行,导致程序强制终止运行.捕获后会正常运行.

异常的体系结构(重要)

Throwable类:

是异常体系结构的父类,Throw able类的父类是Object.Throwable类下有两种类别:Error(错误)和(Experience)异常.

Error类:

值无法通过程序员编写程序解决的异常

Exception类:

课以通过编写程序解决的异常.Exception有两套子类:运行时异常和编译时异常.

规定：

编译时异常必须捕获，如果不捕获会导致程序无法编译，也就无法运行了。例如ClassnotfoundExcetion就是编译时异常，例:

使用try , catch解决

RuntimeException类:

RuntimeException是所有运行时异常的父类.

如何捕获异常:使用关键字try,catch,finally,throw,throws.

三种处理方式:

用法1:

try{

}catch(Exception){

}

用法2:

try{

}catch(Exception){

}finaly{

}

用法3:

try{

}finally{

}

解析:

1,try中包裹可能发生异常的代码

2,catch中用于捕获异常并处理异常

3,finally中用于祸首资源

4,try和catch组合,catch可以有多个

5,try和finally组合,try和finally都只能有一个

6,try,catch,finally不能单独使用.catch和finally不能一起使用.

捕获异常:

1, 使用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） 异常发生后，程序进入到catch，导致从异常发生位置开始到catch位置之间的代码无法运行。

（2） 当try中没有发生异常时，程序不会进入到catch中执行

2, 使用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

3, 多重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) {
            bSystem.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没有先后顺序。

throw ,throws 异常处理

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,如何将提示信息改为中文:开发人员自己定义一个异常对象,在异常对象的构造函数中输入中文异常描述信息.

3,在主调方法中捕获的异常就是中文信息.

异常相关的方法:

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

printStacTrace() : 输出异常的对战信息.