【Java基础】-- 第10、11章：枚举、注解、异常处理

小d<>

已于 2022-11-07 20:06:30 修改

阅读量406

点赞数

分类专栏： Java 文章标签： java

于 2022-10-27 09:35:10 首次发布

本文链接：https://blog.csdn.net/qq_46656857/article/details/127545808

版权

Java 专栏收录该内容

39 篇文章 1 订阅

订阅专栏

Java基础

十、枚举和注解

枚举类

就是把具体的对象一个一个例举出来的类就称为枚举类

1）枚举是一组常量的集合

2）可以理解为枚举属于一种特殊的类，里面只包含一组有限的特定的对象

枚举的实现方式

自定义实现枚举
使用enum关键字实现枚举

自定义实现枚举

1）不需要提供setXXX方法，因为枚举对象值通常为只读

2）对枚举对象/属性使用final+static共同修饰，实现底层优化

3）枚举对象名通常使用全部大写，常量的命名规范

4）枚举对象根据需要，也可以有多个属性

package com.Chapter04.enum_;

public class EnmuerClass {
    public static void main(String[] args) {
        System.out.println(Season.AUTUMN);
    }
}
//演示自定义枚举实现
//1.将构造器私有化，目的防止直接new
//2.去掉setXXX方法，防止属性被修改
//3.在season内部直接创建固定的对象
//4.优化：可以加入final关键字
class Season{  //类
    private String name;
    private String desc; //描述

    //定义了四个对象
    public static final Season SPRING = new Season("春天", "温暖");
    public static final Season WINTER = new Season("冬天", "寒冷");
    public static final Season AUTUMN = new Season("秋天", "凉爽");
    public static final Season SUMMER = new Season("夏天", "炎热");

    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

小结：

1）构造器私有化

2）本类内部创建一组对象

3）对外暴露对象（通过为对象添加public final static修饰符）

4）可以提供get方法，但是不要提供set

enum关键字实现枚举

package com.Chapter04.enum_;

public class EnumClass02 {
    public static void main(String[] args) {
        System.out.println(Season2.SPRING);
    }
}
//使用enum关键字来实现枚举类
enum Season2{  //类
    //使用enum来实现枚举类
    //1.使用关键字enum替代class
    //2.public static final Season SPRING = new Season("春天","温暖");直接使用
    //    SPRING("春天","温暖");解读，常量名(实参列表)
    //3.如果有多个常量对象，使用,号间隔即可
    //4.使用enum来实现枚举，要求将定义常量对象，写在前面
    //5.如果使用无参构造器，创建常量对象，则可以省略()
     SPRING("春天","温暖"),WINTER("冬天","寒冷");
    private String name;
    private String desc; //描述

