Java中反射的常用方法及总结

反射，是在java中非常有用，在框架中也经常接触的一种方法，所以反射是在开发中必须会的东西
所谓反射，就是给你一个XX.class文件，你通过反射方法，能够拿到该XX类相关的所有资源，比如该类所在位置，通过该类创建一个对象x，获取这个类X创建的对象x的所有公有、私有属性和公有、私有方法。这个技术你值得学习。
首先，我写了一个TestClass.java文件，作为编译成class后要使用的TestClass.class文件，然后ReflectDemo.java演示所有反射技术的demo，这里你将学会反射里常见的方法。先给大家一个方法总结，然后看代码，熟悉相关应用。

1、方法总结：
1.1获取class的三种方法：
第一种：Class clazz = Class.forName(XX.class的全包名)
第二种：Class clazz = XX xx = new XX();xx.getClass();
第三种：Class clazz = XX.class;
见实例代码test0()
1.2如何通过类class文件，拿到该文件里面的资源？这种方式获取的路径方法，永远是固定的，不会随着工程的路径改变而改变，始终都能获取到。
比如，TestClass.class文件（被编译后）所在的classes文件夹下，有prop.properties属性文件，如何拿到这个文件的绝对路径？如何把该文件加载到流中？通过在clazz中有个getClassLoader()方法，得到类加载器ClassLoader，然后再通过getSource()的方法，得到URL，然后再getPath()得到路径名
两种固定写法：
第一种：
Class clazz = TestClass.class;
ClassLoader classLoader = clazz.getClassLoader();
URL url = classLoader.getResource("prop.properties");
String path = url.getPath();
InputStream ins = new FileInputStream(path);
链式写法为：String path = TestClass.class.getClassLoader().getResource("prop.properties").getPath();
InputStream ins = new FileInputStream(path);
第二种[直接将资源加载成流]：InputStream ins = TestClass.class.getClassLoader().getSourceAsStream("prop.properties");
见实例代码test()
1.3如何用该class文件，创建一个对象？
创建对象有两种方法，直接用xx.newInstance()或使用xx.constructor()获取构造器然后再newInstance()。
第一种：
Class xx = TestClass.class;
Object obj = xx.newInstance();//无参构造方法
TestClass tc = (TestClass)obj;//转换为该类的对象
第二种：
Class xx = TestClass.class;
Constructor cst = xx.getConstructor();//无参构造方法
Object obj = cst.newInstance();//这个也不能有参数
TestClass tc = (TestClass)obj;//转换为该类的对象
见实例代码test1()、test2()
注意：这两种方法，只能使用无参的构造方法来创建无参默认的对象，如果想创建带参的对象呢？
使用构造器，然后指定参数类型，再创建实例对象时，将实参数传递
Class xx = TestClass.class;
Constructor cst = xx.getConstructor(String.class,int.class);//指定参数类型的带参构造方法
Object obj = cst.newInstance("李四",18);//顺便指定好实参
TestClass tc = (TestClass)obj;//转换为该类的对象
见实例代码test2()
1.4如何获取到该类创建的对象中的公有及私有属性值呢？需要用到xx.getField().get()或xx.getDeclaredField().setAccessible().get();
注意：获得公有私有的属性和方法时，必须指定获取哪个对象的，必须创建好一个对象。
Class xx = TestClass.class;
Constructor cst = xx.getConstructor(String.class,int.class);//指定参数类型的带参构造方法
Object obj = cst.newInstance("李四",18);//顺便指定好实参
TestClass tc = (TestClass)obj;//转换为该类的对象
//获取公有属性name：
Field fieldName = xx.getField("name");//指定哪个字段
Object name = fieldName.get(tc);//获取tc对象的name值
String strname = (String)name;
//获取私有属性age：
Field fieldAge = xx.getDeclaredField("age");//获取所有声明的一个叫age的字段
fieldAge.setAccessible(true);//使得该私有age可以被获取
Object age = fieldAge.get(tc)//获取tc的私有age
int intage = (int)age;
见实例代码test3()
1.5如何获取到该类创建的对象中的公有及私有的方法呢？xx.getMethod().invoke()或者xx.getDeclaredMethod().setAccessible().invoke();
注意：获得公有私有的属性和方法时，必须指定获取哪个对象的，必须创建好一个对象。
Class xx = TestClass.class;
Constructor cst = xx.getConstructor();//无参构造方法
Object obj = cst.newInstance();//这个也不能有参数
TestClass tc = (TestClass)obj;//转换为该类的对象
//获得公有的无参的方法:
Method mt1 = xx.getMethod("showPublic");//指定获取哪个方法（showPublic()方法）
mt1.invoke(tc);//获取对象tc中的showPublic()方法
//获得公有的带参的方法:
Method mt2 = xx.getMethod("showPublicParams", String.class,int.class);//指定获取哪个方法，并指定带哪种参数（showPublicParams(String,int)方法）
mt2.invoke(tc1, "刘二麻子",23);//获取对象tc中的showPublicParams并指定传进两个实参
//获得私有的无参方法【两步：1.获得声明的方法；2.让该方法可视化】
Method mt3 = xx.getDeclaredMethod("showPrivate");//获取哪个私有方法(showPrivate()方法)
mt3.setAccessible(true);//该方法可被获取，即可视化
mt3.invoke(tc);//获取对象tc中的showPrivate()方法
见实例代码test4()
1.6如果一个方法中的参数带了泛型，怎么获取该参数以及泛型参数的类型？如参数为(List,int)
见实例代码test5()。其中，getGenericParameterTypes 只能获取方法的参数列表中的类型，返回的是一个类型数组[list类型,int类型];ParameterizedType是Type的子接口,需要向下转型为ParameterizedType，然后再使用方法getActualTypeArguments获取泛型的参数类型，返回的是个类型数组[People类型,String类型]。
见实例代码test5()
2、实例代码：
TestClass.java的代码【有公有私有属性，有公有私有方法，有带返回值的方法，有带泛型的方法】如下：
package com.dou.reflect;

