反射：在程序运行期间获取类的结构完成某些特定的功能。
常规情况下是通过类来创建实例化对象,反射是将这一过程进行反转，通过实例化对象来获取类的信息。Class类是反射的源头！——专门用来描述其他类的类，Class的每一个实例化对象对应一个类的结构
forName(String className)——将目标类的全限定类名
Class的实例化对象描述的是目标类在JVM内存中的运行时类。
运行时类： 当程序启动时，目标类第一次被加载到内存中的模板就叫做运行时类，并且只加载一次。
反射：在程序执行期间，动态加载类及其成员到CLassLoad类中
面向对象的Java——动态语言
类加载器：classloader
动态加载类及其成员反射的第一步：获取class对象 【包名+类名】——完全类名
1>通过对象来获取：在获得具体对象时，可以用它
2>通过类来获取：当我没有对象，只有类型时候使用
3>通过局部变量声明的方式来获取：一般来说，通过第三方获取的信息来创建{
本质：通常只是一个字符串。
}
反射创建对象，
1>通过类创建
2>通过构造
3>通过class2>动态代理
获取属性：（正常情况下属性都是私有的）
1>获取所有属性
2>获取共有属性
3>属性赋值取值，必须现有对象
反射操作方法：
1.得到方法名
2.获得方法对象的时候，参数列表给的是类型
3.执行方法：invoke();
4.invoke()后，可以有返回值，也可以没有返回值
5.思考：为什么getter、setter要那么写！！
在所有的类成员的“对象”中，但凡私有的，想要访问，必须提供权限，各个成员对象只要可以修饰为私有！
interface I{
public void show();
}class A implements I{
@Override
public void show() {
// TODO Auto-generated method stub
System.out.println("A.show()");
}
}class B extends A{
}//获取类对象
//对象获取
A a = new A();
Class<? extends A> a1 = a.getClass();
//类名获取
Class<? extends A> a2 = A.class;//通过全类名获取
Class a3 = Class.forName("反射.A");
//类对象调用构造函数
Object obj = a3.newInstance();//相当于new 了一个对象//本质：调用空参构造构建对象
((A) obj).show();
//对于继承类对象
Class<?> aClass = B.class.asSubclass(A.class);
Class<? extends A> testClass = B.class;
System.out.println(testClass.equals(aClass));//二者本质一致
//接口
//多态
I i = I.class.cast(new A());
i.show();
I i1 = I.class.cast(new B());
i1.show();//简单应用获取属性、方法
//反射操作方法
Class personClass = Person.class;
Person person = (Person) personClass.newInstance();
Field idField = personClass.getDeclaredField("id");
String nameString = idField.getName();
String setMethod = "set"+nameString.substring(0,1).toUpperCase()+nameString.substring(1);
Method setId = personClass.getMethod(setMethod, idField.getType());
setId.invoke(person, 2);String getMethod = "get"+nameString.substring(0,1).toUpperCase()+nameString.substring(1);
System.out.println("getMethod:"+getMethod);
Method getId = personClass.getMethod(getMethod);
Object object = getId.invoke(person);
System.out.println(object);
综合：反射构造方法
//定义Person对象（+注解）
//其中需要注意：包装类与基本数据类型的区别，通过构造反射获取对象，需要传入属性类型
public class Person {
private int id;
// private Integer id;
// private int age;
private Integer age;
private String name;
@testAnn()
public Person() {
super();
// TODO Auto-generated constructor stub
}
// @testAnn(value1 = "",value2 = "")
@testAnn(value1 = "")
public Person(int id) {
super();
this.id = id;
}
public Person(int id,int age,String name) {
this(id);
this.age = age;
this.name = name;
}
@SuppressWarnings("unused")
void test() {
int i;
int j;
}
public Integer getId() {
return id;
}public void setId(Integer id) {
this.id = id;
}public Integer getAge() {
return age;
}public void setAge(Integer age) {
this.age = age;
}@Deprecated
public String myString() {
return "Person["+id+"]";
}
@Override
public String toString() {
return "Person["+id+"]";
}
}
@Documented//其实可要可不要，是用于表面是否会出现在DOC注释里的
@Target(ElementType.CONSTRUCTOR)//
@Retention(RetentionPolicy.RUNTIME)//
@interface testAnn{
//可以添加一个类似于抽象方法，定义方法或者域
String value1() default "";
String value2() default "";
}
//反射验证生成对象
Class<?> personClass = Person.class;
//获取构造器
Constructor<?> constructor = personClass.getConstructor();
Constructor constructor2 = personClass.getDeclaredConstructor(int.class);
Constructor<?> constructor3 = personClass.getConstructor(int.class,int.class,String.class);
//生成对象
Object object = constructor.newInstance();
Object object2 = constructor2.newInstance(2);
Object object3 = constructor3.newInstance(1,2,"macr");
//获取属性对象
String nameString = "id";
String valueString = "123";
Class<?> personClass2 = Person.class;
//获取对象、属性、方法
Object object4 = personClass2.newInstance();
Field field = personClass2.getDeclaredField(nameString);
String methodString = "set"+nameString.substring(0,1).toUpperCase()
+nameString.substring(1);
System.out.println(methodString);
//属性类型
System.out.println(field.getType().getName());
//获取方法对象
//判断是否是常用基本数据类型
if (field.getType().isPrimitive()) {
switch (field.getType().toString()) {
case "int":
System.out.println("基本数据类型转换");
Method setMethod = personClass2.getMethod(methodString, int.class);
setMethod.invoke(object4, Integer.class.getConstructor(String.class).newInstance(valueString));
break;
default:
break;
}
}else {//否则：包装类类型
Class<? extends Number>parameterType = field.getType().asSubclass(Number.class);
if(parameterType!=null) {
Method setMethod = personClass2.getMethod(methodString, parameterType);
setMethod.invoke(object4, parameterType.getConstructor(String.class).newInstance(valueString));
}
}
System.out.println(((Person)object4).toString());
应用场景
Java中将对象所具备的能力封装成接口！（抽象类）
代理对象可以为委托对象进行消息预处理，过滤消息以及事后处理消息等。
代理类和委托类之间存在注入的关联关系。
我们在访问委托对象时，是通过代理对象来间接访问的，代理模式就是通过这种间接访问的方式，
为程序预留出可处理的空间，利用此空间，在不影响核心业务的基础上可以附加其他的业务，代理模式：静态代理和动态代理，
两者区别：静态代理需要预先编写好代理类的代码，在编译期间代理类的class文件已经生成。
静态代理时预先写好代理类，动态代理是程序运行期间动态地生成代理类（反射）。
native：JVM虚拟机处理机制问题
/*
* Return the Virtual Machine's Class object for the named
* primitive type.
*/
static native Class<?> getPrimitiveClass(String name);============================
int.class <==> Integer.TYPE
long.class <==> Long.TYPE
double.class <==> Double.TYPE
float.class <==> Float.TYPE
bool.class <==> Boolean.TYPE
char.class <==> Character.TYPE
byte.class <==> Byte.TYPE
void.class <==> Void.TYPE
short.class <==> Short.TYPE
注解小结：
@target:可用于描述Annotation所修饰的对象范围，ElementType取值：
1.CONSTRUCTOR:用于描述构造器
2.FIELD:用于描述域
3.LOCAL_VARIABLE:用于描述局部变量
4.METHOD:用于描述方法
5.PACKAGE:用于描述包
6.PARAMETER:用于描述参数
7.TYPE:用于描述类、接口(包括注解类型) 或enum声明@Retention:RetentionPoicy取值包括：
1.SOURCE:在源文件中有效（即源文件保留）
2.CLASS:在class文件中有效（即class保留）
3.RUNTIME:在运行时有效（即运行时保留）@Documented:Documented是一个标记注解
@Inherited:Inherited元注解是一个标记注解
某个被标注的类型是被继承的；如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。
【当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继承性。如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，直到发现指定的annotation类型被发现，或者到达类继承结构的顶层。】
@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节————JVM的后期应用【高级的话】
@interface用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称，返回值类型就是参数的类型（返回值类型只能是基本类型、Class、String、enum）。可以通过default来声明参数的默认值。
注意：
Annotation类型里面的参数该怎么设定:
第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型；
第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和 String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String;
第三,如果只有一个参数成员,最好把参数名称设为"value",后加小括号.例:下面的例子FruitName注解就只有一个参数成员。//常见应用：注解都是搭配反射的解析器共同工作的，然后利用反射机制查看类的注解内容
//注解定义
package com.cn.pre.注解反射;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Person{
String name();
int age();
}//测试注解定义
package com.cn.pre.注解反射;
@Person(name = "macro",age = 25)
public class TestPersonAnno {
public static void main(String[] args) {
test(TestPersonAnno.class);
}
public static void test(Class class1) {
System.out.println(class1.getName());
//获取类的注解
Person person = (Person)class1.getAnnotation(Person.class);
if (person!=null) {
System.out.println("name:"+person.name()+","+"age:"+person.age());
}else {
System.out.println("person unknown!");
}
}
}
注解元素必须有确定的值，要么在定义注解的默认值中指定，要么在使用注解时指定，非基本类型的注解元素的值不可为null。因此, 使用空字符串或0作为默认值是一种常用的做法。这个约束使得处理器很难表现一个元素的存在或缺失的状态，因为每个注解的声明中，所有元素都存在，并且都具有相应的值，为了绕开这个约束，我们只能定义一些特殊的值，例如空字符串或者负数，一次表示某个元素不存在，在定义注解时，这已经成为一个习惯用法。
//看底层原理
String pathString = ReadDemo.class.getClassLoader()
.getResource("book.xml").getPath();
从异常抛异常对象，构造！；模块化的管理性能！
RuntimeException Exception 实现 Throwable接口；多态的应用！
面向动作、结构执行的效率问题！