    //定义了四个对象
//    public static final Season2 SPRING = new Season2("春天", "温暖");
//    public static final Season2 WINTER = new Season2("冬天", "寒冷");
//    public static final Season2 AUTUMN = new Season2("秋天", "凉爽");
//    public static final Season2 SUMMER = new Season2("夏天", "炎热");

    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }
    private Season2(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

enum关键字实现枚举注意事项：
1）当我们使用enum关键字开发一个枚举类时，默认会继承Enum类，而且是一个final类

2）传统的public static final Season2 SPRING = new Season2(“春天”, “温暖”);简化成SPRING(“春天”,“温暖”)必须要知道它调用的是哪个构造器

3）如果使用无参构造器创建枚举对象，则实参列表和小括号都可以省略

4）当有多个枚举对象时，使用,号间隔，最后有一个分号结尾

5）枚举对象必须放在枚举类的行首

enum常用方法

说明：使用关键字enum时，会隐式继承enum类，这样我们就可以使用enum类相关的方法

toString:Enum 类已经重写过了，返回的是当前对象
名,子类可以重写该方法，用于返回对象的属性信息
name：返回当前对象名（常量名），子类中不能重写
ordinal：返回当前对象的位置号，默认从0 开始
values：返回当前枚举类中所有的常量
valueOf：将字符串转换成枚举对象，要求字符串必须
为已有的常量名，否则报异常！
compareTo：比较两个枚举常量，比较的就是编号！

package com.hspedu.enum_;
public class EnumMethod {
    public static void main(String[] args) {
        //使用Season2 枚举类，来演示各种方法
        Season2 autumn = Season2.AUTUMN;
        //输出枚举对象的名字
        System.out.println(autumn.name());
        //ordinal() 输出的是该枚举对象的次序/编号，从0 开始编号
        //AUTUMN 枚举对象是第三个，因此输出2
        System.out.println(autumn.ordinal());
        //从反编译可以看出values 方法，返回Season2[]
        //含有定义的所有枚举对象
        Season2[] values = Season2.values();
        System.out.println("===遍历取出枚举对象(增强for)====");
        for (Season2 season: values) {//增强for 循环
            System.out.println(season);
        }
        //valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常
            //执行流程
            //1. 根据你输入的"AUTUMN" 到Season2 的枚举对象去查找
            //2. 如果找到了，就返回，如果没有找到，就报错
            Season2 autumn1 = Season2.valueOf("AUTUMN");
        System.out.println("autumn1=" + autumn1);
        System.out.println(autumn == autumn1);
        //compareTo：比较两个枚举常量，比较的就是编号
        //1. 就是把Season2.AUTUMN 枚举对象的编号和Season2.SUMMER 枚举对象的编号比较
        //2. 看看结果
        /*
public final int compareTo(E o) {
return self.ordinal - other.ordinal;
}
Season2.AUTUMN 的编号[2] - Season2.SUMMER 的编号[3]
*/
        System.out.println(Season2.AUTUMN.compareTo(Season2.SUMMER));
        //补充了一个增强for
        // int[] nums = {1, 2, 9};
        // //普通的for 循环
        // System.out.println("=====普通的for=====");
        // for (int i = 0; i < nums.length; i++) {
        // System.out.println(nums[i]);
        // }
        // System.out.println("=====增强的for=====");
        // //执行流程是依次从nums 数组中取出数据，赋给i, 如果取出完毕，则退出for
        // for(int i : nums) {
        // System.out.println("i=" + i);
        // }
    }
}

enum实现接口

1）使用enum关键字后，就不能再继承其他类了，因为enum会隐式继承Enum，而java是单继承机制

2）枚举类和普通类一样，可以实现接口

enum 类名 implements 接口1 接口2{}

package com.Chapter04.enum_;

public class EnumMethod {
    public static void main(String[] args) {
        Music.CLASSMUSIC.playing();
    }
}

//enum实现的枚举类，仍然是一个类，还是可以实现接口的
interface IPlaying{
    public void playing();
}
enum Music implements IPlaying{
    CLASSMUSIC;
    @Override
    public void playing() {
        System.out.println("音乐");
    }
}

注解

1）注解也称为元数据，用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息

2）和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息

3）在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE 中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替java EE 旧版中所遗留的繁冗代码和XML 配置等。

基本的Annotation介绍

使用Annotation 时要在其前面增加@ 符号, 并把该Annotation 当成一个修饰符使用。用于修饰它支持的程序元素
三个基本的Annotation:

1）@Override: 限定某个方法，是重写父类方法, 该注解只能用于方法

2）@Deprecated: 用于表示某个程序元素(类, 方法等)已过时

3）@SuppressWarnings：抑制编译器警告

@Override

1）@Override表示指定重写父类的方法（从编译层面验证），如果父类没有fly方法，则会报错

2）如果不写@Override注解，而父类仍有public void fly(){}，仍然构成重写

3）@Override只能修饰方法，不能修饰其他类，包，属性等等

4）查看@Override注解源码为@Target(ElementType.METHOD),说明只能修饰方法

5）@Target是修饰注解的注解，称为元注解

package com.Chapter04.annotation_;

public class Override_ {
    public static void main(String[] args) {

    }
}
class Father{ //父类
    public void fly(){
        System.out.println("father fly...");
    }
}
class Son extends Father{
    //1.@override注解放在fly方法上，表示子类的fly方法时重写了父类的fly
    //2.这里如果没有写@override还是重写了父类fly
    //3.如果写了@override注解，编译器就会去检查该方法是否真的重写了父类的方法
    // 如果的确重写了，则编译器通过，如果没有构成重写，则编译错误
    //4.如果发现@interface表示一个注解类
    @Override
    public void fly() {
        System.out.println("son fly...");
    }
    //@Override  报错
    public void say(){}
}

@Deprecated

1）用于表示某个程序元素（类、方法等）已过时

2）可以修饰方法、类、字段、包、参数等

3）@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})

