简析java反射

一.什么是反射：

java反射机制是在运行状态中，对于任意一个类，都能知道这个类的所有属性和方法；对于任意一个对象，都能调用它的任意方法和属性；反射就是把java类中的各个成分映射成一个个对象；它是框架设计的灵魂。

二.反射的作用：

1. 编译：.java->.class 编译：.class->.java

2.通过反射机制访问java对象的属性，方法和构造方法等

三.具体功能实现：

1.反射之获取类的对象：

2.根据类得到全限定名：

3.Filed类属性：

例如：

person实体类：

public String pid;
private String pname;
private String psex;
public Person() {
	super();
	// TODO Auto-generated constructor stub
}
public Person(String pid, String pname, String psex) {
	super();
	this.pid = pid;
	this.pname = pname;
	this.psex = psex;
}

demon类：

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

		// 得到类的对象
		Class c = Class.forName("com.zking.Person");
		// 获取公共属性
		Field f = c.getField("pid");
		// 获取属性名
		System.out.println(f.getName());
		// 得到访问修饰符 public=1 private =2 protected=4 static=8 final=16  默认=0
		System.out.println(f.getModifiers());
		// 得到属性的数据类型
		System.out.println(f.getType());
		// 属性赋值
		// 得到一个实例化对象 newInstance产生一个新的实例 (实例化对象)
		Object person = c.newInstance();
		// 实例
		f.set(person, "001");
		// 取值
		System.out.println(f.get(person));
	 
 	 //获取属性
    	 Field f1= c.getDeclaredField("pname");
   	 //设置私有的属性能够被访问
    	 f1.setAccessible(true);
 	 System.out.println(f1);
 	 Object  person1=c.newInstance();
 	 f1.set(person1, "王嘉尔");
      System.out.println(f1.get(person1));
		
		
     //获取当前类中的所有的属性
 		Field[] fields=c.getDeclaredFields();
 		Object person=null;
 		for (Field f : fields) {
 			f.setAccessible(true);
 			person=c.newInstance();
 			if("pid".contains(f.getName())) {
 				f.set(person, "002");
 			}else if("pname".contains(f.getName())) {
 				f.set(person, "李易峰");
 			}else if("psex".contains(f.getName())) {
 				f.set(person, "男");
 			}
 			System.out.println(f.get(person));
 		}
 	 //得到父类
 		Class c1=Person.class.getSuperclass();
 	    System.out.println(c1);
		}

注意：getModifiers()获取的修饰符输出

得到访问修饰符 public=1 private =2 protected=4 static=8 final=16 默认=0

4.Method方法：

5.构造方法：

例如：

IPerson接口类：

public interface IPerson {
	
	//无参无返回方法
   public void m1();

	//无参有返回方法
   public String m2();
   
	//有参数无返回方法
	public  void m3(String str);

	//有参数有返回方法
	public String m4(Object index,String str);
}

Person实现类：

public class Person implements IPerson {
	

public String pid;
private String pname;
private String psex;
public Person() {
	super();
	// TODO Auto-generated constructor stub
}
public Person(String pid, String pname, String psex) {
	super();
	this.pid = pid;
	this.pname = pname;
	this.psex = psex;
}
@Override
public void m3(String str) {
	// TODO Auto-generated method stub
	System.out.println(str);
	
}
@Override
public String m4(Object index,String str) {
	// TODO Auto-generated method stub
	return  index+str;
}
@Override
public void m1() {
	// TODO Auto-generated method stub
	System.out.println("m1");
}
@Override
public String m2() {
	// TODO Auto-generated method stub
	return "m2";
}

}

demon类：

public class demo1 {
//	<1>新建实体类Person
//	<2>三个字段：pid pname psex
//	<3>要求该类有父类，并且实现多接口
//	<4>通过反射得到该类所有的属性和方法，父类和实现接口
	public static void main(String[] args) throws Exception {

//		// 得到类的对象
//		Class c = Class.forName("com.zking.Person");
//		// 获取公共属性
//		Field f = c.getField("pid");
//		// 获取属性名
//		System.out.println(f.getName());
//		// 得到访问修饰符 public=1 private =2 protected=4 static=8 final=16  默认=0
//		System.out.println(f.getModifiers());
//		// 得到属性的数据类型
//		System.out.println(f.getType());
//		// 属性赋值
//		// 得到一个实例化对象 newInstance产生一个新的实例 (实例化对象)
//		Object person = c.newInstance();
//		// 实例
//		f.set(person, "001");
//		// 取值
//		System.out.println(f.get(person));
	 
//	 //获取属性
//   	 Field f1= c.getDeclaredField("pname");
//   	 //设置私有的属性能够被访问
//   	 f1.setAccessible(true);
//	 System.out.println(f1);
//	 Object  person1=c.newInstance();
//	 f1.set(person1, "王嘉尔");
//     System.out.println(f1.get(person1));
		
		
//    //获取当前类中的所有的属性
//		Field[] fields=c.getDeclaredFields();
//		Object person=null;
//		for (Field f : fields) {
//			f.setAccessible(true);
//			person=c.newInstance();
//			if("pid".contains(f.getName())) {
//				f.set(person, "002");
//			}else if("pname".contains(f.getName())) {
//				f.set(person, "李易峰");
//			}else if("psex".contains(f.getName())) {
//				f.set(person, "男");
//			}
//			System.out.println(f.get(person));
//		}
//	 //得到父类
//		Class c1=Person.class.getSuperclass();
//	    System.out.println(c1);
		
		
//			<5>并调用方法（无参无返回，无参有返回，有参数无返回，有参数有返回）
	    Class c=Class.forName("com.zking.Person");
	    Object o=c.newInstance();
	    //1.有参数无返回方法
	    Method m3=c.getMethod("m3", String.class);
	    m3.invoke(o, "王嘉尔");
	   // 2.有参数有返回方法
	    Method m4=c.getMethod("m4",Object.class, String.class);
	    System.out.println( m4.invoke(o, "24 ","王嘉尔"));
	    //3.无参无返回方法
	    Method m1=c.getMethod("m1", null);
	    m1.invoke(o, null);
	    //4.无参有返回方法
	    Method m2=c.getMethod("m2", null);
	    System.out.println(m2.invoke(o, null));
	}
	
}

综上为， JAVA 反射的再次学习，灵活的运用它，能够使我们的代码更加灵活，但是它也有它的缺点，就是运用它会使我们的软件的性能降低，复杂度增加，所以还要我们慎重的使用它。

猜你喜欢