Java反射常用方法

Posted 2023-02-09 未定_

以下代码来源

package cs;

public class Animal 
	//属性
	public double height;
	//方法
	public void h1()
	
	
	public Animal(double height) 
		this.height = height;
	
	public Animal() 
		


package cs;

interface IA	

interface IB

@Deprecated
//此方法已作废，暂时可用，以后可能会删除
public class Cat extends Animal implements IA,IB 

	public String name;
	protected int age;
	String work;
	private double weight;
	
	
	//构造函数
	public Cat() 
	
	public Cat(double height) 
	
	public Cat(double height, String name, int age, String work, double weight) 
		super(height);
		this.name = name;
		this.age = age;
		this.work = work;
		this.weight = weight;
	
	private Cat(String name, int age)
	
	
	//方法
	public void m1(String name, int age, String work)
		
	
	protected String m2()
		return null;
	
	void m3()
	private void m4()


package cs;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test 

	public static void main(String[] args) throws ClassNotFoundException 
		//得到class对象
		Class Catcls = Class.forName("cs.Cat");
		
		//获取全类名
		System.out.println(Catcls.getName());//cs.Cat
		
		//获取简单类名
		System.out.println(Catcls.getSimpleName());//Cat
		
		//获取本类以及继承父类所有public修饰的属性
		Field[] fields = Catcls.getFields();
		for(Field field:fields)
			System.out.println("本类以及父类所有public属性="+field.getName());
			/*本类以及父类所有public属性=name
			本类以及父类所有public属性=height*/
		
		
		//获取本类所有属性(不包含继承属性)
		Field[] declaredFields=Catcls.getDeclaredFields();
		for(Field declarefield:declaredFields)
			System.out.println("本类所有属性="+declarefield.getName()
					+" 该属性的修饰符值="+declarefield.getModifiers()
					+" 该属性的类型="+declarefield.getType());
		   /*本类所有属性=name 该属性的修饰符值=1 该属性的类型=class java.lang.String
			本类所有属性=age 该属性的修饰符值=4 该属性的类型=int
			本类所有属性=work 该属性的修饰符值=0 该属性的类型=class java.lang.String
			本类所有属性=weight 该属性的修饰符值=2 该属性的类型=double*/
			//规定：默认修饰符是0,public是1,private是2,protected是4,static是8,final是16,public static是1+8=9
		
		
		//获取本类以及继承父类所有Public修饰的方法
		Method[] methods=Catcls.getMethods();
		for (Method method : methods) 
			System.out.println("本类以及父类所有public方法="+method.getName());//包含了object
			/*本类以及父类所有public方法=m1
			本类以及父类所有public方法=h1
			本类以及父类所有public方法=wait
			本类以及父类所有public方法=wait
			本类以及父类所有public方法=wait
			本类以及父类所有public方法=equals
			本类以及父类所有public方法=toString
			本类以及父类所有public方法=hashCode
			本类以及父类所有public方法=getClass
			本类以及父类所有public方法=notify
			本类以及父类所有public方法=notifyAll*/
		
		
		//获取本类中所有方法(不包含继承方法)
		Method[] declaredMethods=Catcls.getDeclaredMethods();
		for(Method declaremethod:declaredMethods)
			System.out.println("本类所有方法="+declaremethod.getName()
					+" 该方法的访问修饰符值="+declaremethod.getModifiers()
					+" 该方法返回类型="+declaremethod.getReturnType());
			//输出当前这个方法的形参数组情况
			Class[] parameterTypes=declaremethod.getParameterTypes();
			for(Class parametertype:parameterTypes)
				System.out.println("该方法的形参类型="+parametertype);
			
			/*本类所有方法=m3 该方法的访问修饰符值=0 该方法返回类型=void
			本类所有方法=m1 该方法的访问修饰符值=1 该方法返回类型=void
			该方法的形参类型=class java.lang.String
			该方法的形参类型=int
			该方法的形参类型=class java.lang.String
			本类所有方法=m4 该方法的访问修饰符值=2 该方法返回类型=void
			本类所有方法=m2 该方法的访问修饰符值=4 该方法返回类型=class java.lang.String*/
		
		
		//获取本类所有public修饰的构造函数
		Constructor[] constructors=Catcls.getConstructors();
		for(Constructor constructor:constructors)
			System.out.println("本类公有构造函数="+constructor.getName());
			/*本类公有构造函数=cs.Cat
		          本类公有构造函数=cs.Cat
			本类公有构造函数=cs.Cat*/
			//只是输出名字，不包含参数
		
		
		//获取本类所有构造函数
		Constructor[] declaredConstructors=Catcls.getDeclaredConstructors();
		for(Constructor declaredConstructor:declaredConstructors)
			System.out.println("--------------------------------");
			System.out.println("本类所有的构造函数="+declaredConstructor.getName());
			Class[] parameterTypes=declaredConstructor.getParameterTypes();
			for(Class parameterType:parameterTypes)
				System.out.println("该构造函数参数类型="+parameterType);
			
			/*本类所有的构造函数=cs.Cat
			该构造函数参数类型=class java.lang.String
			该构造函数参数类型=int
			--------------------------------
			本类所有的构造函数=cs.Cat
			该构造函数参数类型=double
			该构造函数参数类型=class java.lang.String
			该构造函数参数类型=int
			该构造函数参数类型=class java.lang.String
			该构造函数参数类型=double
			--------------------------------
			本类所有的构造函数=cs.Cat
			该构造函数参数类型=double
			--------------------------------
			本类所有的构造函数=cs.Cat*/
		
		
		//返回包信息
		System.out.println(Catcls.getPackage());//package cs
		
		//以Class形式返回父类信息
		Class superclass=Catcls.getSuperclass();
		System.out.println(superclass);//class cs.Animal
		
		//以Class[]形式返回接口信息
		Class[] interfaces=Catcls.getInterfaces();
		for(Class aninterfaces:interfaces)
			System.out.println("接口信息="+aninterfaces);
			/*接口信息=interface cs.IA
			接口信息=interface cs.IB*/
		
		
		//以Annotation[]形式返回注解信息
		Annotation[] annotations=Catcls.getAnnotations();
		for(Annotation annotation:annotations)
			System.out.println("注解信息="+annotation);
			//注解信息=@java.lang.Deprecated()
		
	

