注解 & 异常 & 枚举 & 泛型-code

注解（缺应用，填坑！）

① 内置的常规注解

1) @Deprecated：标注已过时的注解

2) @Override：限定方法重写，检查当前方法是否是重写的父类方法

3) @SuppressWarnings：忽略警告，可以作用于类的任何位置

元注解：

① @Documented：其实可要可不要，是用于表明是否会出现在DOC注释里的

② @Target：可以没有，如果使用他，配合ElementType枚举类型，可以定义注解作用的地方

③ @Retention：可以没有，如果有，可以用它来定义注解的生命周期

元注解：用于注解注解的注解

① @inherited 注解继承

1) ElementType：用于提供注解的类型

2) RetentionPolicy：用于说明当前注解的声明周期

--注解想要通过反射获取到，必须是RetentionPolicy.RUNTIME类型

② @Documented：其实可要可不要，是用于表明是否会出现在DOC注释里的

③ @Target：可以没有，如果使用他，配合ElementType枚举类型，可以定义注解作用的地方

④ @Retention：可以没有，如果有，可以用它来定义注解的生命周期

？？自定义注解放这

@testAnn()
     public Person() {
         super();
         // TODO Auto-generated constructor stub
     }
？？？传参目的？？？   
     @testAnn(value1 = "",value2 = "")
//    @testAnn(value1 = "")
     public Person(int id) {
         super();
         this.id = id;
     }

//三种常规注解

@SuppressWarnings("unused")
     void test() {
         int i;
         int j;
     }
    
     @Deprecated
     public String myString() {
         return "Person["+id+"]";
     }
     @Override
     public String toString() {
         return "Person["+id+"]";
     }

//自定义注解+元注解组合使用

@Documented//其实可要可不要，是用于表面是否会出现在DOC注释里的
@Target(ElementType.CONSTRUCTOR)//
@Retention(RetentionPolicy.RUNTIME)//
@interface testAnn{
     //可以添加一个类似于抽象方法
     String value1() default "";
     String value2() default "";
}

异常：尽量不要让虚拟机JVM处理！

java中的错误大致可以分为:
     编译时错误：语法错误
     运行时错误

异常：Java提供的专门用于处理运行时错误的一种机制，具体步骤：
     当程序出现错误时，会创建一个异常类对象，该对象封装了异常的信息，并提交给系统，由系统转交给能处理该异常的代码进行处理。
     异常分为两类：包括Error和Exception。
         Erro指系统错误，由JVM生成，我们编写的程序无法处理。
         Exception指程序运行期间出现的错误，我们编写的程序可以对其进行处理。

Throwable 父类
         -Error,系统错误，程序无法解决
         -Exception，指程序运行时出现的错误，程序可以处理，所有的异常类都存放在java.lang包中。

Error常见的子类包括：VirtualMachineError、AWTError、IOError
         Exception常见的子类包括：IOException和RuntimeException.
         IOException存放在java.io包
             包括：FileLockInterruptionException、FileNotFoundException、FileException，
             这些异常通常都是在处理IO流进行文件传输时发生的错误。
         RuntimeException存放在java.lang包
             包括：
                 ArithmeticException：表示数学运算异常
                 ClassNotFoundException:表示类未定义异常
                 IllegalArgumentException:表示参数格式错误异常
                 ArrayIndexOutOfBoundsException:表示数组下标越界异常
                 NullPointerException:空指针异常
                 NoSuchMethodException:方法未定义
                 NmberFormatException:表示将其他数据类型转为数值类型不匹配异常

大原则:无论如何，异常最终一定会（要）被处理。

捕获异常的原则：  
     如果方法调用的是RuntimeException及子类，那么在调用方法的时候，可以不用手动try...catch
      如果方法调用的是Exception及子类，那么在调用方法的时候，必须手动捕获：try...catch

捕获异常——捕获指定的异常。

catch的优先级高于return——结束catch的唯一方法：System.exit(1)
finally优先级最高？

checked异常必须被处理，捕获或者自动抛出
         ---中途捕获了（try...catch），就算是处理完毕，后续调用者无须关注该异常
         ---如果throws 自动抛，后续方法都需要自动抛

注意：

1.当发生异常之后，在异常之后的程序将不再执行

（**）2.通过捕获异常，可以让程序继续执行下去

3.捕获异常，只能捕获指定异常

