RABBIT2002-MSI_2020.12.16.刘佳昊

学员日志 676 5年前 0 admin

一、方法可变参数

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

1.定义

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

2.规则

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

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 {

    }
}

注：

try中用于包裹住可能发生异常的代码。
catch中用于捕获异常，并对异常进行处理
finally中用于回收资源
try与catch组合时，一个try可以与多个catch组合，但是try只能有一个
try与finally组合时，一个try只能与一个finally组合，且try与finally都只能有一个
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()：输出异常的堆栈信息

RABBIT2002-MSI_2020.12.16.刘佳昊

一、方法可变参数

1.定义

2.规则

3.方法可变参数的调用

二、异常

1.概念

2.异常的体系结构

3.捕获异常

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

(2)throw、throws异常处理

4.自定义异常

5.异常相关的方法

热门资源

评论留言

取消回复

一、方法可变参数

1.定义

2.规则

3.方法可变参数的调用

二、异常

1.概念

2.异常的体系结构

3.捕获异常

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

(2)throw、throws异常处理

4.自定义异常

5.异常相关的方法

热门资源

相关推荐

评论留言

取消回复