4）@Deprecated的作用可以做到新旧版本的兼容和过渡

package com.Chapter04.annotation_;

public class Deprecated_ {
    public static void main(String[] args) {
        A a = new A();
        a.hi();
    }
}
//1.@Deprecated修饰某个元素，表示该元素已经过时
//2.即不在推荐使用，但是仍然可以使用
@Deprecated
class A{
    public int n1 = 10;
    @Deprecated
    public void hi(){

    }
}

@SupperWarnings

package com.Chapter04.annotation_;

import java.util.ArrayList;
import java.util.List;

@SuppressWarnings({"rawtypes", "unchecked", "unused"})
public class Supperwarning {
    //1. 当我们不希望看到这些警告的时候，可以使用SuppressWarnings 注解来抑制警告信息
    //2. 在{""} 中，可以写入你希望抑制(不显示)警告信息
    //3. 可以指定的警告类型有
    // all，抑制所有警告
    // boxing，抑制与封装/拆装作业相关的警告
    // //cast，抑制与强制转型作业相关的警告
    // //dep-ann，抑制与淘汰注释相关的警告
    // //deprecation，抑制与淘汰的相关警告
    // //fallthrough，抑制与switch 陈述式中遗漏break 相关的警告
    // //finally，抑制与未传回finally 区块相关的警告
    // //hiding，抑制与隐藏变数的区域变数相关的警告
    // //incomplete-switch，抑制与switch 陈述式(enum case)中遗漏项目相关的警告
    // //javadoc，抑制与javadoc 相关的警告
    // //nls，抑制与非nls 字串文字相关的警告
    // //null，抑制与空值分析相关的警告
    // //rawtypes，抑制与使用raw 类型相关的警告
    // //resource，抑制与使用Closeable 类型的资源相关的警告
    // //restriction，抑制与使用不建议或禁止参照相关的警告
    // //serial，抑制与可序列化的类别遗漏serialVersionUID 栏位相关的警告
    // //static-access，抑制与静态存取不正确相关的警告
    // //static-method，抑制与可能宣告为static 的方法相关的警告
    // //super，抑制与置换方法相关但不含super 呼叫的警告
    // //synthetic-access，抑制与内部类别的存取未最佳化相关的警告
    // //sync-override，抑制因为置换同步方法而遗漏同步化的警告
    // //unchecked，抑制与未检查的作业相关的警告
    // //unqualified-field-access，抑制与栏位存取不合格相关的警告
    // //unused，抑制与未用的程式码及停用的程式码相关的警告
    //4. 关于SuppressWarnings 作用范围是和你放置的位置相关
    // 比如@SuppressWarnings 放置在main 方法，那么抑制警告的范围就是main
    // 通常我们可以放置具体的语句, 方法, 类.
    //5. 看看@SuppressWarnings 源码
    //(1) 放置的位置就是TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE
    //(2) 该注解类有数组String[] values() 设置一个数组比如{"rawtypes", "unchecked", "unused"}
    /*
    @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
    @Retention(RetentionPolicy.SOURCE)
    public @interface SuppressWarnings {
    String[] value();
    }
    */
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        int i;
        System.out.println(list.get(1));
    }
    public void f1() {
// @SuppressWarnings({"rawtypes"})
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
// @SuppressWarnings({"unused"})
        int i;
        System.out.println(list.get(1));
    }
}

