生命不息，学习不止，对一切都要维持敬畏之心。
若有不正之处，请谅解和批评指正，不胜感激。

1.枚举

1.1 枚举概述

枚举是JDK1.5新增的引用数据类型，和类，接口是一个级别的，定义枚举的关键字为enum。

java.lang.Enum类，是所有枚举的父类。

枚举的本质就是一个类的多个对象。

1.2 枚举的定义

• 格式：public enmu 枚举名{}
• 枚举常量定义：
  • 枚举中的常量名字大写，多个常量之间逗号分开，最后一个常量可以写分号，也可以不写。每一个常量，都表示这个类的对象。修饰符为public static final。
  • 枚举中有默认的无参数的private修饰的构造方法，如果手写构造方法，也必须是私有修饰的。而且构造方法必须写在常量的后面，这时最后一个常量就必须要写分号。

    public enum  Color {
    //枚举的静态常量
    RED,GREEN,YELLOW
    }

    public enum Color{
    //枚举静态常量，直接为变量color赋值
    RED("红色"),GREEN("绿色"),YELLOW("黄色");
    private String color;
    priate Color(String color){
        this.color = color ;
    }
    //省略get/set
    }

1.3 枚举的使用

由于枚举的常量为静态修饰可以直接枚举名.调用

public static void main(String[] args){
    MyEnum myEnum = MyEnum.GREEN;
    System.out.println(myEnum);
    System.out.println(myEnum.getName());
}

2.注解

5.1 注解概述

定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

作用分类：

• 编写文档：通过代码里标识的注解生成文档【例如，生成文档doc文档】
• 代码分析：通过代码里标识的注解对代码进行分析【例如，注解的反射】
• 编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【例如，Override】

常见注解

1. @author：用来标识作者名
2. @version：用于标识对象的版本号，适用范围：文件、类、方法。
3. @Override ：用来修饰方法声明，告诉编译器该方法是重写父类中的方法，如果父类不存在该方法，则编译失败。

   5.2 自定义注解

定义格式

元注解
public @interface 注解名称{
    属性列表;
}

注解本质上就是一个接口，该接口默认继承Annotation接口。

public @interface MyAnno extends java.lang.annotation.Annotation {}

任何一个注解，都默认的继承Annotation接口。

注解的属性

1. 属性的作用

   • 可以让用户在使用注解时传递参数，让注解的功能更加强大。

2. 属性的格式

   • 格式1：数据类型 属性名();
   • 格式2：数据类型 属性名() default 默认值;

3. 属性定义示例

   public @interface Student {
     String name(); // 姓名
     int age() default 18; // 年龄
     String gender() default "男"; // 性别
   } 
   // 该注解就有了三个属性：name，age，gender

4. 属性适用的数据类型

   • 八种基本数据类型（int,float,boolean,byte,double,char,long,short)。
   • String类型，Class类型，枚举类型，注解类型。
   • 以上所有类型的一维数组。

5.3 使用自定义注解

在程序中使用(解析)注解的步骤（获取注解中定义的属性值）：

1. 获取注解定义的位置的对象 （Class，Method,Field）
2. 获取指定的注解 getAnnotation(Class)
3. 调用注解中的抽象方法获取配置的属性值

使用格式:

​ @注解名(属性名=属性值,属性名=属性值,属性名=属性值...)

定义注解

1. 定义一个注解：Book
   • 包含属性：String value() 书名
   • 包含属性：double price() 价格，默认值为 100
   • 包含属性：String[] authors() 多位作者
2. 代码实现

public @interface Book {
    // 书名
    String value();
    // 价格
    double price() default 100;
    // 多位作者
    String[] authors();
}

使用注解

public class BookShelf {

    @Book(value = "西游记",price = 998,authors = {"吴承恩","白求恩"})
    public void showBook(){

    }
}

使用注意事项

• 如果属性有默认值，则使用注解的时候，这个属性可以不用赋值。
• 如果属性没有默认值，那么在使用注解时一定要给属性赋值。

特殊属性value

1. 当注解中只有一个属性且名称是value，在使用注解时给value属性赋值可以直接给属性值，无论value是单值元素还是数组类型。

   // 定义注解Book
   public @interface Book {
       // 书名
       String value();
   }
   
   // 使用注解Book
   public class BookShelf {
       @Book("西游记")
       public void showBook(){
   
       }
   }
   或
   public class BookShelf {
       @Book(value="西游记")
       public void showBook(){
   
       }
   }

