关于Java枚举，注解，还有异常的一些简单的介绍应用

枚举：

enum State{
    UNUSE, USING, USED;

    private State(){
        System.out.println("State constrator");
    }
}

/**
 * 设计模式：单例模式
 */
/*class Singleton{
    private static Singleton single = null;
    public static Singleton getInstance(){
        if(single == null){
            single = new Singleton();
        }
        return single;
    }
    private Singleton(){
        System.out.println("Singleton constrator!");
    }
}*/
enum Singleton{
    single;
    private Singleton(){
        System.out.println("Singleton constrator!");
    }
}

class Test{
    private int filed;
    private Test(){
        System.out.println("Test()");
    }
    public void func(){
        System.out.println("func()");
    }
}
/**
 * 描述: 枚举

 * @Date 2019/6/16
 */
public class EnumTestUnit {
    public static void main(String[] args) throws Exception{
        /*
        * 类加载器  =》  Singleton.class  =》   Class对象
        * 成员变量 - 属性 field
        * 构造函数 - 初始化 constructor
        * 成员方法 - 方法  method
        * */
        //Class c = Singleton.class;
        //Class tc = Test.class;
        /*Constructor[] cons = tc.getConstructors();
        for (int i = 0; i < cons.length; i++) {
            System.out.println(cons[i].getName());
        }*/
        /*try {
            Constructor c = tc.getDeclaredConstructor(null);
            // 通过反射来生成对象   new Test()
            c.setAccessible(true);
            Test t1 = (Test)c.newInstance(); // 通过Constructor间接调用构造函数生成对象
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }*/

        //Field f = tc.getField("filed");


        Singleton s1 = Singleton.single;
        Singleton s2 = Singleton.single;
        Singleton s3 = Singleton.single;
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);

        /**
         * 静态内部类 =》 解决的安全性，指的是解决了线程安全特性
         * JVM安全特性
         *
         * 枚举的认识：
         * 什么时候使用枚举？
         * 枚举经常可以和final定义的常量互换，用来定义有限的值的列举，不能随意
         * 产生新的对象
         *
         * 枚举的构造函数默认就是private的，不能通过new来产生新的枚举对象
         *
         * 枚举通过反射产生对象，已经在jdk中防止了，所以enum是JVM安全的
         *
         * 枚举的一个经典应用：非常简单的代码，就可以实现线程安全的，
         * JVM安全的单例模式
         *
         * 反射的第一个问题：你怎么理解Java的反射？
         * 直接访问类的静态成员和类对象的实例成员和成员方法
         * 先获取该类型的Class对象，然后通过Class对象得到相应的Constructor
         * method,field，然后简介访问类的静态成员和类对象的实例成员和成员方法
         * setAccessible(true)简介访问了被private私有化的成员

注解

/*abstract class Animal{
    public abstract void bark();
}

class Cat extends Animal{
    @Override // 注解，本身就是有信息提升作用，信息配置作用 JDK1.5  xml
    public void bark() {

    }
}*/

import java.lang.annotation.*;
import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * 定义注解  注解默认只存在与编译阶段，不会保留到运行阶段  注解的信息，默认不会添加到
 * 类型.class文件当中去
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface Author{
    String value()default ""; // value称作注解参数的名字，返回值String是value名字的类
    String[] name();
    String date();
}

/**
 * 功能类
 */
//@Author(value="加法操作", name={"施磊", "徐老师"}, date="2019-6-16")
class Function{
    @Author(value="加法操作", name={"施磊", "徐老师"}, date="2019-6-16")
    public int sum(int a, int b){
        return a + b;
    }

    @Author(value="减法操作", name="高明明", date="2019-6-16")
    public int minor(int a, int b){
        return a - b;
    }
}

/**
 * 异常，枚举，反射，注解
 *
 * 描述: 注解 注解都是通过反射来访问的
 * @Date 2019/6/16
 */
public class AnnotationTestUnit {
    public static void main(String[] args) {
        Class c = Function.class;
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) { // 通过反射获取Function的成员方法
            // 再通过方法访问方法的注解信息了
            Annotation[] anno = method.getDeclaredAnnotations();
            for (Annotation annotation : anno) {
                if(annotation instanceof Author){
                    System.out.print(method.getName() + " ");
                    System.out.println("方法功能:" + ((Author) annotation).value());
                    System.out.println("方法作者:" + Arrays.toString(((Author) annotation).name()));
                    System.out.println("方法开发日期:" + ((Author) annotation).date());
                }
            }
        }
    }
}

异常：

/**
 * try ：把有可能发生异常的代码括起来，如果代码正常，那么try块里面的所有代码都执行完成，跳过
 * catch，继续向下运行；
 *       如果代码运行发生异常，try块里面剩下的代码就不执行了，直接到相应的catch块处理异常，
 *       处理完异常，代码继续向下运行。
 *
 * catch：捕获相应类型异常对象的，catch块可以出现多个，catch块运行完，代码继续向下正常执行
 *
 * throw: 抛出异常
 *
 * throws: 声明当前函数会抛出相应类型的异常，但是当前函数是不会处理异常的，异常由该函数的调用
 * 方来处理
 *
 * 描述:Java异常
 * 1.简述一下Java的异常继承结构
 * 2.Java的异常都包含哪些？你知道的常见的异常
 * 3.异常所用的关键字
 *
 *
 *                      Object
 *                        |
 *                     Throwable
 *         |                              |
         Error（JVM抛出的）          Exception(Java应用抛出的)
        程序只能结束，无法挽回     程序可以处理异常，让代码继续往下执行
        StackOverflowError                          |
        OutOfMemoryError      FileNotFoundException(可检测异常)     ArrayIndexOutOfBounds(不可检测异常)
                                     IoException（可检测异常）       NullPointerException
 * @Date 2019/6/16
 */
public class ExceptionTestUnit {
    public static void main(String[] args) throws Exception{
        // ArrayIndexOutOfBounds   NullPointerException    OutOfMemory堆不够用了
        // StackOverflowError


        func();

        /*try{
            div(20, 0);
            System.out.println("div成功了...");
        } catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e.getMessage());
        } catch(RuntimeException e){
            System.out.println(e.getMessage());
        }

        System.out.println("我正在正常运行...");*/
    }

    private static void func() throws Exception{
        FileReader f1 = new FileReader("data.txt");
        FileReader f2 = new FileReader("data.txt");
        FileReader f3 = new FileReader("data.txt");
        FileReader f4 = new FileReader("data.txt");
        FileReader f5 = new FileReader("data.txt");
        FileReader f6 = new FileReader("data.txt");
    }

    private static int div(int i, int j) {
        if(j == 0){
            throw new RuntimeException("被除数不能为0!");
        }

        return i/j;
    }
}