一、反射

1、获得Class对象

第一种: Class c = Class.forName(“完整的类名带包名”);
第二种: Class c = 对象.getClass();
第三种: Class c = 任何类型.class;
注意：Class.forName是一个静态方法。

如果你只是希望一个类的静态代码块执行，其它代码一律不执行，你可以使用:Class.forName(“完整类名”); 这个方法的执行会导致类加载，类加载时，静态代码块执行。

2、判断是否为某个类的实例

一般地，我们用 instanceof 关键字来判断是否为某个类的实例。同时我们也可以借助反射中 Class 对象的 isInstance() 方法来判断是否为某个类的实例，它是一个 native 方法：
public native boolean isInstance(Object obj);

3、创建实例

通过反射来生成对象主要有两种方式。

使用Class对象的newInstance()方法来创建Class对象对应类的实例。
```
Class<?> c = String.class;
Object str = c.newInstance();
```
注意：重点是:new Instance()调用的是无参构造，必须保证无参构造是存在的!

先通过Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建实例。这种方法可以用指定的构造器构造类的实例。

//获取String所对应的Class对象
Class<?> c = String.class;
//获取String类带一个String参数的构造器
Constructor constructor = c.getConstructor(String.class);
//根据构造器创建实例
Object obj = constructor.newInstance("23333");
System.out.println(obj);

4.获取方法

获取某个Class对象的方法集合，主要有以下几个方法：

getDeclaredMethods 方法返回类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
```
  public Method[] getDeclaredMethods() throws SecurityException
```
getMethods 方法返回某个类的所有公用（public）方法，包括其继承类的公用方法。
```
public Method[] getMethods() throws SecurityException
```

getMethod 方法返回一个特定的方法，其中第一个参数为方法名称，后面的参数为方法的参数对应Class的对象。

public Method getMethod(String name, Class<?>... parameterTypes)

只是这样描述的话可能难以理解，我们用例子来理解这三个方法：

package org.ScZyhSoft.common;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test1 {
  public static void test() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
          Class<?> c = methodClass.class;
          Object object = c.newInstance();
          Method[] methods = c.getMethods();
          Method[] declaredMethods = c.getDeclaredMethods();
          //获取methodClass类的add方法
          Method method = c.getMethod("add", int.class, int.class);
          //getMethods()方法获取的所有方法
          System.out.println("getMethods获取的方法：");
          for(Method m:methods)
              System.out.println(m);
          //getDeclaredMethods()方法获取的所有方法
          System.out.println("getDeclaredMethods获取的方法：");
          for(Method m:declaredMethods)
              System.out.println(m);
      }
  }
class methodClass {
  public final int fuck = 3;
  public int add(int a,int b) {
      return a+b;
  }
  public int sub(int a,int b) {
      return a+b;
  }
}

程序运行结果如下：

Methods获取的方法：
public int org.ScZyhSoft.common.methodClass.add(int,int)
public int org.ScZyhSoft.common.methodClass.sub(int,int)
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
getDeclaredMethods获取的方法：
public int org.ScZyhSoft.common.methodClass.add(int,int)
public int org.ScZyhSoft.common.methodClass.sub(int,int)

可以看到，通过 getMethods() 获取的方法可以获取到父类的方法,比如 java.lang.Object 下定义的各个方法。

5、获取类的成员变量（字段）信息

获取成员变量并调用：
1.批量的
1).Field[] getFields():获取所有的”公有字段”
2).Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有；但不包括父类的成员变量。
2.获取单个的：
1).public Field getField(String fieldName):获取某个”公有的”字段；
2).public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)

5.2、Field:成员变量

(1)设置值void set(Object obj , Object value)
(2)获取值 get(Object obj)
(3)忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射

5.3通过反射访问对象属性

Student类：

package com.bjpowernode;
//反射属性Field
public class Student {
    //Field翻译为字段，其实就是属性/成员
    private String name;//Field对象
    protected int age;
    boolean sex;
    public int no;
    public static final double MATH_PI=3.1415926;
}

测试类：

package com.bjpowernode;
import java.lang.reflect.Field;
public class FieldTest {
    public static void main(String[] args)  throws  Exception{
     //使用反射机制，去访问一个对象属性(set,get)
        Class studentCLass = Class.forName("com.bjpowernode.Student");
        Object obj=studentCLass.newInstance();//obj就是Student对象(底层调用无参构造方法)
        //获取no属性(根据属性的名称来获取Field)
       Field noField = studentCLass.getDeclaredField("no");
        noField.set(obj,2222);
        System.out.println(noField.get(obj));//2222
        //可以访问私有属性(打破封装)
        Field nameField = studentCLass.getDeclaredField("name");
        nameField.setAccessible(true);
        //给name属性赋值
        nameField.set(obj,"jackson");
        //获取name属性的值
        System.out.println(nameField.get(obj));//jackson
    }
}