2. 如果注解中除了value属性还有其他属性，且至少有一个属性没有默认值，则在使用注解给属性赋值时，value属性名不能省略。

   // 定义注解Book
   public @interface Book {
       // 书名
       String value();
       // 价格
       double price() default 100;
       // 多位作者
       String[] authors();
   }
   // 使用Book注解：正确方式
   @Book(value="红楼梦",authors = "曹雪芹")
   public class BookShelf {
     // 使用Book注解：正确方式
       @Book(value="西游记",authors = {"吴承恩","白求恩"})
       public void showBook(){
   
       }
   }
   
   // 使用Book注解：错误方式
   public class BookShelf {
       @Book("西游记",authors = {"吴承恩","白求恩"})
       public void showBook(){
   
       }
   }
   // 此时value属性名不能省略了。

5.4 注解之元注解

默认情况下，注解可以用在任何地方，比如类，成员方法，构造方法，成员变量等地方。如果要限制注解的使用位置怎么办？那就要学习一个新的知识点：元注解。

• @Target
• @Retention

元注解之@Target

• 作用：指明此注解用在哪个位置，如果不写默认是任何地方都可以使用。
  • 可选的参数值在枚举类ElemenetType中包括：

 TYPE： 用在类,接口上
 FIELD：用在成员变量上
 METHOD： 用在方法上
 PARAMETER：用在参数上
 CONSTRUCTOR：用在构造方法上
 LOCAL_VARIABLE：用在局部变量上

元注解之@Retention

• 作用：定义该注解的生命周期(有效范围)。
  • 可选的参数值在枚举类型RetentionPolicy中包括

SOURCE：注解只存在于Java源代码中，编译生成的字节码文件中就不存在了。
CLASS：注解存在于Java源代码、编译以后的字节码文件中，运行的时候内存中没有，默认值。
RUNTIME：注解存在于Java源代码中、编译以后的字节码文件中、运行时内存中，程序可以通过反射获取该注解。

5.5 注解解析

通过Java技术获取注解数据的过程则称为注解解析。

与注解解析相关的接口

• Anontation：所有注解类型的公共接口，类似所有类的父类是Object。
• AnnotatedElement：定义了与注解解析相关的方法，常用方法以下四个：

boolean isAnnotationPresent(Class annotationClass); 判断当前对象是否有指定的注解，有则返回true，否则返回false。
T getAnnotation(Class<T> annotationClass);  获得当前对象上指定的注解对象。
Annotation[] getAnnotations(); 获得当前对象及其从父类上继承的所有的注解对象。
Annotation[] getDeclaredAnnotations();获得当前对象上所有的注解对象，不包括父类的。

获取注解数据的原理

注解作用在那个成员上，就通过反射获得该成员的对象来得到它的注解。

• 如注解作用在方法上，就通过方法(Method)对象得到它的注解。

   // 得到方法对象
   Method method = clazz.getDeclaredMethod("方法名"); 
   // 根据注解名得到方法上的注解对象
   Book book = method.getAnnotation(Book.class); 

• 如注解作用在类上，就通过Class对象得到它的注解。

  // 获得Class对象
  Class c = 类名.class;
  // 根据注解的Class获得使用在类上的注解对象
  Book book = c.getAnnotation(Book.class);

使用反射获取注解的数据

3.反射

• 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
• 反射：将java代码的各个组成部分封装为其他对象，可以在程序运行过程中操作这些对象，这就是java的反射机制，如下图。
• 反射的好处：
  1. 可以在程序运行过程中，操作这些对象。
  2. 可以解耦，提高程序的可扩展性。
     

4.2 获取Class对象的方式

Student类：

public class Student {
    private String name;
    private int age;
    public Student(){
    }
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public void study(){
        System.out.println("学生在学习");
    }

