Java反射操作

因为要开始学习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();
	}
}

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值