1、枚举
-
基本介绍
（1）枚举对应英文(enumeration, 简写 enum)
（2）枚举是一组常量的集合
（3）可以这里理解：枚举属于一种特殊的类，里面只包含一组有限的特定的对象 -
枚举的二种实现方式
（1） 自定义类实现枚举
（2） 使用 enum 关键字实现枚举 -
自定义类实现枚举
步骤：
（1）构造器私有化
（2）本类内部创建一组对象
（3）对外暴露对象（通过为对象添加 public final static 修饰符）
（4）可以提供 get 方法，但是不要提供 setpublic 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;//描述 //3. 在 Season 内部，直接创建固定的对象 //4. 优化，可以加入 final 修饰符 //定义了四个对象, 固定: 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("夏天", "炎热"); //1. 将构造器私有化,目的防止 直接 new private Season(String name, String desc) { this.name = name; this.desc = desc; } //2. 去掉 setXxx 方法, 防止属性被修改 public String getName() { return name; } public String getDesc() { return desc; } } -
enum 关键字实现枚举
（1）使用关键字 enum 替代 class
（2）public static final Season SPRING = new Season(“春天”, “温暖”) 改为：SPRING(“春天”, “温暖”)——解读：常量名(实参列表)
（3）如果有多个常量(对象)， 使用 逗号间隔即可
（4）如果使用 enum 来实现枚举，要求将定义常量对象，写在前面
（5）如果我们使用的是无参构造器，创建常量对象，则可以省略 ()//1. 使用关键字enum替代class enum Season2 { //2. public static final Season SPRING = new Season("春天", "温暖") 改为：SPRING("春天", "温暖")——解读：常量名(实参列表) //3. 如果有多个常量(对象)， 使用 逗号间隔即可 //4. 如果使用 enum 来实现枚举，要求将定义常量对象，写在前面 //5. 如果我们使用的是无参构造器，创建常量对象，则可以省略 () 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 name + desc; } } -
enum 关键字实现枚举注意事项
（1）当我们使用 enum 关键字开发一个枚举类时，默认会继承 Enum 类, 而且是一个 final 类
（2）传统的 public static final Season2 SPRING = new Season2(“春天”, “温暖”); 简化成SPRING(“春天”, “温暖”)， 这里必须清楚调用的是哪个构造器.
（3）如果使用无参构造器 创建枚举对象，则实参列表和小括号都可以省略
（4）当有多个枚举对象时，使用逗号间隔，最后有一个分号结尾
（5）枚举对象必须放在枚举类的行首 -
enum 常用方法介绍
（1）toString:Enum 类已经重写过了，返回的是当前对象名,子类可以重写该方法，用于返回对象的属性信息
（2）name：返回当前对象名（常量名），子类中不能重写（建议使用toString）
（3）ordinal：返回当前对象的位置号，默认从 0 开始
（4）values：返回当前枚举类中所有的常量
（5）valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常！
（6）compareTo：比较两个枚举常量，比较的就是编号！public class EnumMethod { public static void main(String[] args) { //使用 Season2 枚举类，来演示各种方法 Season2 autumn = Season2.AUTUMN; //（2）name：输出枚举对象的名字 System.out.println(autumn.name()); //（3）ordinal() 输出的是该枚举对象的次序/编号，从 0 开始编号 System.out.println(autumn.ordinal()); //（4）从反编译可以看出 values 方法，返回 Season2[] //含有定义的所有枚举对象 Season2[] values = Season2.values(); for (Season2 season: values) {//增强 for 循环 System.out.println(season); //（5）valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常 //执行流程 //1. 根据你输入的 "AUTUMN" 到 Season2 的枚举对象去查找 //2. 如果找到了，就返回，如果没有找到，就报错 Season2 autumn1 = Season2.valueOf("AUTUMN"); System.out.println("autumn1=" + autumn1); System.out.println(autumn == autumn1); //（6）compareTo：比较两个枚举常量，比较的就是编号,比较结果为调用的编号减去传入的编号的值 System.out.println(Season2.AUTUMN.compareTo(Season2.SUMMER)); } } -
enum 实现接口
（1）使用 enum 关键字后，就不能再继承其它类了，因为 enum 会隐式继承 Enum，而 Java 是单继承机制。
（2）枚举类和普通类一样，可以实现接口，形式：enum 类名 implements 接口 1，接口 2{}
2、注解
-
注解的理解
（1）注解(Annotation)也被称为元数据(Metadata)，用于修饰解释 包、类、方法、属性、构造器、局部变量等数据信息。
（2）和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息。
（3）在 JavaSE 中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在 JavaEE 中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替 java EE 旧版中所遗留的繁冗代码和 XML 配置等。 -
基本的 Annotation 介绍
使用 Annotation 时要在其前面增加 @ 符号, 并把该 Annotation 当成一个修饰符使用。用于修饰它支持的程序元素
三个基本的 Annotation:
（1）@Override: 限定某个方法，是重写父类方法, 该注解只能用于方法
（2）@Deprecated: 用于表示某个程序元素(类, 方法等)已过时，不建议使用
（3）@SuppressWarnings: 抑制编译器警告 -
@Override
（1）@Override 表示指定重写父类的方法(从编译层面验证)，如果父类没有方法，则会报错
（2）如果不写@Override 注解,而父类仍有 public void fly0){}，仍然构成重写
（3）@Override 只能修饰方法，不能修饰其它类，包，属性等等
（4）查看@Override注解源码为 @Target(ElementType.METHOD),说明只能修饰方法
（5）@Target 是修饰注解的注解， 称为元注解
（6）@interface 不是interface，是注解类，是jdk5.0之后加入的 -
@Deprecated
（1）用于表示某个程序元素(类,方法等)已过时
（2）可以修饰方法，类，字段,包,参数 等等
（3）@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD,PARAMETER, TYPE})
（4）@Deprecated 的作用可以做到新日版本的兼容和过渡 -
@SuppressWarnings
（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 作用范围是和你放置的位置相关，通常我们可以放置具体的语句, 方法, 类
（5）生成@SupperssWarnings 时，不用背，直接点击左侧的黄色提示，就可以选择（注意可以指定生成的位置） -
JDK 的元 Annotation(元注解， 了解)
1）元注解的基本介绍
JDK 的元 Annotation 用于修饰其他 Annotation
元注解： 本身作用不大，讲这个原因希望同学们，看源码时，可以知道他是干什么
2）元注解的种类
（1）Retention：指定注解的作用范围，三种 SOURCE,CLASS,RUNTIME
（2）Target ：指定注解可以在哪些地方使用
（3） Documented：指定该注解是否会在 javadoc 体现
（4）Inherited：子类会继承父类注解
3）@Retention
只能用于修饰一个 Annotation 定义, 用于指定该 Annotation 可以保留多长时间, @Rentention 包含一个 RetentionPolicy类型的成员变量, 使用 @Rentention 时必须为该 value 成员变量指定值:
@Retention 的三种值
（1） RetentionPolicy.SOURCE: 编译器使用后，直接丢弃这种策略的注释
（2） RetentionPolicy.CLASS: 编译器将把注解记录在 class 文件中. 当运行 Java 程序时, JVM 不会保留注解。这是默认值
（3）RetentionPolicy.RUNTIME:编译器将把注解记录在 class 文件中. 当运行 Java 程序时, JVM 会保留注解. 程序可以通过反射获取该注解
3、异常
-
异常介绍
（1）基本概念Java语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常)
（2）异常事件可分为两大类：Error(错误)和Exception
（3）Error(错误)：Java虚拟机无法解决的严重问题。如:JVM系统内部错误、资源耗尽等严重情况。比如:StackOverflowError[栈溢出]和OOM(out of memory)，Error 是严重错误，程序会崩。
（4）Exception：其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如空指针访问，试图读取不存在的文件，网络连接中断等等，
（5）Exception 分为两大类：运行时异常 [程序运行时，发生的异常] 和编译时异常 [编程时，编译器检查出的异常]。 -
异常体系图一览
-
异常体系图
-
小结
（1）异常分为两大类，运行时异常和编译时异常
（2）运行时异常，编译器检查不出来。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常
（3）对于运行时异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响
（4）编译时异常，是编译器要求必须处置的异常。
- 常见的运行时异常
-
NullPointerException 空指针异常
当应用程序试图在需要对象的地方使用 null 时，抛出该异常
-
ArithmeticException 数学运算异常
当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例
-
ArrayIndexOutOfBoundsException 数组下标越界异常
用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引
-
ClassCastException 类型转换异常
当试图将对象强制转换为不是实例的子类时，抛出该异常
-
NumberFormatException 数字格式不正确异常[]
当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常 => 使用异常我们可以确保输入是满足条件数字.
-
常见的编译异常
（1）SQLException //操作数据库时，查询表可能发生异常
（2）IOException //操作文件时，发生的异常
（3）FileNotFoundException //当操作一个不存在的文件时，发生异常
（4）ClassNotFoundException //加载类，而该类不存在时，异常
（5）EOFException // 操作文件，到文件末尾，发生异常
（6）legalArguementException //参数异常 -
异常处理
（1）异常处理就是当异常发生时，对异常处理的方式
（2）异常处理的方式：try-catch-finally和throws
（3）try-catch-finally程序员在代码中捕获发生的异常，自行处理
（4）throws将发生的异常抛出，交给调用者(方法)来处理，最顶级的处理者就是JVM
-
try-catch 异常处理
1)如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块
2)如果异常没有发生，则顺序执行try的代码块，不会进入到catch
3)如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)则使用finally {}，finally{}必须执行
4)可以有多个catch语句，捕获不同的异常(进行不同的业务处理)，要求父类异常在后，子类异常在前，如果发生异常，只会匹配一个catch
5)可以进行 try-finally 配合使用,这种用法相当于没有捕获异常（没有处理异常），因此程序会直接崩掉/退出。应用场景，就是执行一段代码，不管是否发生异常，都必须执行某个业务逻辑public class TryCatchDetail02 { public static void main(String[] args) { try { Person person = new Person(); person = null; 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 { } } } class Person { private String name = "jack"; public String getName() { return name; } } -
throws 异常处理
-
基本介绍
1)如果一个方法(中的语句执行时)可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。
2)在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。 -
注意事项和使用细节
1)对于编译异常，程序中必须处理，比如 try-catch 或者 throws
2)对于运行时异常，程序中如果没有处理，默认就是throws的方式处理
3)子类重写父类的方法时，对抛出异常的规定:子类重写的方法，所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常的类型的子类型
4)在throws 过程中，如果有方法 try-catch，就相当于处理异常，就可以不必throws
5)编译异常没有默认处理，必须显示处理public static void f1() throws FileNotFoundException { //1. 因为 f3() 方法抛出的是一个编译异常 //2. 即这时，就要 f1() 必须处理这个编译异常 //3. 在 f1() 中，要么 try-catch-finally ,或者继续 throws 这个编译异常 //4. 如果是运行异常，就有默认处理——throws，可以不用去显示处理 f3(); // 抛出编译异常 } public static void f3() throws FileNotFoundException { FileInputStream fis = new FileInputStream("d://aa.txt"); }
- 自定义异常
-
基本概念
当程序中出现了某些“错误”，但该错误信息并没有在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("你的年龄范围正确."); } } class AgeException extends RuntimeException { public AgeException(String message) {//构造器 super(message); } }
- throw 和 throws 的区别
729
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