6、通过反射调用方法

当我们从类中获取了一个方法后，我们就可以用 invoke() 方法来调用这个方法。invoke 方法的原型为:

public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException

下面是一个实例：

public class test1 {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class<?> klass = methodClass.class;
        //创建methodClass的实例
        Object obj = klass.newInstance();
        //获取methodClass类的add方法
        Method method = klass.getMethod("add",int.class,int.class);
        //调用method对应的方法 => add(1,4)
        Object result = method.invoke(obj,1,4);
        System.out.println(result);
    }
}
class methodClass {
    public final int fuck = 3;
    public int add(int a,int b) {
        return a+b;
    }
    public int sub(int a,int b) {
        return a+b;
    }
}

7、通过反射运行配置文件内容

Student类：

package com.bjpowernode.Test;
public class Student {
    public void show(){
        System.out.println("is show()");
    }
}

配置文件以pro.txt文件为例子：

className = com.bjpowernode.Test.Student
methodName = show

测试类：

package com.bjpowernode.Test;
import java.io.FileReader;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;
public class Test {
    public static void main(String[] args) throws Exception {
        //加载键值对数据
        Properties properties = new Properties();
        FileReader fileReader = new FileReader("chapter/pro.txt");
        properties.load(fileReader);
        fileReader.close();
        //获取数据
      String classname=  properties.getProperty("className");    //com.bjpowernode.Test.Student
      String methodName=  properties.getProperty("methodName");  //show
      //反射
        Class c=Class.forName(classname);
        Constructor con =  c.getConstructor();
        Object obj=con.newInstance();
        //调用方法
        Method m =c.getMethod(methodName);
        m.invoke(obj);
    }
}

输出: is show()

补充:路径几种方式

  //第一种通用的方式
//获取一个文件的绝对路径  pro.properties必须放在src的下边(通用的)
    String path=Thread.currentThread().getContextClassLoader().
            getResource("pro.properties").getPath();
        System.out.println(path);
//用第二种方式就可以
    //获取pro.properties文件的绝对路径(从类的根路径下作为起点开始)
    String path=Thread.currentThread().getContextClassLoader().
            getResource("com/bjpowernode/java/pro.properties").getPath();
        System.out.println(path);

         //以流的形式返回
     InputStream reader= Thread.currentThread().getContextClassLoader().
             getResourceAsStream("pro.properties");
        Properties pro= new Properties();
        pro.load(reader);

8.资源绑定器

Classinfo2.properties文件：

className=123;

/*
java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容。
使用以下这种方式的时候，属性配置文件xxx.properties必须放到类路径下。
*/
public class ResourceBundleTest{
    public static void main(String[] args){
资源绑定器，只能绑定xxx.properties文件。并且这个文件必须在类路径下
文件扩展名也必须是properties
并且在写路径的时候，路径后面的扩展名不能写。
ResourceBundle bundle = ResourceBundle.getBundle("classinfo2");
String className = bundle.getString("className");
System.out.println(className);        //123
    }
}

9、利用反射创建数组

数组在Java里是比较特殊的一种类型，它可以赋值给一个Object Reference。下面我们看一看利用反射创建数组的例子：

public static void testArray() throws ClassNotFoundException {
        Class<?> cls = Class.forName("java.lang.String");
        Object array = Array.newInstance(cls,25);
        //往数组里添加内容
        Array.set(array,0,"hello");
        Array.set(array,1,"Java");
        Array.set(array,2,"fuck");
        Array.set(array,3,"Scala");
        Array.set(array,4,"Clojure");
        //获取某一项的内容
        System.out.println(Array.get(array,3));
    }

其中的Array类为java.lang.reflect.Array类。我们通过Array.newInstance()创建数组对象，它的原型是:

public static Object newInstance(Class<?> componentType, int length)
        throws NegativeArraySizeException {
        return newArray(componentType, length);
    }

而 newArray 方法是一个 native 方法，它在 HotSpot JVM 里的具体实现我们后边再研究，这里先把源码贴出来：

private static native Object newArray(Class<?> componentType, int length)
        throws NegativeArraySizeException

源码目录：openjdk\hotspot\src\share\vm\runtime\reflection.cpp

arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) {
  if (element_mirror == NULL) {
    THROW_0(vmSymbols::java_lang_NullPointerException());
  }
  if (length < 0) {
    THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
  }
  if (java_lang_Class::is_primitive(element_mirror)) {
    Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
    return TypeArrayKlass::cast(tak)->allocate(length, THREAD);
  } else {
    Klass* k = java_lang_Class::as_Klass(element_mirror);
    if (k->oop_is_array() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) {
      THROW_0(vmSymbols::java_lang_IllegalArgumentException());
    }
    return oopFactory::new_objArray(k, length, THREAD);
  }
}

10、通过反射越过泛型检查

泛型用在编译期，编译过后泛型擦除（消失掉），所以是可以通过反射越过泛型检查的
测试类：

import java.lang.reflect.Method;
import java.util.ArrayList;
/*
 * 通过反射越过泛型检查
 * 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？
 */
public class Demo {
    public static void main(String[] args) throws Exception{
        ArrayList<String> strList = new ArrayList<>();
        strList.add("aaa");
        strList.add("bbb");
    //    strList.add(100);
        //获取ArrayList的Class对象，反向的调用add()方法，添加数据
        Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
        //获取add()方法
        Method m = listClass.getMethod("add", Object.class);
        //调用add()方法
        m.invoke(strList, 100);
        //遍历集合
        for(Object obj : strList){
            System.out.println(obj);
        }
    }
}

控制台输出:

aaa
bbb
100

二、注解

ava 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。

一、注解的用处：

  1、生成文档。这是最常见的，也是java 最早提供的注解。常用的有@param @return 等<br />      2、跟踪代码依赖性，实现替代配置文件功能。比如Dagger 2 依赖注入，未来java 开发，将大量注解配置，具有很大用处;<br />      3、在编译时进行格式检查。如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出

二、注解的原理：

注解本质是一个继承了Annotation 的特殊接口，其具体实现类是Java 运行时生成的动态代理类。而我们通过反射获取注解时，返回的是Java 运行时生成的动态代理对象$Proxy1。通过代理对象调用自定义注解（接口）的方法，会最终调用AnnotationInvocationHandler 的invoke 方法。该方法会从memberValues 这个Map 中索引出对应的值。而memberValues 的来源是Java 常量池。

三、元注解

java.lang.annotation 提供了四种元注解，专门注解其他的注解（在自定义注解的时候，需要使用到元注解）：
@Documented – 注解是否将包含在JavaDoc中
@Retention – 什么时候使用该注解
@Target – 注解用于什么地方
@Inherited – 是否允许子类继承该注解
1.）@Retention – 定义该注解的生命周期
● RetentionPolicy.SOURCE : 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注解。
● RetentionPolicy.CLASS : 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式
● RetentionPolicy.RUNTIME : 始终不会丢弃，运行期也保留该注解，因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。
2.）Target – 表示该注解用于什么地方。默认值为任何元素，表示该注解用于什么地方。可用的ElementType 参数包括
● ElementType.CONSTRUCTOR: 用于描述构造器
● ElementType.FIELD: 成员变量、对象、属性（包括enum实例）
● ElementType.LOCAL_VARIABLE: 用于描述局部变量
● ElementType.METHOD: 用于描述方法
● ElementType.PACKAGE: 用于描述包
● ElementType.PARAMETER: 用于描述参数
● ElementType.TYPE: 用于描述类、接口(包括注解类型) 或enum声明
3.)@Documented – 一个简单的Annotations 标记注解，表示是否将注解信息添加在java 文档中。
4.)@Inherited – 定义该注释和子类的关系
@Inherited 元注解是一个标记注解，@Inherited 阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited 修饰的annotation 类型被用于一个class，则这个annotation 将被用于该class 的子类。

四、常见标准Annotation

1.）Override
java.lang.Override 是一个标记类型注解，它被用作标注方法。它说明了被标注的方法重写了父类的方法，起到了断言的作用。如果我们使用了这种注解在一个没有覆盖父类方法的方法时，java 编译器将以一个编译错误来警示。
2.）Deprecated
Deprecated 也是一种标记类型注解。当一个类型或者类型成员使用@Deprecated 修饰的话，编译器将不鼓励使用这个被标注的程序元素。所以使用这种修饰具有一定的“延续性”：如果我们在代码中通过继承或者覆盖的方式使用了这个过时的类型或者成员，虽然继承或者覆盖后的类型或者成员并不是被声明为@Deprecated，但编译器仍然要报警。
3.）SuppressWarnings
SuppressWarning 不是一个标记类型注解。它有一个类型为String[] 的成员，这个成员的值为被禁止的警告名。对于javac 编译器来讲，被-Xlint 选项有效的警告名也同样对@SuppressWarings 有效，同时编译器忽略掉无法识别的警告名。
@SuppressWarnings(“unchecked”)

