关于注解和反射

注解

：框架的基础，给程序看的解释 java 1.5出现
内置注解
@Override 重写 覆盖父类的方法
@Deprecated 已过时的，不建议实际用，但是可以使用，可以存在更好的方式，调用多个-
@SuppressWaring（“call”) 镇压警告

元注解
@Target （value = ElementType.Method) 表示注解可以用在哪些地方
@Retention(value=RetenionPolicy.RUNTIME) 在什么地方有效
@Documented 是否生成javadoc中
@Interited 继承

自定义注解

用@interface来声明一个注解 格式为public @interface 注解名称{}
1.其中每一个方法实际声明了一个配置参数 方法名称就是参数的名称
2.返回类型就是参数的类型，返回值只能是基本类型Class，String，enum
3.可以用default来申明参数的默认值，如果只有一个参数，一般为value，写参数时就不用加value= ，如果是其他命令 就必须加，默认规定
4.注解元素必须优质，经常使用空字符串和0作为默认值

反射

反射机制 java.reflection 使得java变成一个动态语言
创建对象 new ，clone ，反射（运行时创建对象） bean底层也是反射
java是静态语言，反射使其变成准动态语言，在程序运行时
类加载完就成一个class对象，反射就是一个镜子，反过来的

优点：动态常见对象，在程序运行的时候改变其结构
缺点: 性能降低

主要API：
java.lang.Class:一个类
reflect.method 代表类的方法
reflect.Field 成员变量
reflect.Constructor 类的构造器

反射的方法 主要得到Class
Class aclass = Class.forName(“类的路径”)
Object类中的getClass 所有的对象的只有一个class

Class本身也是一个类，
一个java的类在jvm只有一个class实例

获取class的实例

1.Class clazz = Person.class

2 Class clazz = person.getClass()

3.Class clazz = Class.forName（“路径”）

基本数据类型可以通过.Type

反射测试代码：
package com.kang;

public class Person {
private String name;
private String age;

@Override
public String toString() {
    return "Person{" +
            "name='" + name + '\'' +
            ", age='" + age + '\'' +
            '}';
}

public Person(){};
public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public String getAge() {
    return age;
}

public void setAge(String age) {
    this.age = age;
}

public Person(String name, String age) {
    this.name = name;
    this.age = age;
}

}
package com.kang;

import org.springframework.http.converter.json.GsonBuilderUtils;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class reflection {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException {
//获得class ，就是反射用的镜子
Class clazz = Class.forName(“com.kang.Person”);
Person person = new Person();
Class personClass = person.getClass();

     //获得类的包名和类型

    String name = clazz.getName();//包名+类名
    String simpleName =clazz.getSimpleName();//类名
    System.out.println("name"+name+"     simple"+simpleName);
    //只能获得public修饰属性
    Field[] fields=clazz.getFields();
    for (int i = 0; i <fields.length ; i++) {
        System.out.println("public"+fields[i]);
    }
    //能获得私有属性
    Field[] declaredFields = clazz.getDeclaredFields();
    for (int i = 0; i <declaredFields.length ; i++) {
        System.out.println("privateAndPublic"+declaredFields[i]);
    }
    //获得本类和父类所有的public方法
    Method[] methods = clazz.getMethods();
    for (int i = 0; i <methods.length ; i++) {
        System.out.println("public"+methods[i]);
    }
    //获得本类和父类所有的私有方法
    Method[] declaredMethods = clazz.getDeclaredMethods();
    for (int i = 0; i <declaredMethods.length ; i++) {
        System.out.println("privateAndPublic"+declaredMethods[i]);
    }
    //获得构造器
    Constructor[] constructors = clazz.getConstructors();
    for (int i = 0; i <constructors.length ; i++) {
        System.out.println(constructors[i]);
    }
    //获得所有的构造器
    Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
    //获得指定的构造器
    Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class, String.class);

    System.out.println("指定"+declaredConstructor);








   //动态的创建对象，利用反射创建一个对象
    Person person1 = (Person) clazz.newInstance();
    System.out.println("创建无参构造器对象"+person1.toString());
    //创建对象后可以通过反射获得方法/属性然后传入值
    //获得指定方法
    Method setName = clazz.getDeclaredMethod("setName", String.class);
    setName.invoke(person1,"陈康你真帅");
    System.out.println("方法传值"+person1);
    //获得指定属性
    Field age=clazz.getDeclaredField("age");
    age.setAccessible(true);//关闭访问权限检查，让私有方法可达，不然无法访问,并且提高反射效率，用反射，可以打开
    age.set(person1,"陈康永远18岁");
    System.out.println("属性传值"+person1);
    //通过构造器创建对象
    Person chenkang = (Person)declaredConstructor.newInstance("chenkang", "18");
    System.out.println("通过有参构造创建对象"+chenkang.toString());



    //获得类加载器ApplicationClassLoader
    ClassLoader classLoader = clazz.getClassLoader();
    System.out.println("类加载器ApplicationClassLoader"+classLoader);
    //ApplicationClassLoader
    ClassLoader parent = classLoader.getParent();
    System.out.println("扩展类加载器ApplicationClassLoader"+parent);
    //bootstrapClassLoader,根加载器获得为null
    ClassLoader parent1 = parent.getParent();
    System.out.println("根加载器bootstrapClassLoader"+parent1);
    //jdk是bootstrap加载的
    Class clazzObject = Class.forName("java.lang.Object");
    System.out.printf("bootStrap"+clazzObject.getClassLoader());
}

}