目录

文章目录

目录获取Class类型对象的三种方式Properties类通过反射创建对象读取Properties属性文件反射创建对象User类Field获取指定的成员变量Method获取指定的方法Constructor获取指定的构造方法父类父接口通过反射反编译某个类

获取Class类型对象的三种方式

Class.forName(String className); className：全限定类名全限定类名.class （java每种类型都有class属性）对象.getClass() 返回对象的运行时类 (java中任何一个对象都有getClass() 方法)

Properties类

package reflect; import java.io.FileInputStream; import java.util.Properties; public class ReflectTest { public static void main(String[] args) throws Exception { Properties p = new Properties(); FileInputStream fin = new FileInputStream("resources/jdbc.properties"); p.load(fin); //key重复则value覆盖 String p1 = p.getProperty("driver"); String p2 = p.getProperty("url"); String p3 = p.getProperty("username"); String p4 = p.getProperty("password"); System.out.println(p1); System.out.println(p2); System.out.println(p3); System.out.println(p4); } } driver=com.mysql.cj.jdbc.driver url=mysql:jdbc://localhost:3306/test?useSSL=false&serverTimezone=UTC username=root password=123456

properties配置文件的key与value之间可以空格分割或者冒号或者等号，同时出现则就近原则

通过反射创建对象

package reflect; public class A { static { System.out.println("类A已被加载到JVM中"); } public A(){ System.out.println("A的无参构造方法执行了"); } } package reflect; public class Reflect { public static void main(String[] args) throws ClassNotFoundException { Class.forName("reflect.A"); //将A.class文件加载到JVM过程中会执行类中的静态方法 Class<?> c = A.class; //不会执行A中的静态语句块 Class<?> c = Class.forName("reflect.A"); Object a = c.getConstructor().newInstance();//会调用无参构造方法，创建对象 } }

读取Properties属性文件反射创建对象

package reflect; import java.io.FileInputStream; import java.util.Enumeration; import java.util.Properties; public class ReflectTest { public static void main(String[] args) throws Exception { Properties p = new Properties(); FileInputStream fin = new FileInputStream("resources/className.properties"); p.load(fin); fin.close(); Enumeration<Object> enumeration = p.keys(); while(enumeration.hasMoreElements()){ String className = p.get(enumeration.nextElement()).toString(); Class<?> c = Class.forName(className); Object date = c.getConstructor().newInstance(); System.out.println(date); } } } date=java.util.Date

---

User类

package reflect; public class User { private int id; private String name; public String password; public User(){ System.out.println("User无参构造函数执行了..."); } public User(String name,String password){ this.name = name; this.password = password; System.out.println("User有参构造方法执行了..."); } public boolean login(String name,String password){ return "admin".equals(name) && "123".equals(password); } public void logout(){ System.out.println("用户已安全退出..."); } }

Field

package reflect; import java.lang.reflect.Field; public class Reflect { public static void main(String[] args) throws Exception { Class<?> c = Class.forName("reflect.User"); Field[] fields = c.getDeclaredFields();//获取所有的属性 //Field[] fields = c.getFields(); //1 获取被public修饰的属性 System.out.println(fields.length); //4 for(Field field : fields){ //返回成员变量的类型的Class类型全限定类名名 System.out.println(field.getType() +" "); //返回成员变量的类型的全限定类 System.out.println(field.getType().getName() + " "); //返回成员变量的类型 System.out.println(field.getType().getSimpleName()); //获取成员变量的名称 System.out.println(field.getName()); //获取成员变量的修饰符 System.out.println(Modifier.toString(field.getModifiers())); } } }

获取指定的成员变量

Class<?> c = Class.forName("reflect.User"); Object user = c.getConstructor().newInstance(); Field id = c.getDeclaredField("id"); //打破封装 id.setAccessible(true); //相当于new User().setId(21) id.set(user,21); System.out.println(id.get(user));//21

Method

public class Reflect { public static void main(String[] args) throws Exception { Class<?> c = Class.forName("reflect.User"); //获取类中的所有的方法 Method[] methods = c.getDeclaredMethods(); for(Method method : methods){ //获取方法的修饰符 System.out.println(Modifier.toString(method.getModifiers())); //获取方法的类型 System.out.println(method.getReturnType().getSimpleName()); //获取方法的名称 System.out.println(method.getName()); //获取方法形式参数列表 Class<?>[] parameterTypes = method.getParameterTypes(); for(Class parameterType : parameterTypes){ System.out.println(parameterType.getSimpleName()); } } } }

获取指定的方法

package reflect; import java.lang.reflect.Method; public class Reflect { public static void main(String[] args) throws Exception { Class<?> c = Class.forName("reflect.User"); //根据每个方法的方法签名不同来区分每个方法 Method method = c.getDeclaredMethod("login",String.class,String.class); Object user = c.getConstructor().newInstance(); //returnValue为该方法返回的值 Object returnValue = method.invoke(user,"admin","123"); System.out.println(returnValue); //true } }

Constructor

package reflect; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; public class Reflect { public static void main(String[] args) throws Exception { Class<?> c = Class.forName("reflect.User"); //获取所有的构造方法，包括无参和有参 Constructor[] constructors = c.getDeclaredConstructors(); for(Constructor constructor : constructors){ //获取构造函数的修饰符 System.out.println(Modifier.toString(constructor.getModifiers())); //获取构造函数的名称 System.out.println(constructor.getName()); //获取构造函数的形式参数列表 Class<?>[] parameterTypes = constructor.getParameterTypes(); for(Class parameterType : parameterTypes){ System.out.println(parameterType.getSimpleName()); } } } }

获取指定的构造方法

package reflect; import java.lang.reflect.Constructor; public class Reflect { public static void main(String[] args) throws Exception { Class<?> c = Class.forName("reflect.User"); //根据构造函数的形式参数列表不同区别每个构造函数 Constructor constructor = c.getDeclaredConstructor(String.class,String.class); constructor.newInstance("admin","123");//通过有参构造函数来创建User对象 } }

父类

Class<?> c = Class.forName("java.util.Date"); //父类 Object fa = c.getSuperclass(); System.out.println(fa);

父接口

Class<?> c = Class.forName("java.util.Date"); //父接口 Class<?>[] fatherInterfaces = c.getInterfaces(); for(Class<?> fatherInterface: fatherInterfaces){ System.out.println(fatherInterface); }

通过反射反编译某个类

package reflect; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; public class Reflect { public static void main(String[] args) throws Exception { Class<?> c = Class.forName("java.lang.String"); StringBuilder str = new StringBuilder(); str.append(Modifier.toString(c.getModifiers())); str.append(" class "); str.append(c.getSimpleName()); str.append("{\n"); Field[] fields = c.getDeclaredFields(); //获取成员变量 for(Field field :fields){ str.append(" "); str.append(Modifier.toString(field.getModifiers())); str.append(" "); str.append(field.getType().getSimpleName()); str.append(" "); str.append(field.getName()).append("\n"); } //获取构造方法 Constructor<?>[] constructors = c.getDeclaredConstructors(); for(Constructor<?> constructor :constructors){ str.append(" "); str.append(Modifier.toString(constructor.getModifiers())); str.append(" "); str.append(constructor.getName()); str.append("("); //获取有参构造器的形式参数 Class<?>[] parameters = constructor.getParameterTypes(); for(int i = 0;i<parameters.length;i++){ Class<?> parameter = parameters[i]; if(i == parameters.length-1){ str.append(parameter.getSimpleName()); } else{ str.append(parameter.getSimpleName()).append(","); } } str.append(")"); str.append("{}\n"); } Method[] methods = c.getDeclaredMethods(); //获取方法 for(Method method:methods){ str.append(" "); str.append(Modifier.toString(method.getModifiers())); str.append(" "); str.append(method.getReturnType().getSimpleName()); str.append(" "); str.append(method.getName()); str.append("("); //获取形参 Class<?>[] parameters = method.getParameterTypes(); for(int i = 0;i < parameters.length;i++){ Class<?> parameter = parameters[i]; if(i == parameters.length-1){ str.append(parameter.getSimpleName()); } else{ str.append(parameter.getSimpleName()).append(","); } } str.append("){}\n"); } str.append("}"); System.out.println(str); } }