Java反射操作

浅浅的花香味﹌ 2022-02-03 05:23 167阅读 0赞

### 因为要开始学习Java框架，所以特地简单的学习了一下Java的反射，只是一些基础的使用并没有涉及比较深层次的东西，比较适合小白..... ###

# 一.先进行准备工作： #

在这里我定义了2个接口:MyInterface MyInterface2

1个实体类： Person

由实体类继承了两个接口；

两个接口：

package cn.skh.reflect;
    
    public interface MyInterface {
         void interfaceMethod() ;
    }
    package cn.skh.reflect;
    
    public interface MyInterface2 {
         void Interface02() ;
    }

实体类：

package cn.skh.reflect;
    
    public class Person implements MyInterface,MyInterface2{
        private int age;
        private String name;
        private int id;
    	@Override
    	public void interfaceMethod() {
    		System.out.println("Interface Method.....");		
    	}
    	public static void staticMethod() {
    		System.out.println("This is Static Method......");
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public Person(int age, String name, int id) {
    		this.age = age;
    		this.name = name;
    		this.id = id;
    	}
    	public Person(int id) {
    		
    		this.id = id;
    	}
    	public Person() {
    		
    	}
    	private Person(String name) {
    		this.name = name;
    	}
        private void privateMethod() {
        	System.out.println("This is a privateMethid...");
        }
        private void privateMethod2(String name) {
        	System.out.println("privateMethod...."+name);
        }
    	@Override
    	public void Interface02() {
    		System.out.println("This is a Interface02 Method......");
    		
    	}
    }

# 二、反射Demo #

1.demo01：通过反射获取类的基本信息： 更具体的说明都写在了代码的注释里面，这里就不在叙述。

tips：你会发现在下面的代码中，不管是获取方法还是属性都会有两个方法 区别就是Declared的有无，在这里说明一下，有它只能获取当前的属性，不管是私有还是公有都可以。如果没有这个declared那么只能得到公有属性，但他的范围变大了，不仅可以得到当前类的，也可以获取父类的和所继承的接口的方法，但只能是public

package cn.skh.reflect;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    public class ReflectDemo01 {
    	//通过反射获取类
    	public static void demo01() {
    		//获取反射对象（反射入口）：Class ，1 Class.forName(全类名)   2 类名.class  3 对象.getClass()
    		//1 Class.forName("全类名")
    		try {
    			Class<?> perClazz =  Class.forName("cn.skh.reflect.Person") ;
    			System.out.println(perClazz);
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    		
    //		 2 类名.class
    		Class<?> perClazz2 = Person.class ;
    		System.out.println(perClazz2);
    		
    //		 3 对象.getClass()
    		Person per = new Person();
    		Class<?> perClazz3 = per.getClass() ;
    		System.out.println(perClazz3);
    	}
     
    	//获取公共方法
    	public static void demo02() {
    		//Class入口
    		Class<?> perClazz =  null ; 
    		try {
    			perClazz =  Class.forName("cn.skh.reflect.Person") ;
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    		//获取所有的 公共的方法(1.本类 以及 父类、接口中的所有方法  2.符合访问修饰符规律)
    		  Method[] methods = perClazz.getMethods();
    		  for(Method method:methods) {
    			  System.out.println(method);
    		  }
    		  System.out.println("==========");
    		  //获取当前类的所有方法（1.只能是当前类   2.忽略访问修饰符限制）
    		  Method[] declaredMethods = perClazz.getDeclaredMethods();
    		  for(Method declaredMethod:declaredMethods) {
    			  System.out.println(declaredMethod);
    		  }
    	}
    	//获取所有的接口
    	public static void demo03() {
    		Class<?> perClazz =  null ; 
    		try {
    			perClazz =  Class.forName("cn.skh.reflect.Person") ;
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    		
    		Class<?>[] interfaces = perClazz.getInterfaces() ;
    		for(Class<?> inter:interfaces) {
    			System.out.println(inter);
    		}
    	}
    	
    	//获取所有的父类
    		public static void demo04() {
    			Class<?> perClazz =  null ; 
    			try {
    				perClazz =  Class.forName("cn.skh.reflect.Person") ;
    			} catch (ClassNotFoundException e) {
    				e.printStackTrace();
    			}
    			Class<?> superclass = perClazz.getSuperclass() ;
    			System.out.println(superclass);
    			
    		}
    	
    		
    		//获取所有的构造方法
    		public static void demo05() {
    			Class<?> perClazz =  null ; 
    			try {
    				perClazz =  Class.forName("cn.skh.reflect.Person") ;
    			} catch (ClassNotFoundException e) {
    				e.printStackTrace();
    			}
    			Constructor<?>[] constructors = perClazz.getConstructors() ;
    			for(Constructor<?> constructor:constructors) {
    				System.out.println(constructor);
    				
    			}
    		}
    	
    		//获取所有的公共属性
    		public static void demo06() {
    			Class<?> perClazz =  null ; 
    			try {
    				perClazz =  Class.forName("cn.skh.reflect.Person") ;
    			} catch (ClassNotFoundException e) {
    				e.printStackTrace();
    			}
    			//公共属性
    			Field[] fields = perClazz.getFields() ;
    			for(Field field:fields) {
    				System.out.println(field);
    			}
    			System.out.println("====");
    			//所有属性  (属性的 ：公共属性\所有属性的区别 同“方法”)
    			Field[] declaredFields = perClazz.getDeclaredFields() ;
    			for(Field declaredField:declaredFields) {
    				System.out.println(declaredField);
    			}
    		}
    	
    	//获取当前反射所代表类（接口） 的对象（实例）
    	public static void demo07() throws InstantiationException, IllegalAccessException {
    		Class<?> perClazz =  null ; 
    		try {
    			perClazz =  Class.forName("cn.skh.reflect.Person") ;
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    		
    		Object instance = perClazz.newInstance() ;
    		Person per = (Person)instance ;
    		per.Interface02(); 
    	}	
    	public static void main(String[] args) throws InstantiationException, IllegalAccessException {
    //		demo01();
    //		demo02();
    //		demo03();
    //		demo04();
    //		demo05();
    //		demo06();
    		demo07();
    	}
    
    }

2.demo02: 通过反射获取对象实例 并操作对象

tips: 在这里需要注意的是，如果操作私有的方法或者属性，必须要暂时代开权限 才可以对私有的变量进行赋值 或者调用私有的方法：

package cn.skh.reflect;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.ArrayList;
    /*
     * 获取对象实例 并操作对象
     */
    public class ReflectDemo02 {
    	public static void demo01() throws InstantiationException, IllegalAccessException {
    		Class<?> perClazz =  null ; 
    		try {
    			perClazz =  Class.forName("cn.skh.reflect.Person") ;
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    		Person p = (Person) perClazz.newInstance();
    		p.setName("skh");
    		p.setAge(18);
    		p.setId(1);
    		System.out.println(p.getName());
    	}
    	//操作属性
    	public static void demo02() throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
    		Class<?> perClazz =  null ; 
    		try {
    			perClazz =  Class.forName("cn.skh.reflect.Person") ;
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    		Person p = (Person) perClazz.newInstance();
    		Field namefield = perClazz.getDeclaredField("name");
    		//只能设置public 可以修改权限
    		namefield.setAccessible(true);//此时私有变量也可以使用
    		namefield.set(p, "zxx");//等价于语句 p.setName("zxx"); 只能操作公有变量
    		System.out.println(p.getName());
    		System.out.println("======================");
    		Method method = perClazz.getDeclaredMethod("privateMethod2", String.class);//第一个为方法名 第二个为方法的参数类型的class入口 没有就是null
    		//因为我这个方法也是私有的 所以也要设置权限才可以调用
    		method.setAccessible(true);
    		method.invoke(p, "skh");//调用方法用invoke skh为给方法传入的参数
    	    
    	}
    	//操作构造方法
    	public static void demo03() throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
    		Class<?> perClazz =  null ; 
    		try {
    			perClazz =  Class.forName("cn.skh.reflect.Person") ;
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    		Person p = (Person) perClazz.newInstance();
    		//得到本类所有的构造方法
    	    Constructor<?>[] constructors = perClazz.getDeclaredConstructors();
    	    //获取指定的构造方法
    	    Constructor<?> constructor = perClazz.getConstructor(int.class);//无参构造的话就不需要了反射入口
    	    //在这里我们得到了构造方法 有构造方法可产生对象
    	    Person p1 = (Person) constructor.newInstance(1);
    	    //操作私有构造方法
    	    Constructor<?> constructor2 = perClazz.getDeclaredConstructor(String.class);
    	    //注意 这里也要放开权限 因为是私有的构造方法
    	    constructor2.setAccessible(true);
    	    Person p2 = (Person) constructor2.newInstance("skh");
    	    System.out.println(p+"--"+p1+"--"+p2);
    	}
    	//反射可以 越过泛型检查 
    		//虽然可以通过反射 访问private等访问修饰符不允许访问的属性/方法，也可以忽略掉泛型的约束；但实际开发 不建议这样使用，因此可能造成程序的混乱。
    		public static void demo04() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
    			ArrayList<Integer> list = new ArrayList<>() ;
    			list.add(123) ;
    			list.add(3) ;
    			list.add(2) ;
    //			list.add("zs") ; 
    			Class<?> listClazz = list.getClass() ;
    			Method method = listClazz.getMethod("add", Object.class) ;
    			method.invoke(list , "zs...") ;
    			System.out.println(list);
    		}
    		
    	public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
    		//demo01();
    		//demo02();
    		//demo03();
    		demo04();
    	}
    }

就先说这些吧，应该够用了.......