4.finally:无论是否发生异常，都一定会执行，其优先级非常高

5.无论如何，异常最终一定会（要）被处理

工程应用中：

自定义异常：经常使用throw new Exception(String);

---抛出异常之后，程序直接停了。

---try…catch 捕获后，不影响程序后续执行。

//捕获异常之后正常执行

try {
             //int i = 1/0;
             int j = 1/2;
             System.out.println("try");
             return;
         } catch (Exception e) {
             // TODO: handle exception
             //System.exit(1);
             System.out.println("catch module");
             //return;//return 是finally执行之后
             //System.out.println("return");
         }finally {
             System.out.println("finally");
         }
         System.out.println("main 异常之后代码块");

//if、catch代码块中都有return语句，finally执行完之后，会直接return。 异常之后的代码块不执行。【前提：return 只能出现在 try 跟 catch中的一处】

//自定义异常，根据业务需求自定义

public class MyException extends Exception{
     public MyException(String message) {
         super(message);
     }
}

try-catch- finally块中,finally块唯一不执行的情况是什么？

1.try之前出现异常，且未处理（未捕捉异常）

2.trycatch 中 system.exit();

throw 和 throws 的区别：

throw	throws
生成并抛出异常	声明方法内抛出了异常
位于方法体内部，可作为单独语句使用	必须跟在方法参数列表后面，不能单独使用
抛出一个异常对象，且只能是一个	声明抛出异常类型，可以跟多个异常

枚举:当处理离散值的时候，我们通常希望有一个类似于布尔类型这样的数据类型给我们使用，而实际情况是，如果用标识符定义，不仅不安全，也会给程序的阅读造成困难

1.使用switch：使用枚举作为常量比较

2.每次调用都是一次构造。

//定义枚举类

public enum SEX_PERSON {
    //Enum;
    MALE(0){
        public boolean isValue0(){
            return true;
        }
        public boolean isValue1(){
            return false;
        }
    },FEMALE(1){
        public boolean isValue0(){
            return false;
        }
        public boolean isValue1(){
            return true;
        }
    };
    private int i;
    SEX_PERSON(int i) {
        this.i = i;
    }
    public int getValue(){
        return this.i;
    }
    /*public void setValue(int i){
        this.i = i;
    }*/
    public boolean isValue0(){
        return true;
    }
    public boolean isValue1(){
        return true;
    }
}

//使用方式

System.out.println(SEX_PERSON.FEMALE.isValue0());
System.out.println(SEX_PERSON.FEMALE.isValue1());
System.out.println(SEX_PERSON.MALE.isValue0());
System.out.println(SEX_PERSON.MALE.isValue1());

泛型：一般是用于容器

解决集合数据不统一的方案：强制要求所有数据统一

泛型：参数化类型

泛型类：泛型接口，泛型方法

泛型形参：定义类或者接口的时候定义

表示形式:T type;E:element;I:item

泛型通配符：?

   <? extends 父类>

方法泛型，是只属于方法的泛型，只作用于该方法的作用域内，给什么，就是什么

应用原则：

1. 类型声明和实现类上，都加上泛型

2. 添加了泛型的容器，只能添加该类型，或者是其子类和接口实现类

--- 如果是基本数据类型，只能使用该类型对应的包装类

---实体类的属性定义，尽可能使用包装类

原理：

泛型不能使用基本数据类型。JVM类型擦除问题。？？--类型擦除后变成Object对象，Object对象不能存放基本数据类型。编译器阶段会报错。

//泛型接口
interface MyMap<P,E> {
    public void put(P p,E e);
    public E get(P p,E e);
}
abstract class MyMap1<T> {
    public abstract void put(T t);
}

//泛型类————实现了接口或者继承了抽象类，也必须同时定义泛型形参
class MyHashMap<P,E,T> extends MyMap1<T> implements MyMap<P,E>{
    Map<P,E> map = new HashMap<>();
    @Override
    public void put(P p, E e) {
        map.put(p,e);
    }

    @Override
    public E get(P p, E e) {
        return (E)map.get(p);
    }

    @Override
    public void put(T t) {
    }
}

//通配符，泛型实参

static void test(List<? extends Number> list){
    //System.out.println();
    //List<int> list1 = new ArrayList<int>();
    List<Integer> list2 = new ArrayList<Integer>();
}

//方法泛型

public<A,B,C> A test(A a){
        return a;
    }