五、自定义注解

自定义注解类编写的一些规则:
1. Annotation 型定义为@interface, 所有的Annotation 会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口.
2. 参数成员只能用public 或默认(default) 这两个访问权修饰
3. 参数成员只能用基本类型byte、short、char、int、long、float、double、boolean八种基本数据类型和String、Enum、Class、annotations等数据类型，以及这一些类型的数组.
4. 要获取类方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation 对象，因为你除此之外没有别的获取注解对象的方法
5. 注解也可以没有定义成员,，不过这样注解就没啥用了
PS:自定义注解需要使用到元注解

六、自定义注解的实例：

FruitName.java

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
/**
 * 水果名称注解
 */
@Target(FIELD)
@Retention(RUNTIME)
@Documented
public @interface FruitName {
 /*           属性           属性默认值*/
    String value() default "";
}

FruitColor.java

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
/**
 * 水果颜色注解
 */
@Target(FIELD)
@Retention(RUNTIME)
@Documented
public @interface FruitColor {
    /**
     * 颜色枚举
     */
    public enum Color{ BLUE,RED,GREEN};
    /**
     * 颜色属性
     */
    Color fruitColor() default Color.GREEN;
}

FruitProvider.java

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
/**
 * 水果供应者注解
 */
@Target(FIELD)
@Retention(RUNTIME)
@Documented
public @interface FruitProvider {
    /**
     * 供应商编号
     */
    public int id() default -1;
    /**
     * 供应商名称
     */
    public String name() default "";
    /**
     * 供应商地址
     */
    public String address() default "";
}

FruitInfoUtil.java

import java.lang.reflect.Field;
/**
 * 注解处理器
 */
public class FruitInfoUtil {
    public static void getFruitInfo(Class<?> clazz){
        String strFruitName=" 水果名称：";
        String strFruitColor=" 水果颜色：";
        String strFruitProvicer="供应商信息：";
        Field[] fields = clazz.getDeclaredFields();
        for(Field field :fields){
            //A.isAnnotationPresent(B.class)；意思就是：注释B是否在此A上。
            if(field.isAnnotationPresent(FruitName.class)){
                 //获取该注解对象
                FruitName fruitName = (FruitName) field.getAnnotation(FruitName.class);
                //获取该注解的属性ruitName.value();
                strFruitName=strFruitName+fruitName.value();
                System.out.println(strFruitName);
            }
            else if(field.isAnnotationPresent(FruitColor.class)){
                FruitColor fruitColor= (FruitColor) field.getAnnotation(FruitColor.class);
                strFruitColor=strFruitColor+fruitColor.fruitColor().toString();
                System.out.println(strFruitColor);
            }
            else if(field.isAnnotationPresent(FruitProvider.class)){
                FruitProvider fruitProvider= (FruitProvider) field.getAnnotation(FruitProvider.class);
                strFruitProvicer=" 供应商编号："+fruitProvider.id()+" 供应商名称："+fruitProvider.name()+" 供应商地址："+fruitProvider.address();
                System.out.println(strFruitProvicer);
            }
        }
    }
}

Apple.java

import test.FruitColor.Color;
/**
 * 注解使用
 */
public class Apple {
    @FruitName("Apple")
    private String appleName;
    @FruitColor(fruitColor=Color.RED)
    private String appleColor;
    @FruitProvider(id=1,name="陕西红富士集团",address="陕西省西安市延安路89号红富士大厦")
    private String appleProvider;
    public void setAppleColor(String appleColor) {
        this.appleColor = appleColor;
    }
    public String getAppleColor() {
        return appleColor;
    }
    public void setAppleName(String appleName) {
        this.appleName = appleName;
    }
    public String getAppleName() {
        return appleName;
    }
    public void setAppleProvider(String appleProvider) {
        this.appleProvider = appleProvider;
    }
    public String getAppleProvider() {
        return appleProvider;
    }
    public void displayName(){
        System.out.println("水果的名字是：苹果");
    }
}

FruitRun.java

/**
 * 输出结果
 */
public class FruitRun {
    public static void main(String[] args) {
        FruitInfoUtil.getFruitInfo(Apple.class);
    }
}

运行结果是：

水果名称：Apple
水果颜色：RED
供应商编号：1 供应商名称：陕西红富士集团供应商地址：陕西省西安市延安路89号红富士大厦

Java 学习笔记

反射和注解