8.枚举_注解_异常处理

枚举_注解_异常处理

1.枚举

枚举:是一组常量的集合,可以理解为枚举属于一种特殊的类,里面只包含一组有限的特定的对象。
实现方式:
1.自定义类实现枚举
2.使用enum关键字实现枚举
自定义枚举案例:

public class Test{
    public static void main(String[]args){
        //1.将构造器私有化,目的防止直接new
        //2.去掉setxxx方法
        //3.在season内部，直接创建固定的对象
        //4.优化,可以加入final修饰符
    System.out.println(Season.s1);
    }
}
class Season{
    private String name;
    private String desc;
          //下面定义了4个对象
        public static final Season s1 = new Season("春天","温暖");
        public static final Season s2 = new Season("夏天","炎热");
        public static final Season s3 = new Season("秋天","凉爽");
        public static final Season s4 = new Season("冬天","寒冷");
    private Season(String name,String desc){
        this.name=name;
        this.desc=desc;
    }
    public String getName(){
        return name;
    }
    public String getDesc(){
        return desc;
    }
}

enum关键字实现枚举案例：

public class Test2{
    public static void main(String[]args){
    System.out.println(Season2.s1);
    }
}
enum Season2{
          //下面定义了4个对象
          //如果使用了enum来实现枚举类
          //1.使用关键字enum替代class
          //2.s1("春天","温暖");//常量名(实参列表)
          //3.如果使用enum来实现枚举,要求将定义常量对象,写在前面
          s1("春天","温暖");
    private String name;
    private String desc;
    private Season2(String name,String desc){
        this.name=name;
        this.desc=desc;
    }
    public String getName(){
        return name;
    }
    public String getDesc(){
        return desc;
    }
}

注意事项:
1.枚举对象必须放在枚举类的行首

1.1enum枚举常用方法

说明:使用关键字enum时,会隐式继承Enum类这样我们就可以使用Enum类的相关方法。
enum常用方法的使用:
1.toString:Enum类已经重写过了,返回的是当前对象名，子类可以重写该方法，用于返回对象的属性信息
2.name:返回当前对象名(常量名)，子类中不能重写
3.ordinal:返回当前对象的位置号,默认从0开始
4.values:返回当前枚举类的所有常量
5.valueOf:将字符串转换成枚举对象,要求字符串必须为已有的常量名,否则报异常
6.compareTo:比较两个枚举常量，比较的就是编号！！
举例:

public class EnumMethod{
    public static void main(String[]args){
        //使用season2枚举类,来演示各种方法
    	Season2 s1 = Season2.s1;
    	//输出枚举对象的名字
    	System.out.println(s1.name());
    	//ordinal()输出的是该枚举对象的次序/编号,从0开始
    	System.out.println(s1.ordinal());
    	//从反编译可以看出values方法,返回Season2[]
    	//含有定义的所有枚举对象
    	Season2[] values = Season2.values();
    	for(Season2 season:values) {
    		System.out.println(season);
    	}
    	//valueOf
    	Season2 autumn1 = Season2.valueOf("s3");
    	System.out.println(autumn1);
    	//compareTo,比较s1和s2的编号,如果=0,则相等,<0,则代表前面的编号小于后面的编号,>1,则前面的编号大于后面的编号
    	System.out.println(Season2.s1.compareTo(Season2.s2));
    }
}

细节:

