什么是JAVA的反射机制
Java反射是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其
modifiers（诸如public, static等）、superclass（例如Object）、实现之
interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行
时改变fields内容或唤起methods。
Java反射机制容许程序在运行时加载、探知、使用编译期间完全未知的classes。
换言之，Java可以加载一个运行时才得知名称的class，获得其完整结构。
反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。
JAVA反射机制提供了什么功能
Java反射机制提供如下功能：
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判段任意一个类所具有的成员变量和方法
在运行时调用任一个对象的方法
从接口 java.lang.reflect
获取类的Class对象
Class类的实例表示正在运行的Java应用程序中的类和接口。获取类的Class对象有多种方式：
调用getClass：
Boolean var1 = true;
Class<?> classType2 = var1.getClass();System.out.println(classType2);
输出：class java.lang.Boolean
运用.class语法
Class<?> classType4 = Boolean.class;
System.out.println(classType4);
输出：class java.lang.Boolean
运用static methodClass.forName()
Class<?> classType5= Class.forName("java.lang.Boolean");
System.out.println(classType5);
输出：class java.lang.Boolean
运用primitive wrapper classes
Class<?> classType3 = Boolean.TYPE;
System.out.println(classType3);
输出：boolean
TYPE语法这里返回的是原生类型，和Boolean.class返回的不同
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
// 方式1
Person p = new Person();
Class c = p.getClass();
Person p2 = new Person();
Class c2 = p2.getClass();
System.out.println(p == p2);// false
System.out.println(c == c2);// true
// 方式2
Class c3 = Person.class;
// int.class;
// String.class;
System.out.println(c == c3);
// 方式3
// ClassNotFoundException
Class c4 = Class.forName("cn.itcast_01.Person");
System.out.println(c == c4);
}
}获取类的Fields
可以通过反射机制得到某个类的某个属性，然后改变对应于这个类的某个实例的该属性值。
JAVA的Class<T>类提供了几个方法获取类的属性。
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
// 获取单个的成员变量
// 获取address并对其赋值
Field addressField = c.getField("address");
// public void set(Object obj,Object value)
// 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
System.out.println(obj);
// 获取name并对其赋值
// NoSuchFieldException
Field nameField = c.getDeclaredField("name");
// IllegalAccessException
nameField.setAccessible(true);
nameField.set(obj, "林青霞");
System.out.println(obj);
// 获取age并对其赋值
Field ageField = c.getDeclaredField("age");
ageField.setAccessible(true);
ageField.set(obj, 27);
System.out.println(obj);可见getFields和getDeclaredFields区别：
getFields返回的是申明为public的属性，包括父类中定义，
getDeclaredFields返回的是指定类定义的所有定义的属性，不包括父类的。
获取类的Method
通过反射机制得到某个类的某个方法，然后调用对应于这个类的某个实例的该方法
Class<T>类提供了几个方法获取类的方法。
getMethod
public Method getMethod(String name,
Class<?>... parameterTypes)
throws NoSuchMethodException,
SecurityExceptionclassnullpublic class ReflectDemo {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
// 获取所有的方法
// Method[] methods = c.getMethods(); // 获取自己的包括父亲的公共方法
// Method[] methods = c.getDeclaredMethods(); // 获取自己的所有的方法
// for (Method method : methods) {
// System.out.println(method);
// }
//创建新类的实例
Constructor con = c.getConstructor();
Object obj = con.newInstance();
/*
* Person p = new Person(); p.show();
*/
// 获取单个方法并使用
// public void show()
// public Method getMethod(String name,Class<?>... parameterTypes)
// 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
Method m1 = c.getMethod("show");
// obj.m1(); // 错误
// public Object invoke(Object obj,Object... args)
// 返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
m1.invoke(obj); // 调用obj对象的m1方法
System.out.println("----------");
// public void method(String s)
Method m2 = c.getMethod("method", String.class);
m2.invoke(obj, "hello");
System.out.println("----------");
// public String getString(String s, int i)
Method m3 = c.getMethod("getString", String.class, int.class);
Object objString = m3.invoke(obj, "hello", 100);
System.out.println(objString);
// String s = (String)m3.invoke(obj, "hello",100);
// System.out.println(s);
System.out.println("----------");
// private void function()
Method m4 = c.getDeclaredMethod("function");
m4.setAccessible(true);
m4.invoke(obj);
}
}
获取类的Constructor
通过反射机制得到某个类的构造器，然后调用该构造器创建该类的一个实例
Class<T>类提供了几个方法获取类的构造器。
//使用getConstructors获取构造器
Constructor<?>[] constructors = classType.getConstructors();for(Constructor<?> m : constructors)
{
System.out.println(m);
}//使用getDeclaredConstructors获取构造器
constructors = classType.getDeclaredConstructors();
for(Constructor<?> m : constructors)
{
System.out.println(m);
}通过反射去获取该构造方法并使用
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
// 获取带参构造方法对象
// public Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor con = c.getConstructor(String.class, int.class,
String.class);
// 通过带参构造方法对象创建对象
// public T newInstance(Object... initargs)
Object obj = con.newInstance("林青霞", 27, "北京");
System.out.println(obj);
}
}通过反射获取私有构造方法并使用
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
// 获取私有构造方法对象
// NoSuchMethodException：每个这个方法异常
// 原因是一开始我们使用的方法只能获取公共的，下面这种方式就可以了。
Constructor con = c.getDeclaredConstructor(String.class);
// 用该私有构造方法创建对象
// IllegalAccessException:非法的访问异常。
// 暴力访问
con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。
Object obj = con.newInstance("风清扬");
System.out.println(obj);
}
}新建类的实例
调用类的Class对象的newInstance方法
该方法会调用对象的默认构造器，如果没有默认构造器，会调用失败.
Class<?> classType = ExtendType.class;
Object inst = classType.newInstance();
System.out.println(inst);输出：
Type:Default Constructor
ExtendType:Default Constructor
com.quincy.ExtendType@d80be3
调用默认Constructor对象的newInstance方法
Class<?> classType = ExtendType.class;
Constructor<?> constructor1 =
classType.getConstructor();
Object inst = constructor1.newInstance();
System.out.println(inst);输出：
Type:Default Constructor
ExtendType:Default Constructor
com.quincy.ExtendType@1006d75
调用带参数Constructor对象的newInstance方法
Constructor<?> constructor2 =
classType.getDeclaredConstructor(int.class,
String.class);
Object inst = constructor2.newInstance(1, "123");
System.out.println(inst);输出：
Type:Default Constructor
ExtendType:Constructor with parameters
com.quincy.ExtendType@15e83f9