Java基础知识总结（第六篇）：枚举、注解和异常
声明:
1. 本文根据韩顺平老师教学视频自行整理，以便记忆
2. 若有错误不当之处, 请指出
系列文章目录
Java基础知识总结（第一篇）：基础语法
Java基础知识总结（第二篇）：流程控制语句(分支控制和循环控制)
Java基础知识总结（第三篇）：数组、排序和查找
Java基础知识总结（第四篇）：面向对象编程基础(类、对象、方法、包以及封装继承多态)
Java基础知识总结（第五篇）：面向对象编程进阶(代码块，抽象类、接口和内部类)
目录
一、枚举
1.自定义实现枚举
2.enum关键字实现枚举
3.Enum 类常用方法
4.enum 实现接口
二、注解
1. @Override注解
2. @Deprecated注解
3. @SuppressWarnings注解
三、异常
1.常见运行时异常
2.常见编译时异常
3.异常处理
（1）try-catch-finally
（2）throws
4.自定义异常
5.throws和throw的区别
一、枚举
介绍：枚举(enumeration)属于一种特殊的类，里面只包含一组有限的特定的对象。
1.自定义实现枚举
说明：
（1）构造器私有化
（2）本类内部创建一组对象
（3）枚举对象名通常使用全部大写，常量的命名规范.
（4）对外暴露对象（通过为对象添加 public final static 修饰符）
（5）可以提供 get 方法，但是不要提供 set
代码实例：
public class Enumeration02 {
public static void main(String[] args) {
System.out.println(Season.AUTUMN);
System.out.println(Season.SPRING);
}
}
//演示字定义枚举实现
class Season {//类
private String name;
private String desc;//描述
//在 Season 内部，直接创建固定的对象，使用final +static共同修饰
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("夏天", "炎热");
//将构造器私有化,目的防止 直接 new
//去掉 setXxx 方法, 防止属性被修改
private Season(String name, String desc) {
this.name = name;
this.desc = desc;
}
public String getName() {
return name;
}
public String getDesc() {
return desc;
}
@Override
public String toString() {
return "Season{" +
"name='" + name + '\'' +
", desc='" + desc + '\'' +
'}';
}
}运行结果：
2.enum关键字实现枚举
说明：
（1）使用关键字 enum 替代 class
（2）创建对象语法：对象名/常量名(实参列表)
（3）如果有多个常量(对象)， 使用 ,号间隔即可
（4）枚举对象必须放在枚举类的行首
（5）如果使用无参构造器 创建 枚举对象，则实参列表和小括号都可以省略
代码实例：
public class Enumeration03 {
public static void main(String[] args) {
System.out.println(Season2.AUTUMN);
System.out.println(Season2.SUMMER);
}
}
//演示使用 enum 关键字来实现枚举类
//使用关键字 enum 替代 class
enum Season2 {//类
//语法：对象名/常量名(实参列表)
//如果有多个常量(对象)， 使用 ,号间隔即可
// 枚举对象必须放在枚举类的行首
SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"), SUMMER("夏天", "炎热");
private String name;
private String desc;//描述
// 如果我们使用的是无参构造器，创建常量对象，则可以省略 ()
private Season2() {//无参构造器
}
private Season2(String name, String desc) {
this.name = name;
this.desc = desc;
}
public String getName() {
return name;
}
public String getDesc() {
return desc;
}
@Override
public String toString() {
return "Season{" +
"name='" + name + '\'' +
", desc='" + desc + '\'' +
'}';
}
}运行结果：
3.Enum 类常用方法
使用关键字 enum 时，会隐式继承 Enum 类, 这样就可以使用 Enum 类相关的方法。
| 方法名 | 功能说明 | 使用案例 |
|---|---|---|
| valueOf |
将字符串转换成枚举对象，要求字符串必须
为已有的常量名，否则报异常！
|
Season2.valueOf("AUTUMN") |
| values |
返回当前枚举类中所有的常量
|
Season2.values()
|
| toString |
Enum 类已经重写过了，返回的是当前对象名, 子类可以重写该方法，用于返回对象的属性信息
|
|
| equals | 比较两个枚举常量是否相等。也可以直接使用==来比较。注意， equals()是不可变的。 | |
| hashCode | Enum实现了 hashCode()来和 equals()保持一致。它也是不可变的。 | |
| getDeclaringClass | 得到枚举常量所属枚举类型的Class 对象。可以用它来判断两个枚举常量是否属于同一个枚举类型。 | |
| name | 得到当前枚举常量的名称。建议优先使用toString。 | autumn.name() |
| ordinal |
返回当前对象的位置号，默认从 0 开始
|
autumn.ordinal() |
| compareTo |
比较两个枚举常量，比较的是编号
|
Season2.AUTUMN.compareTo(Season2.SUMMER) |
| clone | 枚举类型不能被 Clone 。为了防止子类实现克隆方法， Enum 实现了一个仅抛出CloneNotSupportedException 异常的不变Clone()。 |
代码实例：
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());
//含有定义的所有枚举对象
Season2[] values = Season2.values();
System.out.println("===遍历取出枚举对象====");
for (Season2 season: values) {//增强 for 循环
System.out.println(season);
}
//执行流程
//1. 根据你输入的 "AUTUMN" 到 Season2 的枚举对象去查找
//2. 如果找到了，就返回，如果没有找到，就报错
Season2 autumn1 = Season2.valueOf("AUTUMN");
System.out.println("autumn1=" + autumn1);
System.out.println(autumn == autumn1);
//compareTo：比较两个枚举常量，比较的就是编号
System.out.println(Season2.AUTUMN.compareTo(Season2.SUMMER));
}
}
enum Season2 {//类
SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"), SUMMER("夏天", "炎热");
private String name;
private String desc;//描述
private Season2() {//无参构造器
}
private Season2(String name, String desc) {
this.name = name;
this.desc = desc;
}
public String getName() {
return name;
}
public String getDesc() {
return desc;
}
@Override
public String toString() {
return "Season{" +
"name='" + name + '\'' +
", desc='" + desc + '\'' +
'}';
}
}运行截图：
4.enum 实现接口
二、注解
介绍：
- 注解(Annotation)也被称为元数据(Metadata)，用于修饰解释 包、类、方法、属性、构造器、局部变量等数据信息。
- 和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息。
- 在 JavaSE 中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在 JavaEE 中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替 java EE 旧版中所遗留的繁冗代码和 XML 配置等。
三个基本的 Annotation:
1. @Override注解
作用：限定某个方法，是重写父类方法, 该注解只能用于方法
说明：
（1）@Override表示指定重写父类的方法(从编译层面验证),如果父类没有fly方法，则会报错
（2）如果不写@Override注解，而父类仍有public void flyO0,仍然构成重写
（3）@Override只能修饰方法，不能修饰其它类，包，属性等等
（4）查看@Override注解源码为@Target(ElementType.METHOD),说明只能修饰方法
（5）@Target是修饰注解的注解，称为元注解
代码实例：
public class Override_ {
public static void main(String[] args) {
}
}
class Father{//父类
public void fly(){
System.out.println("Father fly...");
}
public void say(){}
}
class Son extends Father {//子类
@Override
public void fly() {
System.out.println("Son fly....");
}
@Override
public void say() {}
}2. @Deprecated注解
作用：用于表示某个程序元素(类, 方法等)已过时
说明：
- 可以修饰方法，类，字段，包，参数等等
- @Target(value{CONSTRUCTOR,FIELD,LOCAL_VARIABLE,METHOD,PACKAGE,PARAMETER,TYPE})
- @Deprecated的作用可以做到新旧版本的兼容和过渡
代码实例：
public class Deprecated_ {
public static void main(String[] args) {
A a = new A();
a.hi();
System.out.println(a.n1);
}
}
@Deprecated
class A {
@Deprecated
public int n1 = 10;
@Deprecated
public void hi(){
}
}3. @SuppressWarnings注解
作用：抑制编译器警告
说明：
（1）当我们不希望看到这些警告的时候，可以使用 SuppressWarnings 注解来抑制警告信息
（2）在{""} 中，可以写入你希望抑制(不显示)警告信息
（3）unchecked是忽略没有检查的警告
（4）rawtypes是忽略没有指定泛型的警告(传参时没有指定泛型的警告错误)
（5）unused是忽略没有使用某个变量的警告错误
（6）@SuppressWarnings可以修饰的程序元素为具体的语句, 方法, 类
代码：
import java.util.ArrayList;
import java.util.List;
public class SuppressWarnings_ {
//当不希望看到这些警告的时候，可以使用 SuppressWarnings 注解来抑制警告信息
//在{""} 中，写入希望抑制(不显示)警告信息
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));
}
}| 警告类型 | 效果 |
|---|---|
|
all
|
抑制所有警告
|
|
boxing
|
抑制与封装 / 拆装作业相关的警告
|
|
cast
|
抑制与强制转型作业相关的警告
|
|
dep-ann
|
抑制与淘汰注释相关的警告
|
|
deprecation
|
抑制与淘汰的相关警告
|
|
fallthrough
|
抑制与 switch 陈述式中遗漏 break 相关的警告
|
|
finally
|
抑制与未传回 finally 区块相关的警告
|
|
hiding
|
抑制与隐藏变数的区域变数相关的警告
|
|
incomplete-switch
|
抑制与 switch 陈述式 (enumcase) 中遗漏项目相关的警告
|
|
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
|
抑制与未用的程式码及停用的程式码相关的警告
|
三、异常
概念：Java语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常)
异常可分为两大类
1)Error(错误):Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError[栈溢出]和OOM(out ofmemory),Error是严重错误，程序会崩溃。
2)Exception:其它因编程错误或偶然的外在因素导致的一般性向题，可以使用针对性的代码进行处理。例如空指针访问，试图读取不存在的文件，网络连接中断等等，Exception分为两大类：运行时异常(程序运行时，发生的异常)和编译时异常(编程时，编译器检查出的异常)。
1.常见运行时异常
2.常见编译时异常
（1）SQLException 操作数据库时，查询表可能发生异常
（2）IOException 操作文件时，发生的异常
（3）FileNotFoundException 当操作一个不存在的文件时，发生异常
（4）ClassNotFoundException 加载类，而该类不存在时，异常
（5）EOFException 操作文件，到文件末尾，发生异常
（6）lllegalArguementException 参数异常
3.异常处理
异常处理就是当异常发生时，对异常处理的方式。
异常处理的方式：
（1）try-catch-finally
程序员在代码中捕获发生的异常，自行处理
语法：
try {
代码/可能有异常
}catch(Exception e){
//捕获到异常
//当异常发生时系统将异常封装成Exception对象e,传递给catch
//得到异常对象后，程序员，自己处理
//注意，如果没有发生异常catch代码块不执行
}finally {
//不管try代码块是否有异常发生，始终要执行finally
//所以，通常将释放资源的代码，放在finally
}使用细节：
- 可以有多个catch语句，捕获不同的异常(进行不同的业务处理),要求父类异常在后，子类异常在前，比如(Exception在后，NullPointerException在前),如果发生异常，只会匹配一个catch
- 可以进行try-finally配合使用，这种用法相当于没有捕获异常，因此程序会直接崩掉/退出。应用场景，就是执行一段代码，不管是否发生异常，都必须执行某个业务逻辑
代码实例：
try {
Person person = new Person();
System.out.println(person.getName());//NullPointerException
int n1 = 10;
int n2 = 0;
int res = n1 / n2;//ArithmeticException
} catch (NullPointerException e) {
System.out.println("空指针异常=" + e.getMessage());
} catch (ArithmeticException e) {
System.out.println("算术异常=" + e.getMessage());
} catch (Exception e) {
System.out.println(e.getMessage());
} finally {
}2)如果出现异常，则try块中异常发生后，try块剩下的语句不再执行。将执行catch块中的语句，如果有finally,最后还需要执行finally里面的语句
（2）throws
将发生的异常抛出，交给调用者(方法)来处理，最顶级的处理者就是JVM
语法：
public static void readFile(String file) throws FileNotFoundException {}
使用细节：
1)对于编译异常，程序中必须处理，使用try-catch或者throws
2)对于运行时异常，程序中如果没有处理，默认就是throws的方式处理[举例]
3)子类重写父类的方法时，对抛出异常的规定：子类重与的方法，所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常的类型的子类型
4)在throws过程中，如果有方法try-catch,就相当于处理异常，就可以不必throws
4.自定义异常
当程序中出现了某些“错误”,但该错误信息并没有在Throwable子类中描述处理，这个时候可以自己设计异常类，用于描述该错误信息。
步骤：
（1）定义类：自定义异常类名(自己写)继承Exception或RuntimeException
（2）如果继承Exception,属于编译异常
（3）如果继承RuntimeException,属于运行异常(一般来说，继承RuntimeException)
代码实例：
public class CustomException {
public static void main(String[] args) throws AgeException {
int age = 180;
//要求范围在 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);
}
}5.throws和throw的区别
| 意义 | 位置 | 后面跟的东西 | 例子 | |
|---|---|---|---|---|
| throws | 异常处理的一种方式 | 方法声明处 | 异常类型 | public static void readFile(String file) throws FileNotFoundException {} |
| throw | 手动生成异常对象的关键字 | 方法体中 | 异常对象 | throw new AgeException("年龄需要在 18~120 之间"); |