手机版 欢迎访问it开发者社区(www.mfbz.cn)网站

当前位置: > 开发

Java反射之Class、Field、Method

时间:2021/4/30 8:36:52|来源:|点击: 次
  • 获取class的实例的方式
//方式一:调用运行时类的属性:.class
Class clazz1=Person.class;
System.out.println(clazz1);
//方式二:调用运行时类的对象,调用getClass()
Person p1=new Person();
Class clazz2=p1.getClass();
System.out.println(clazz2);
//方式三:调用Class的静态方法:forName(String classPath)
Class clazz3=Class.forName("com.atguigu.java.Person"); 
//方式四:使用类的加载器classLoader
ClassLoader classLoader=ReflectionTest.class.getClassLoader();
Class clazz4=classLoader.loadClass("com.atguigu.java.Person");
System.out.println(clazz4);

  • 哪些类型可以有class对象?
    1、class:
    外部类,成员(成员内部类,静态内部类),局部内部类,匿名内部类
    2、接口
    3、数组
    4、枚举
    5、annotation :注解
    6、基本数据类型
    7、void

  • Properties:用来读取配置文件

public void test2() throws Exception{
	Properties pros=new Properties();
	FileInputStream fis=new FileInputStream("jdbc.properties");
	pros.load(fis);
	String user=pros.getProperty("user");
}
  • classLoader来读取配置文件
Properties pros=new Properties();
ClassLoader classLoader=ClassLoaderTest.class.getClassLoader();
InputStream is=classLoader.getResourceAsStream("jdbc.properties");
pros.load(is);

  • java反射知识要领
    1、java反射机制概述
    2、理解Class类并获取Class实例
    3、类的加载与ClassLoader的理解
    4、创建运行时类的对象
    5、获取运行时类的完整结构
    6、调用运行时类的指定结构
    7、反射的应用:动态代理

  • 获取运行时类的属性结构

public class FieldTeset{
	public void test1(){
		Class clazz=Person.class;
		//获取属性结构
		//getFields():获取当前运行时类及其父类中声明为public访问权限的属性
		Filed[] fields=clazz.getFields();
		for(Filed f : fields){
			System.out.println(f);
		}

		//获取过类声明的所有属性(不包括父类的)
		Field[] declaredFields = clazz.getDeclaredFields();
		for(Field f : declaredFields){
			System.out.println(f);
		}
	}

	//权限修饰符 数据类型 变量名
	public void test2(){
		Class clazz=Person.class;
		Field[] declaredFields=clazz.getDeclaredFields();
		for(Field f : declaredFields){
			//权限修饰符
			int modifier=f.getModifiers();
			System.out.println(Modifier.toString(modifier));
			//数据类型
			Class type=f.getType();
			System.out.println(type.getName());
			//变量名
			String fName=f.getName();
			System.out.println(fName);
		}
	}
}
  • 获取运行时类的方法结构
public class MethodTest{
	public void test1(){
		Class clazz=Person.class;
	
		//getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
		Method[] methods=clazz.getMethods();
		for(Method m : methods){
			System.out.println(m)
		}
	}
	
	//getDeclaredMethods:获取当前运行时类中声明的所有方法(不包含父类中声明的方法)
	Method[] declaredMethods=clazz.getDeclareMethods();
	for(Method m : declaredMethods){
		System.out.println(m);
	}
	
	//获取方法声明的注解
	Class clazz=Person.class;
	Method[] declaredMethods=clazz.getDeclaredMethods();
	for(Method m : declaredMethods){
		//获取方法声明的注解
		Annotation[] annos=m.getAnontations();
		for(Annontation a : annos){
			System.out.println(a);
		}

		//返回值类型
		System.out.println(m.getReturnType().getName);
		//方法名
		m.getName();
		//形参列表
		Class[] parameterTypes=m.getParameterTypes();
		if(!parameterTypes==null && parameterTypes.length==0){
			for(Class p : parameterTypes){
				System.out.println(p.getName() + "arg_" )
			}
		}

		//抛出的异常
		Class[] ex=m.getExceptionTypes();
		if(!(exceptionTypes==null && exceptionTypes.length==0))		
		{
			System.out.println("throws ");
			for(int i=0;i<exceptionTypes.length;i++){
				System.out.println(exceptionType[i].getName()) 
			}
		}
	}
}
  • 获取构造器结构