说明各种值：
1）unchecker是忽略没有检查的警告

2）rawtypes是忽略没有指定泛型的警告（传参时没有指定泛型的警告错误）

3）unused是忽略没有使用某个变量的警告错误

4）@SuppressWarnings可以修饰的程序元素为，查看@ Target

5）生成@ SupperssWarnings时，不用背，直接点击左侧的黄色提示，就可以选择(注意可以指定生成的位置)

元注解

JDK 的元Annotation 用于修饰其他Annotation

元注解的种类：

1）Retention //指定注解的作用范围，三种SOURCE,CLASS,RUNTIME

2）Target // 指定注解可以在哪些地方使用

3）Documented //指定该注解是否会在javadoc 体现

4）Inherited //子类会继承父类注解

@Retention注解

说明：
只能修饰一个Annotation定义，用于指定该Annotation可以保留多长时间，@Rentention包含一个RetentionPolicy类型的成员变量，使用@Rentention时必须为该value成员变量指定值：
@Rentention的三种值：

RetentionPolicy.SOURCE: 编译器使用后，直接丢弃这种策略的注释
RetentionPolicy.CLASS: 编译器将把注解记录在class 文件中。当运行Java 程序时, JVM 不会保留注解。这是默认
值
RetentionPolicy.RUNTIME:编译器将把注解记录在class 文件中。当运行Java 程序时, JVM 会保留注解. 程序可以通过反射获取该注解

@Target注解
基本说明：用于修饰Annotation定义，用于指定被修饰的Annotation能用于修饰哪些程序元素@Target也包含一个名为value的成员变量

@Documented注解

基本说明：

@Documented：用于指定被该元Annotation修饰的Annotation类将被Javadoc工具提取成文档，即在生成文档时，可以看到该注解

说明：定义为Documented的注解必须设置为Retention值为RUNTIME

@Inherited 注解

被它修饰的Annotation将具有继承性，如果某个类使用了被@Inherited修饰的Annotation，则其子类将自动具有该注释

十一、异常处理

基本介绍

在Java语言中，将程序执行中发生的不正常情况称为"异常"(开发过程中的语法错误和逻辑错误不是异常)

package com.Chapter05.Exception_;

public class Exception01 {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 0;
        //1.num1/num2 => 10/0
        //2.当执行到num1/num2，因为num2=0，程序就会出现(抛出)异常，ArithmeticException
        //3.当抛出异常后，程序就退出，崩溃了，下面的代码就不会执行
        //4.Java设计者提供了一个异常处理机制来解决该问题
        //如果程序员认为一段代码可能出现异常/问题，可以使用try-catch异常处理机制来解决
        //从而保证程序的健壮性
        //5.如果进行异常处理，那么即使出现了异常，程序可以继续执行
        try {
            int res = num1 / num2;
        } catch (Exception e) {
            //e.printStackTrace();
            System.out.println(e.getMessage());
        }

        System.out.println("程序继续运行");

    }
}

执行过程所发生的异常事件可分为两大类

1）Error(错误)：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况，如：StackOverflowError(栈溢出)和OOM(out of memory)，Error是严重错误，程序会崩溃

2）Exception：其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如空指针访问，试图读取不存在的文件，网络连接中断等等，Exception分为两大类：运行时异常[程序运行时发生异常]和编译时异常[编程时，编译器检查出的异常]

异常体系图

总结：

异常分为两大类，运行时异常和编译时异常
运行时异常，编译器检查不出来，一般是指编程时的逻辑错误，是程序员应该避免其出现的异常，java.lang.RuntimeException类及它的子类都是运行时异常
对于运行时异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响
编译时异常，是编译器要求必须处置的异常

五大运行时异常

1）NullPointException：空指针异常

2）ArithmeticException：数学运算异常

