反射概述
反射概述：
- 反射（Reflection） 是被视为 动态语言 的关键，反射机制允许程序在执行期间借助于Reflection API 取得任何内部类的信息，并能直接操作任意对象的内部属性及方法。
- 加载完类之后，在堆内存的方法区中就产生了一个Class 类的对象（一个类只有一个Class 对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以我们形象的称之为 反射。
反射主要涉及到的包：
java.lang.Class
java.lang.reflect.Constructor;
java.lang.reflect.Field;
java.lang.reflect.Method;
反射演示
比如我们有一个 Person 类，如下代码演示如何动态获取 Person 类，并对其属性和方法进行操作。
@Test
public void test1() throws Exception {
Class clazz = Person.class;
//1.通过反射，创建Person 类的对象
Constructor cons = clazz.getConstructor(String.class, int.class);
Object obj = cons.newInstance("Tom", 22);
Person p = (Person) obj;
System.out.println(p.toString());
//2.通过反射，调用对象指定的属性、方法
//调用属性，这里可以调用和设置私有属性
Field age = clazz.getDeclaredField("age");
//通过反射设置当前实例Person的age属性
age.setAccessible(true);
age.set(p, 10);
//3.调用方法
Method show = clazz.getDeclaredMethod("show");
show.invoke(p);
//4.调用私有方法,指定一个参数：
Method showNation = clazz.getDeclaredMethod("showNation", String.class);
showNation.setAccessible(true);//调用私有方法，必须去指定它的访问权限，权限为true，才可以调用该方法
showNation.invoke(p, "China");
//5.调用方法，带返回值的
Method getName = clazz.getDeclaredMethod("getName");
String name1 = (String) getName.invoke(p);//这里需要强转下返回值
System.out.println(name1);
//6.调用静态方法
Method showDesc = clazz.getDeclaredMethod("showDesc", String.class);
showDesc.setAccessible(true);
Object returnVal = showDesc.invoke(Person.class, "Jerry description");//这里是void方法，所以返回值是null
//Object returnVal = showDesc.invoke(null,"Jerry description");//或者填null也是可以的
System.out.println("Return value is: " + returnVal);
}
获取Class 的方式
- 有四种方式可以动态获取大Class
方式1：使用.class
//方式一：调用运行时的类的属性： .class
Class clazz1 = Person.class;
System.out.println(clazz1);
方式2：使用getClass()
//方式二：通过运行时类的对象，调用getClass()
Person p2 = new Person();
Class clazz2 = p2.getClass();
System.out.println(clazz2);
方式3：使用forName(String classPath)
//方式三：调用Class 的静态方法，forName(String classPath)
Class clazz3 = Class.forName("com.jerry.reflection1.Person");
System.out.println(clazz3);
方式4：使用ClassLoader
//方式四：使用ClassLoader（作为了解）
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class<?> clazz4 = classLoader.loadClass("com.jerry.reflection1.Person");
System.out.println(clazz4);
-
注意： 4种方式创建的实例对象，指向同一个实例
System.out.println(clazz1 == clazz2); System.out.println(clazz1 == clazz3); System.out.println(clazz1 == clazz4);
理解java.lang.Class
类的加载过程：
- 程序通过
javac.exe命令以后，会生成一个或多个字节码文件(.class结尾的文件)，
接着我们使用java.exe命令，对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中，此过程称为类的加载。
加载到内存类中，我们就称为运行时类，此时运行时类，就作为Class 的一个实例。 - 简单来说：大
Class类其实就是对应运行时类的一个实例。 - 体现出：万事万物皆对象
可以获取Class 场景
-
可以动态获取 Class 实例的场景如下：
@Test public void test3() throws Exception { Class c1 = Object.class; Class c2 = Comparable.class; Class c3 = String[].class; Class c4 = int[][].class; Class c5 = ElementType.class; Class c6 = Override.class; Class c7 = int.class; Class c8 = void.class; Class c9 = Class.class; int[] a = new int[10]; int[] b = new int[100]; Class c10 = a.getClass(); Class c11 = b.getClass(); //只要元素类型与维度一样，就是同一个Class System.out.println(c10 == c11); }
示例：反射文件获取内容
例如： 我们有一个jdbc.properties 的资源文件，如下：
我们要获取其中配置文件的 user 和 password 可以按如下办法：
方式1：FileInputStream
-
通过
FileInputStream文件流的方式，获取配置文件中的内容Properties props = new Properties(); //通过读取文件方式，获取配置文件中的内容，使用这种方式配置文件前面加src\\\\ FileInputStream fis = new FileInputStream("src\\\\jdbc.properties"); props.load(fis); String user = props.getProperty("user"); String password = props.getProperty("password"); System.out.println("User: " + user + " Password: " + password);
方式2：getClassLoader
-
通过反射 getClassLoader 在获取文件流方式，获取配置文件中内容
//通过类的加载器获取资源文件中的内容,配置文件是在当前文件目录下 Properties props = new Properties(); ClassLoader classLoader = ReflectionTest.class.getClassLoader(); InputStream is = classLoader.getResourceAsStream("jdbc.properties"); props.load(is); String user1 = props.getProperty("user"); String password1 = props.getProperty("password"); System.out.println("User1: " + user1 + " Password1: " + password1);
创建运行时类的对象
概述：我们通常需要根据反射，来动态的创建运行时类的对象，可以按如下方法：
@Test
public void test5() throws Exception {
Class<Person> clazz = Person.class;
Person person = clazz.newInstance();
System.out.println(person);
//这里是新创建的对象，所以不相等
Person person1 = clazz.newInstance();
Person person2 = clazz.newInstance();
System.out.println(person1 == person2);//false
}
注意：
newInstance()方法调用时，对应实例类中必须有对应的空参构造器，没有的话就会报错
总结：要想此方法正常的创建运行时类的对象，要求：
- 1.运行时类必须提供空参的构造器
- 2.空参的构造器访问权限得够，通常为public
扩展：在javabean 中通常要求提供一个public 的空参构造器，好处如下：
- 1.便于通过反射，创建运行时类的对象
- 2.便于子类继承此运行类时，默认调用super() 时，保证父类有此构造器
示例：体会反射的动态性
@Test
public void test6() {
for (int i = 0; i < 50; i++) {
int num = new Random().nextInt(3);
String classPath = "";
switch (num) {
case 0:
classPath = "java.util.Date";
break;
case 1:
classPath = "java.lang.Object";
break;
case 2:
classPath = "com.jerry.reflection1.Person";
break;
}
try {
Object obj = getInstance(classPath);
System.out.println(obj);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public Object getInstance(String classPath) throws Exception {
Class clazz = Class.forName(classPath);
return clazz.newInstance();
}
**总结： **上述代码，通过
switch-case通过传入的classPath的name不同，既可以动态创建实例，这里就体现了反射的动态性。
附录：Person 类代码
public class Person {
private String name;
private int age;
public Person() {
System.out.println("Person constructor");
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name=\'" + name + \'\\\'\' +
", age=" + age +
\'}\';
}
public void show() {
System.out.println("This is a person");
}
private void showNation(String nation) {
System.out.println("My nation is : " + nation);
}
private static void showDesc(String desc) {
System.out.println("My description is: " + desc );
}
}