1. 使用enum关键字后,就不能再继承其他类了,因为enum会隐式继承Enum
2. 枚举类和普通类一样，可以实现接口
   语法:

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

   2.注解

   2.1Override注解

   解释:使用Annotation时要在其前面增加@符号,并把该Annotation当成一个修饰符使用,用于修饰它支持的程序元素
   三个基本的Annotation:
   1.@Override:限定某个方法,是重写父类方法,该注解只能用于方法
   2.@Deprecated:用于表示某个程序元素(类,方法等)已过时
   3.@SuppressWarnings:抑制编译器警告

   3.异常处理

   例题:

   public class Exception01{
       public static void main(String[]args){
           int num1 = 10;
           int num2 = 0;
           //int res = num1/num2;
           //1.当程序执行到两数相除时，程序会报错因为被除数为0,而下面的输出语句不会被执行
           //2.JAVA设计者提供了一个叫异常处理机制来解决该问题
           //3.如果程序员,认为一段代码可能出现异常/问题,可以使用try-catch异常处理机制来解决,从而保证程序的健壮性。
           //4.如果进行异常处理,那么即使出现了异常,程序可以继续执行
           try{
               int res = num1/num2;
           } catch (Exceptopn e){
               System.out.println(e.getMessage());
           }
           
           System.out.println("程序继续运行");
   
       }
   }

   概念:java将程序执行中发生的不正常情况称为”异常”;
   执行过程中所发生的异常时间可分为两类:
   1.Error(错误):JAVA虚拟机无法解决的严重问题,比如栈溢出,Error是严重错误,程序会崩溃
   2.Exception:其他因变成错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行处理比如:空指针访问,试图读取不存在的文件,网络中断等等,Exception分为两大类:运行时异常[程序运行时,发生的异常]和编译时异常[编程时,编译器检查出的异常].
   了解异常体系图
   
   小结:
   1.异常分为两大类,运行时的异常和编译时的异常
   2.运行时异常,编译器不要求强制处置的异常,一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。
   3.对于运行时异常,可以不做处理,因为这类异常很普遍,若全处理可能会对程序的可读性和运行效率产生影响
   4.编译时异常,是编译器要求必须处置的异常
   五大运行时的异常:
   1.NullPointerException:空指针异常
   2.ArithmeticException:数学运算异常
   3.ArraylndexOutOfBoundsException:数组下标越界异常
   4.ClassCastException:类型转换异常
   5.NumberFormatException:数字格式不正确异常[]
   编译异常:
   1.SQLException:操作数据库时,查询表可能发生异常
   2.IOException:操作文件时,发生的异常
   3.FileNotFoundException:当操作一个不存在的文件时,异常
   4.ClassNotFoundException:加载类,而该类不存在时,发生异常
   5.EOFException:操作文件,到文件末尾,发生异常
   6.illegalArguementException:参数异常
   异常处理:
   定义:就是当异常发生时,对异常处理的方式
   异常处理的方式:
   1.try-catch-finally:程序员再代码中捕获发生的异常
   2.throws:将发生的异常抛出,交给调用者(方法)来处理,最顶级的处理者就是JVM
   案例:

   try{
       代码/可能有异常
   }catch(Exception e){
       //捕获到异常
       //1.当异常发生时
       //2.系统将异常封装成Exception对象e,传递给catch
       //3.得到异常对象后,程序员,自己处理
       //4.注意:如果没有发生异常catch块时不会执行的
   }finally{
       //1.不管try代码块是否有异常发生,始终要执行finally
       //2.所以,通常将释放资源的代码,放在finally
   }

   Throws处理机制图:
   

   3.1try-catch异常处理

   案例:

   public class TryCatchDetail02{
       public static void main(String[]args){
           //1.如果发生异常,则异常发生后面的代码不会执行,直接进入到catch块
           //2.如果异常没有发生,则顺序执行try的代码块,不会进入到catch
           //3.如果希望不管是否发生异常,都执行某段代码则可以使用finally语句块
           try{
               Person person = new Person();
               person=null;
               System.out.println(person.getName());
               int n1 = 10;
               int n2 = 0;
               int res = n1/n2;
               //1.如果try代码块有可能有多个异常
               //2.可以使用多个catch分别捕获不同的异常,响应处理
               //3.要求子类异常写在前面,父类异常写在后面
           } 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;
       public String getName(){
           return name;
       }
   }

   3.2throws异常

   含义:
   1.如果一个方法(中的语句执行时)可能生成某种异常,但不能确定如何处理这些异常,则此方法应显示地声明抛出异常,表明该方法将不对这些异常进行处理,而由该方法的调用者负责处理
   2.在方法声明中用throws语句可以声明抛出异常的列表,throws后面的异常类型可以是方法中产生的异常类型,也可以是它的父类
   例子:

   public class Throws01{
       public static void main(String[]args){
   
       }
       public void f2() throws Exception,(其他异常) {
           //创建了一个文件流对象
           //1.这里的异常是一个FileNotFoundException编译异常
           //2.使用前面讲过的try-catch-finally可以解决问题
           //3.使用throws,抛出异常,让调用f1方法的调用者(方法)来处理
           //4.throws后面的异常类型可以是方法中产生的异常类型,也可以是它的父类
           //5.throws 关键字后也可以是异常列表,即可抛出多个异常
           FileInputStream fis = new FileInputStream("d://aa.txt");
       }
   }

   注意事项:
   1.对于编译异常,程序必须处理,比如try-catch或throws
   2.对于运行时异常,程序中如果没有处理,默认就是throws的方式处理
   3.子类重写父类的方法时,对抛出异常的规定:子类重写的方法,所抛出的异常类型要么和父类抛出的异常一致,要么为父类抛出的异常类型的子类型
   4.在throws过程中,如果有方法try-catch,就相当于处理异常,就可以不必throws

   3.3自定义异常

   定义:
   当程序中出现了某些错误,但该错误信息没有在Throwable子类中描述处理,这个时候可以自己设计异常类,用于描述该错误信息
   步骤:
   1.定义类:自定义异常类名(程序员自己写)继承Exception或RuntimeException
   2.如果继承Exception则属于编译异常
   3.如果继承RuntimeException,属于隐形异常(一般来说继承这个较多)

   3.4throw和throws的区别

   	意义	位置	后面跟的东西
   throws	异常处理的一种方式	发方法声明处	异常类型
   throw	手动生成异常对象的关键字	方法体中	异常对象