3）ArrayIndexOutOfBoundsException：数组下标越界异常

4）ClassCastException：类型转换异常

5）NumberFormatException：数学格式不正确异常

空指针异常

当应用程序试图在需要对象的地方使用null时，抛出该异常

数学运算异常

当出现异常的运算条件时，抛出该异常，如整数除零异常

数组下标越界异常

用非法索引访问数组时抛出的异常，如果索引为负或者大于等于数组大小，则该索引为非法索引

类型转换异常

当试图将对象强制转换成不是实例的子类时，抛出该异常

package com.Chapter05.Exception_;

public class ClassCastException {
    public static void main(String[] args) {
        A b = new B(); //向上转型
        B b2 = (B)b; //向下转型
        C c2 = (C)b; //这里会抛出CLassCastException

    }
}
class A {}
class B extends A {}
class C extends A {}

数字格式不正确异常

当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换成适当格式时，抛出该异常=>使用异常我们可以确保输入是满足条件数字

编译异常

编译异常是在编译期间，就必须处理的异常，否则代码不能通过编译

常见的编译异常：

SQLException：操作数据库时，查询表可能发生异常
IOException：操作文件时，发生的异常
FileNotFoundException：当操作一个不存在的文件时，发生异常
ClassNotFoundException：加载类，而该类不存在时，发生异常
EOFException：操作文件时，到文件末尾，发生异常
IIIegalArgumentException：参数异常

异常处理机制

异常处理的方式：
1）try - catch - finally

程序员在代码中捕获发生的异常，自行处理

2）throws

将发生的异常抛出，交给调用者（方法）来处理，最顶级者就是JVM

try-catch异常处理

1）Java提供try和catch块来处理异常，try块用于包含可能出错的代码，catch块用于处理try块中发生的异常，可以根据需要在程序中有多个try…catch块

2）基本语法：

try{
    //可疑代码
    //将异常生成对应的异常对象，传递给catch块
}catch(异常){
    //对异常的处理
}
//如果没有finally，语法是可以通过的

注意事项：
1）如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块

2）如果异常没有发生，则顺序执行try的代码块，不会进入到catch

3）如果希望不管是否发生异常，都执行某段代码（比如关闭连接，释放资源等），则使用如下代码–finally{ }

package com.Chapter05.try_;

public class TryCatch02 {
    public static void main(String[] args) {
        try {
            String str = "aaaa";
            int a = Integer.parseInt(str);
            System.out.println("数字" + a);
        } catch (NumberFormatException e) {
            System.out.println("异常信息" + e.getMessage());
        }
        finally {
            System.out.println("finally代码块被执行");
        }
        System.out.println("程序继续");
    }
}

4）可以有多个catch语句，捕获不同的异常（进行不同的业务处理），要求父类异常在后，子类异常在前，比如Exception在后，NullPointerException在前），如果发生异常，只会匹配一个catch

package com.Chapter05.try_;

import com.Chapter05.Exception_.NullException;

public class TryCatch01 {
    public static void main(String[] args) {
        //1.如果代码块有可能有多个异常
        //2.可以使用多个catch 分别捕获不同的异常，相应处理
        //3.要求子类异常写在前面，父类异常写在后面
        try {
            Person person = new Person();
            System.out.println(person.getName());
            int n1 = 10;
            int n2 = 0;
            int res = n1/n2; //ArithmeticException
        }catch (NullPointerException e){
            System.out.println("空指针异常"+e.getMessage());
        }
        catch (Exception e) {
            System.out.println("算术异常"+e.getMessage());
        }finally {

        }

    }
}
class Person{
    private String name;

    public String getName() {
        return name;
    }
}

5）可以进行try-finally配合使用，这种用法相当于没有捕获异常，因此程序会直接崩溃。应用场景，就是执行一段代码，不管是否发生异常，都必须执行某个业务逻辑

try-catch-finally执行顺序：

1）如果没有出现异常，则执行try块中所有语句，不执行catch块中语句，如果有finally，最后还需要执行finally里面的语句

