Java 反射

reflect

反射机制用来描述所有的类，所有的类具有相同的特征（属性、方法、构造、权限修饰符）

Class 描述类本身
Package
Field 描述类中的属性
Method 描述类的方法
Constructor
Annotation 注解 @Override

获取 Class

① Class clazz = Class.forName("类全名：包名.类名"); //编译异常
② Class clazz = 类名.class;
③ Class clazz = 对象.getClass();

常用方法：

clazz.getModifiers(); //修饰符（权限，特征）返回值 int:0-1-2-4-8-16-32-64-128-256-512-1024（默认-public-private-protected-static-final-synchronized-volatile-transient-native-interface-abstract）

clazz.getName(); //包名.类名
clazz.getSimpleName(); //类名

clazz.getPackage();

clazz.getSuperClass(); //获取父类

clazz.getInterfaces(); //获取父接口

clazz.newInstance(); //创建对象，返回值 Object 需要造型

Field field = clazz.getField(“属性名”);
clazz.getFields(); //以上两个方法只能获取公有的属性，包含继承的父类属性

Field f = clazz.getDeclaredField(); //可以获取本类中公有、私有属性，操作异常
f.setAccessible(true); //可以操作私有属性

field.getModifiers();
field.getType(); //获取属性类型
field.getName();

field.set(对象，”属性值”);
field.get(对象);

Method m = clazz.getMethod(“方法名”,”参数类型.class”); //获取公有方法，包含继承的父类方法
m.getParameterTypes();
m.invoke(“对象”,…args:”参数”); //调用方法，返回值 Object

Method m = clazz.getDeclaredMethod(“方法名”,”参数类型.class”); //可以获取本类中公有、私有方法，操作异常
m.setAccessible(true); //可以操作私有方法

con = clazz.getConstructor([“参数类型.class”]);
con.newInstance(…”参数”);

Annotation

格式

@注解说明[(一些信息)]

放置

类、属性、方法、构造方法上面，参数前面

作用

1、充当注释说明 @Deprecated
2、用来代码检测 @Override
3、携带一些信息内容
信息不可以随便写，支持类型：基本类型、String、enum、注解类型、数组类型[以上类型]

@Deprecated
@Override
@SuppressWarnings("信息") //少用
    //unused、serial、rawtypes、deprecation、unchecked

• 自定义注解类型

@interface

import java.lang.annotation.Target;
//import static java.lang.annotation.ElementType.*;
//@Target({FIELD,METHOD})

/**
* 元注解
*/
@Target({ElementType.FIELD,ElementType.METHOD}) //描述当前的注解可以放置在哪里书写
@Retention(RetentionPolicy.RUNTIME) //作用域
@Inherited //当前的注解能否被子类对象继承
@Document //是否能被文档所记录
public @interface myAnnotation(){
    //public static final String test = "自定义注解";
    // 必须要有返回值（基本类型、String、enum、注解类型、数组类型）
    //test => value 使用时可以省略方法名；如果有多个方法，则每一个方法必须书写
    public abstract String test(); 
}

• 示例

package mySelfannotation;

import java.lang.annotation.ElementType;
/*import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;*/
import java.lang.annotation.*;

@Target({ElementType.CONSTRUCTOR,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface SelfAnnotation {
    String[] value();
}

public class Human {
    private String name;
    private Integer age;
    private String sex;

    @SelfAnnotation({"陈小米","22","男"})
    public Human(){}

    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public Integer getAge(){
        return age;
    }
    public void setAge(Integer age){
        this.age = age;
    }
    public String getSex(){
        return sex;
    }
    public void setSex(String sex){
        this.sex = sex;
    }
}

package mySelfannotation;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class MySpring {
    public Object getBean(String className){
        Object obj = null;
        try {
            //获取类
            Class clazz = Class.forName(className);
            //获取构造方法
            Constructor con = clazz.getConstructor();
            //实例化
            obj = con.newInstance();
            //获取注解
            Annotation a = con.getAnnotation(SelfAnnotation.class);
            //获取注解对象
            Class aclazz = a.getClass();
            //获取注解值
            String[] values = (String[])aclazz.getMethod("value").invoke(a);
            //获取类属性
            Field[] fields = clazz.getDeclaredFields();
            for(int i=0; i<fields.length; i++){
                //获取类属性名
                String fieldName = fields[i].getName();
                String fLetter = fieldName.substring(0,1).toUpperCase();
                String lLetter = fieldName.substring(1);

                StringBuilder sb = new StringBuilder("set");
                sb.append(fLetter + lLetter);
                Class type = fields[i].getType();
                //执行赋值方法，参数 obj 对象，参数类型
                clazz.getMethod(sb.toString(), type).invoke(obj, 
type.getConstructor(String.class).newInstance(values[i]));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }
}

MySpring ms = new MySpring();
Human h = (Human) ms.getBean("mySelfannotation.Human");
System.out.println(h.getName() + "/" + h.getAge() + "/" + h.getSex());