注解 & 异常 & 枚举 & 泛型-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.try\catch 中 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;
}