2）如果出现异常，则try块中异常发生后，try块剩下的语句不再执行，将执行catch块中的语句，如果有finally，最后还需执行finally里面的语句

throws异常处理

基本介绍：

1）如果一个方法（中的语句执行时）可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表面该方法将不对这些异常进行处理，而由该方法的调用者负责

2）在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类

package com.Chapter05.throws_;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class Throws01 {
    public static void main(String[] args) {

    }
    public void f1() throws FileNotFoundException{
        //创建了一个文件流对象
        //1.这里的异常是一个FileNotFoundException编译异常
        //2.使用前面讲过的try-catch-finally
        //3.使用throws，抛出异常，让调用f1方法的调用者(方法)处理
        //4.throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类
        //5.throws关键字后也可以是异常列表，即可以抛出多个异常
        FileInputStream fis = new FileInputStream("d://a.txt");

    }
}

注意事项和使用细节：
1）对于编译异常，程序中必须处理，比如try-catch或者throws

2）对于运行时异常，程序中如果没有处理，默认就是throws的方式处理

3）子类重写父类的方法时，对抛出异常的规定：子类重写的方法，所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常的类型的子类型

4）在throws过程中，如果有方法try-catch，就相当于处理异常，就可以不必throws

package com.Chapter05.throws_;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class Throws02 {
    public static void main(String[] args) {

    }
    public static void f2() throws ArithmeticException{
    //1.对于编译异常，程序中必须处理，比如try-catch 或者throws
    //2.对于运行时异常，程序中如果没有处理，默认就是throws 的方式处理
        int n1 = 10;
        int n2 = 0;
        double res = n1 / n2;
    }
    public static void f1() throws FileNotFoundException {
    //这里大家思考问题调用f3() 报错
    //1. 因为f3() 方法抛出的是一个编译异常
    //2. 即这时，就要f1() 必须处理这个编译异常
    //3. 在f1() 中，要么try-catch-finally ,或者继续throws 这个编译异常
        f3(); // 抛出异常
    }
    public static void f3() throws FileNotFoundException {
        FileInputStream fis = new FileInputStream("d://aa.txt");
    }
    public static void f4() {
    //1. 在f4()中调用方法f5() 是OK
    //2. 原因是f5() 抛出的是运行异常
    //3. 而java 中，并不要求程序员显示处理,因为有默认处理机制
        f5();
    }
    public static void f5() throws ArithmeticException {
    }

}
class Father { //父类
    public void method() throws RuntimeException {
    }
}
class Son extends Father {//子类
    //3. 子类重写父类的方法时，对抛出异常的规定:子类重写的方法，
    // 所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常类型的子类型
    //4. 在throws 过程中，如果有方法try-catch , 就相当于处理异常，就可以不必throws
    @Override
    public void method() throws ArithmeticException {
    }
}

自定义异常

基本概念：当程序中出现了某些"错误"，但该错误信息并没有在Throwable子类中描述处理，这个时候可以自己设计异常类，用于描述该错误信息

自定义异常的步骤：
1）定义类：自定义异常类名（程序员自己写）继承Exception或RuntimeException

2）如果继承Exception，属于编译异常

3）如果继承RuntimeException，属于运行异常（一般来说，继承Runtime Exception）

package com.Chapter05.throws_;

public class CustomException {
    public static void main(String[] args) {
        int age = 80;
        //要求范围在18-120之间，否则抛出一个自定义异常
        if(!(age>=18 && age<=120)){
            //这里我们可以通过构造器设置信息
            throw new AgeException("年龄需要在18-120之间");
        }
        System.out.println("你的年龄范围正确");
    }
}
//自定义一个异常
//1.一般情况下，我们自定义异常是继承RuntimeException
//2.即把自定义异常做成运行时异常，好处是我们可以使用默认的处理机制
class AgeException extends RuntimeException{
    public AgeException(String message) {
        super(message);
    }
}