public class OtherTest{
	//获取构造器结构
	public void test1(){
		Class Clazz=Person.class;
		//getConstructors():获取当前运行时类中声明为public的构造器
		Constructor[] constructor=clazz.getConstructors(); 
		for(Constructor c : constructors){
			System.out.println(c);
		}
		
		System.out.println();
		//getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
		Constructor[] declaredConstructors=clazz.getDeclaredConstructors();
		for(Constructor c : declaredConstructors){
			System.out.println(c);
		}
	}

}
  • 获取运行时类的父类
public void test2(){
	Class clazz=Person.class;
	Class superClass=clazz.getSuperclass();
	System.out.println(superClass);
	
}
  • 获取运行时类的带泛型的父类
public void test3(){
	Class clazz=Person.class;
	Type genericSuperclass=clazz.getGenericSuperclass();
	System.out.println(genericSuperclass);
	
}
  • 获取运行时类的带泛型的父类的泛型
public void test4(){
	Class clazz=Person.class;
	Type genericSuperclass=clazz.getGenericSuperclass();
	//关键
	ParameterizedType paraType=(ParameterizedType)genericSuperclass;
	//获取泛型类型
	paraType.getActualTypeArguments();
	System.out.println(genericSuperclass);
}
  • 获取运行时类实现的接口
public void test5(){
	Class clazz=Person.class;
	Class[] interfaces=clazz.getInterfaces();
	for(Class c : interfaces){
		System.out.println(c);
	}
}
  • 获取运行时类所在的包
public void test6(){
	Class clazz=Person.class;
	Package pack=clazz.getPackage();
	System.out.println(pack);
}
  • 获取运行时类声明的注解
public void test7(){
	Class clazz=Person.class;
	Annotation[] annotations=clazz.getAnnotations();
	for(Annotation annos : annotations){
		System.out.println(annos);
	}
}
  • 调用运行时类的指定属性
public void testField(){
	Class Clazz=Person.class;
	//创建运行时类的对象
	Person p=(Person)clazz.newInstance();
	//获取指定的属性,要求运行时类中属性声明为public
	Field id=clazz.getField("id");
	//设置当前属性的值
	//set():参数1,指明设置哪个对象的属性  参数2:将此属性值设置为多少
	id.set(p,1001);
	//获取当前属性的值
	//get():参数1:获取哪个对象的当前属性值
	id.get(p);
}

public void testField1(){
	Class clazz=Person.class;
	//创建运行时类的对象
	Person p=(Person)clazz.newInstance();
	//获取运行时类中指定变量名的属性
	Field name=clazz.getDeclaredField("name");
	//保证当前属性是可访问的
	name.setAccessible(true);
	//获取、设置指定对象的此属性值
	name.set(p,"Tome");
	System.out.println(name.get(p));
}


//操作运行时类中的指定的方法
public void testMehod(){
	Class clazz=Person.class;
	Person p=(Person)clazz.newInstance();
	//获取指定的某个方法
	//参数1:指明获取的方法的名称,参数2:指明获取的方法的形参列表
	Method show=clazz.getDeclaredMethod("show",String.class);
	//保证当前方法是可访问的
	show.setAccessible(true);
	//参数1:方法的调用者,参数2,给方法形参赋值的实参
	//invoke的返回值即为对应类中调用的方法的返回值
	show.invoke(p,"CHN");
	
}

  • 获取运行时类中的指定的构造器
public void testConstructor(){
	Class clazz=Person.class;
	Constructor constructor=Clazz.getDeclaredConstructor(String.class);

	//保证此构造器是可访问的
	constructor.setAccessible(true);

	//调用此构造器创建运行时类的对象
	Person per=(Person)constructor.newInstance("Tom");
	
}

Copyright © 2002-2019 某某自媒体运营 版权所有