通过反射创建对象

package cs1;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class reflect 
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException
		//1.先获取到User类的Class对象
		Class userClass=Class.forName("cs1.User");
		
		//2.通过public的无参构造函数创建实例
		Object o=userClass.newInstance();
		System.out.println("public的无参构造函数="+o);
		
		//3.通过public的有参构造函数创建实例
		Constructor<?> constructor=userClass.getConstructor(String.class);//得到构造函数
		Object user=constructor.newInstance("未定");//创建实例并传入实参
		System.out.println("public的有参构造函数="+user);
		
		//4.通过非public的有参构造函数创建实例
		Constructor<?> constructor1=userClass.getDeclaredConstructor(int.class,String.class);//得到私有构造函数
		constructor1.setAccessible(true);//爆破，非常重要，使用反射可以访问private构造函数、方法、属性
		Object user1=constructor1.newInstance(18,"空");
		System.out.println("private的有参构造函数="+user1);
	

class User
	private int age=12;
	private String name="派蒙";
	
	public User()
	
	public User(String name)
		this.name=name;
	
	private User(int age,String name)
		this.age=age;
		this.name=name;
	
	public String toString() 
		return "User [age=" + age + ", name=" + name + "]";
	
	

通过反射操作属性

package cs1;

import java.lang.reflect.Field;

public class reflect_sx 
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException 
		//1.得到student类对应的Class对象
		Class<?> stuClass=Class.forName("cs1.Student");
		
		//2.创建对象
		Object o=stuClass.newInstance();
		System.out.println(o.getClass());
		System.out.println(o);
		System.out.println("-------------------------");
		
		//3.使用反射操作age属性对象
		Field age=stuClass.getField("age");
		age.set(o, 18);//通过反射操作属性
		System.out.println(o);
		System.out.println("返回age属性的值="+age.get(o));//返回age属性的值
		System.out.println("-------------------------");
		
		//4.使用反射操作name属性对象
		Field name=stuClass.getDeclaredField("name");
		name.setAccessible(true);//对name进行爆破，可以操作private属性
		name.set(null,"应急食品");//因为name是static属性，所有o也可以写为null
		System.out.println(o);
		System.out.println("返回name属性的值="+name.get(o));//返回name属性的值,因为是静态的,o也可以写为null
	


class Student
	public int age;
	private static String name;
	
	public Student()
	

	public String toString() 
		return "Student [age=" + age + ", name=" + name + "]";
	

通过反射操作方法

package cs1;

import java.lang.reflect.Method;

public class reflect_ff 

	public static void main(String[] args) throws Exception  

		//1.得到Boss类对应的Class对象
		Class<?> bosscls=Class.forName("cs1.Boss");
		
		//2.创建对象
		Object o=bosscls.newInstance();
		
		//3.调用public的hi方法
		//Method hi=bosscls.getMethod("hi",String.class); //法1
		Method hi=bosscls.getDeclaredMethod("hi",String.class);//得到hi方法对象
		hi.invoke(o,"未定");//调用
		
		//4.调用private static方法
		Method say=bosscls.getDeclaredMethod("say", int.class, String.class, char.class);
		say.setAccessible(true);//爆破
		System.out.println(say.invoke(o, 10, "空", '男'));//static方法，o可以写为null
		
		//5.在反射中，如果方法有返回值，统一返回Object，其运行类型和方法定义的返回类型一致
		Object reval=say.invoke(null, 18,"未定",'女');
		System.out.println("reval的运行类型="+reval.getClass());
	

class Boss
	public int age;
	private static String name;

	public Boss()	
	
	private static String say(int n,String s,char c)
		return n+" "+s+" "+c;
	
	public void hi(String s)
		System.out.println("hi "+s);