import java.util.List;

public class TestClass {
       public String name = "张三";//公有属性
       private int age = 28;//私有属性

       public TestClass() {//带参构造
              super();
              // TODO Auto-generated constructor stub
       }

       public TestClass(String name, int age) {//满参构造
              super();
              this.name = name;
              this.age = age;
       }

       public void showPublic() {//无参共有方法
              System.out.println("这是无参共有方法showPublic()->" + this.name + ":" + this.age);
       }
       public void showPublicParams(String name, int age) {//带参公有方法
              System.out.println("这是带参共有方法showPublicParams(String,int)->" + name + ":" + age);
       }
       public String showHello(){//带返回值公有无参方法
              return "hello word";
       }
       public void showParameterized(List list,int num){//带泛型公有方法
              for (String str : list) {
                     System.out.println(str+num);
              }
       }
      
       private void showPrivate() {//无参私有方法
              System.out.println("这是无参私有有方法showPrivate()->" + this.name + ":" + this.age);
       }
}
//--------------
ReflectDemo.java的代码【常用反射方法】如下：
package com.dou.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

import org.junit.Test;

public class ReflectDemo2 {
      
       @Test
       //获得带返回值的方法，以及参数类型和参数化的类型。如List的TestClass类型
       public void test5() throws Exception {
              Class clazz1 = TestClass.class;
              TestClass tc1 = (TestClass)clazz1.newInstance();
              Method m1 = clazz1.getMethod("showHello");
              String str = (String) m1.invoke(tc1);
              System.out.println(str);
             
              //参数类型showParameterized(List list,int num)
              Method m2 = clazz1.getMethod("showParameterized", List.class,int.class);
              //获得你这个method对象（某个方法）的参数列表
              Type[] types = m2.getGenericParameterTypes ();
              for (Type type : types) {
                     System.out.println(type.toString());
                     //java.util.List
                     //int
              }
             
              //获得泛型的类型,ParameterizedType是Type的子接口，代表参数化类型
              Type tp = m2.getGenericParameterTypes ()[0];//参数列表中的第一个参数
              ParameterizedType ptp = (ParameterizedType)tp;
              //getActualTypeArguments获得泛型参数列表里的泛型的类型
              Type T_type = ptp.getActualTypeArguments()[0];//泛型里的第一个参数列表
              System.out.println(T_type.toString());//class java.lang.String
       }
      
       @Test
       //通过反射方法，获取类创建的对象中获取公有和私有方法
       public void test4() throws Exception {
              //showPublic/showPublicParams/showPrivate
              Class clazz1 = TestClass.class;
              TestClass tc1 = (TestClass)clazz1.newInstance();//创建一个被获取的对象
              //获得公有的无参的方法
              Method mt1 = clazz1.getMethod("showPublic");
              mt1.invoke(tc1);
              //获得公有的带参的方法
              Method mt2 = clazz1.getMethod("showPublicParams", String.class,int.class);
              mt2.invoke(tc1, "刘二麻子",23);
             
              //获得私有的无参方法【两步：1.获得声明的方法；2.让该方法可视化】
              Method mt3 = clazz1.getDeclaredMethod("showPrivate");//获取私有方法
              mt3.setAccessible(true);//该方法可视化
              mt3.invoke(tc1);
       }
      