    public void eat(String s,double d){
        System.out.println("带参数方法:"+s+"::"+d);
    }
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

获取Student类的class文件对象：

public static void main(String[] args)throws Exception{
    Student student = new Student(); 
    Class c1 = student.getClass();
    System.out.println(c1);
    Class c2 = Student.class;
    System.out.println(c2);
    Class c3 = Class.forName("com.doit.communication.Student");
    System.out.println(c3);
}

4.3 反射获取构造方法

Class类中与Constructor相关方法

1. Constructor[] getConstructors() 
       获取所有的public修饰的构造方法

2. Constructor getConstructor(Class... parameterTypes) 
    根据参数类型获取构造方法对象，只能获得public修饰的构造方法。
    如果不存在对应的构造方法，则会抛出 java.lang.NoSuchMethodException 异常。
    参数是可变参数,调用此方法时,可以不写参数,获取的空参构造
                可以写参数,给定的参数必须是Class对象
                    比如:
                        参数 String name,int age
                        调用此方法: String.class,int.class 

Constructor类中常用方法

1. T newInstance(Object... initargs) 
      根据指定参数创建对象。
2. T newInstance()
      空参构造方法创建对象。

获取无参数构造方法

public static void main(String[] args)throws Exception{
    Class cla = Class.forName("com.doit.communication.Student");
    //获取无参数构造方法
    Constructor constructor = cla.getConstructor();
    //运行构造方法
    Object object =  constructor.newInstance();
    System.out.println(object);
}

获取有参数构造方法

public static void main(String[] args)throws Throwable{
    Class cla = Class.forName("com.doit.communication.Student");
    //获取有参数构造方法
    Constructor constructor = cla.getConstructor(String.class, int.class);
    //运行构造方法，传递实际参数
    Object object = constructor.newInstance("张三",20);
    System.out.println(object);

}

4.4 反射获取构造方法的简单方式

Class类中定义了方法 T newInstance()，可以直接运行获取到的构造方法。

要求：被反射的类中必须有public权限的无参数构造方法。

public static void main(String[] args)throws Throwable{
    Class cla = Class.forName("com.doit.communication.Student");
    Object object = cla.newInstance();
    System.out.println(object);
}

4.5 反射成员方法执行

Class类中与Method相关方法

1. Method[] getMethods()
      获取所有的public修饰的成员方法，包括父类中。

2. Method getMethod("方法名", 方法的参数类型... 类型) 
    根据方法名和参数类型获得一个方法对象，只能是获取public修饰的    

Method类中常用方法

Object invoke(Object obj, Object... args) 
    返回值Object，表示调用方法后，该方法的返回值
      根据参数args调用对象obj的该成员方法    
      如果obj=null，则表示该方法是静态方法

反射获取无参数方法

public static void main(String[] args)throws Throwable{
    Class cla = Class.forName("com.doit.communication.Student");
    Object object = cla.newInstance();
    //获取study方法
    Method method = cla.getMethod("study");
    //执行方法，传递对象
    method.invoke(object);
}

反射获取有参数方法

public static void main(String[] args)throws Throwable{
    Class cla = Class.forName("com.doit.communication.Student");
    Object object = cla.newInstance();
    //获取有参数的方法eat
    Method method = cla.getMethod("eat",String.class,double.class);
    //调用eat方法，传递实际参数
    method.invoke(object,"吃饭",9.9);
}

4.6 反射案例

需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

实现：

1. 配置文件
2. 反射

步骤：

1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2. 在程序中加载读取配置文件
3. 使用反射技术来加载类文件进内存
4. 创建对象
5. 执行方法

注意：需要将配置文件放在src目录下，放在src目录下的任何文件，都会被编译到classes目录下，这样做的目的是为了让配置文件跟随编译后的class文件一起，因为交付用户使用的是class文件，而不是源代码。

如何读取src目录下的文件：使用类的加载器ClassLoader类的方法 :

• InputStream getResourceAsStream(String name)
  • 此方法返回输入流，该流从类目录下读取文件
  • 参数传递文件名

properties文件：

className=com.doit.domain.Student
methodName=sleep

Student类：

package com.doit.domain;

public class Student {
    public void sleep(){
        System.out.println("sleep...");
    }
}

RefectTest测试类：

public static void main(String[] args)throws Throwable{
    //获取RefectTest类的加载器
    ClassLoader classLoader = RefectTest.class.getClassLoader();
    //加载器获取输入流，读取pro.properties文件
    InputStream inputStream = classLoader.getResourceAsStream("pro.properties");
    Properties properties = new Properties();
    //集合IO关联
    properties.load(inputStream);
    //获取集合中的键值对，类名
    String className = properties.getProperty("className");
    //获取集合中的键值对，方法名
    String methodName = properties.getProperty("methodName");
    //反射获取指定类的class文件对象
    Class cla = Class.forName(className);
    Object object = cla.newInstance();
    //获取指定的方法
    Method method = cla.getMethod(methodName);
    //运行方法
    method.invoke(object);
}