       @Test
       //通过反射方法，获取类中的公有属性和私有属性
       public void test3() throws Exception {
              Class clazz1 = TestClass.class;
              //获取公有属性[需要一个获取哪个对象的实际对象]
              Field f1 = clazz1.getField("name");
              TestClass tc1 = (TestClass)clazz1.newInstance();
              Object name1 = f1.get(tc1);
              System.out.println("默认构造函数对象的公有属性name值："+name1);
             
              //想用带参的，则需要用constructor方法指定参数
              Constructor cs1 = clazz1.getConstructor(String.class,int.class);
              TestClass tc2 = (TestClass)cs1.newInstance("李四",18);
              Field fl2 = clazz1.getField("name");
              Object name2 = fl2.get(tc2);
              System.out.println("带参构造函数对象的公有属性name值："+name2);
             
              //想获取私有的属性age【两步：1.获取私有属性方法getDeclaredField()；2.将私有属性可视化setAccessible();】
              Field fl3 = clazz1.getDeclaredField("age");//获取私有属性的特有方法
              fl3.setAccessible(true);//将私有属性公开可视化的方法
              Object age = fl3.get(tc2);
              System.out.println("私有属性age的值："+age);
       }

       @Test
       //根据类文件，通过构造器getConstructor()创建对象，可以调用带参的构造方法创建带参的对象
       public void test2() throws Exception {
              Class clazz1 = TestClass.class;
              //默认无参的构造方法创建对象
              Constructor cc = clazz1.getConstructor();
              TestClass tc1 = (TestClass)cc.newInstance();
              tc1.showPublic();
              //想调用有参的构造方法，创建带参的对象
              Constructor cc2 = clazz1.getConstructor(String.class,int.class);
              TestClass tc2 = (TestClass)cc2.newInstance("李四",18);
              tc2.showPublic();
       }
      
       @Test
       //通过类的类对象.newInstance()创建一个对应的无参对象
       public void test1() throws Exception{
              Class clazz1 = Class.forName("com.dou.reflect.TestClass");
              Object obj = clazz1.newInstance();
              TestClass tc = (TestClass)obj;
              tc.showPublic();
       }
      
              @Test
       public void test0() throws Exception{
              //活动Class对象的三种方法
              //getClassLoader()只能获取工程编译后的classes文件夹下的所有资源，而对应的工程路径就是src下的路径
              //所有放配置文件放在src下，通过类加载器来获取当前工程下的资源，是最常用的方法
              //Class.forName(类的全包名)
              Class clazz1 = Class.forName("com.dou.reflect.ReflectDemo1");
              ClassLoader classLoader = clazz1.getClassLoader();
              URL resource = classLoader.getResource("prop.properties");
              String path = resource.getPath();
              System.out.println(path);
             
              //2.类.class()
              Class clazz2 = ReflectDemo1.class;
              ClassLoader cl = clazz2.getClassLoader();
              InputStream in = cl.getResourceAsStream("prop.properties");
              Properties prop = new Properties();
              prop.load(in);
              System.out.println("prop.properties加载完成");
              Setkeys = prop.keySet();
              for (Object object : keys) {
                     String value = prop.getProperty((String)object);
                     System.out.println(object+"="+value);
              }
             
              //3.对象.getClass()
              TestClass ts = new TestClass();
              ts.showPublic();
              Class clazz3 = ts.getClass();
              ClassLoader csl = clazz3.getClassLoader();
              URL url = csl.getResource("prop.properties");
              String path2 = url.getPath();
              System.out.println("prop.properties的全路径："+path2);
       }
      
       @Test
       public void test() throws Exception{
              //获取src、classes路径下的资源全路径，并加载到文件流中
              //传统两步
              String path = ReflectDemo1.class.getClassLoader().getResource("prop.properties").getPath();
              InputStream is = new FileInputStream(path);
              System.out.println("prop.properties文件完成加载1");
             
              //一步走
              InputStream ins = ReflectDemo1.class.getClassLoader().getResourceAsStream("prop.properties");
              System.out.println("prop.properties文件完成加载2");
       }

}

幻灯播放