黑马程序员------反射的深入学习（No.1）（Class类、Constructor类、Field类、Method类、数组的反射）

原创 于 2013-09-25 17:52:28 发布 · 1.1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Class #Constructor #Field #Method #Array

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- 

 

java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么则是由这个类的实例对象来确定的。不同的实例对象有不同的属性值。

java程序中的各个java类，他们也属于一个类，这个类就是Class。Class类描述了类的名字，类的访问属性，类所属的包名，字段名称的列表，方法名称的列表，等等。

 

学习反射，首先要明白Class类。

 

类编译成字节码，将字节码加载到内存，用字节码创建一个一个的对象

 

微笑反射的基石—>Class类

 

如何得到各个字节码的实例对象（Class类型）

A.类名.class

B.对象.getClass()

C.Class.forName("类名");

  1.一种是jvm的内存中有字节码，直接得到，不用加载。

  2.一种是是jvm中没有字节码，此时要加载进jvm中缓存起来，用的时候不用加载了。

 

九个预定义Class实例对象

8个基本数据类型+void。

int.class()==Integer.TYPE  true..

数组类型的实例对象 Class.isArray()

原始类型的实例对象 Class.Primitive()

总之，只要是在源程序中出现的类型，都有各自的Class实例对象，

package com.lee.demo;

public class ReflectDemo {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		String  str = "abc";
		Class c1 = str.getClass();
		Class c2 = String.class;
		Class c3 = Class.forName("java.lang.String");
		System.out.println(c1==c2);//true
		System.out.println(c3==c2);//true
		
		System.out.println(c1.isPrimitive());//false
		//是否是原始类型
		System.out.println(int.class.isPrimitive());//true
		System.out.println(int.class==Integer.class);//false
		System.out.println(int.class==Integer.TYPE);//true
		System.out.println(int[].class.isPrimitive());//false
		System.out.println(int[].class.isArray());//true
	}

}


微笑反射

 

反射就是把java类中的各种成分映射成为相应的java类

一个java中用一个Class类的对象来表示，一个类中的组成部分：类的成员变量，方法，构造方法，包等等信息也用一个个java的类来表示

 

Constructor类

 

  //得到某个类的所有构造方法
  Constructor[] constructors = String.class.getConstructors();
  
  //得到某个类的一个构造方法（获得方法时，要用到类型）
  Constructor constructor = String.class.getConstructor(StringBuffer.class);

  //调用获得的方法时要用到上面相同类型的实例对象
  String str = (String)constructor.newInstance(new StringBuffer("abc"));

 

package com.lee.demo;

import java.lang.reflect.Constructor;

public class ReflectDemo1 {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		//得到某个类的所有构造方法
		Constructor[] constructors = String.class.getConstructors();
		
		//得到某个类的一个构造方法（获得方法时，要用到类型）
		Constructor constructor = String.class.getConstructor(StringBuffer.class);

		//调用获得的方法时要用到上面相同类型的实例对象
		String str = (String)constructor.newInstance(new StringBuffer("abc"));
		
		System.out.println(str.charAt(2));
	}
}

 

Class.newInstance()

该方法内部先获得默认的构造函数，然后用该构造方法创建实例对象。

该方法内部用到了缓存机制来保存默认构造方法的实例对象

 

Field类

Field类代表某个类中的一个成员变量

  //fieldX不是对象身上的变量，而是类上，要用它去取谋个对象上对应 的值。
  System.out.println(fieldX.get(pt1));
  //由于y的访问权限是private所以使用getDeclaredField()
  //Field fieldY = pt1.getClass().getField("y");
  Field fieldY = pt1.getClass().getDeclaredField("y");
  //将y强行设置为可见
  fieldY.setAccessible(true);
  System.out.println(fieldY.get(pt1));

 

package com.lee.demo;

public class ReflectPoint {
	
	public int x;
	private int y;
	public String str1 = "abcdb";
	public String str2 = "cbgf";
	public String str3 = "itcast";
	
	public ReflectPoint(int x,int y) {
		// TODO Auto-generated constructor stub
		this.x = x;
		this.y = y;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "str1:"+str1+" str2:"+str2+" str3:"+str3;
	}

}

package com.lee.demo;

import java.lang.reflect.Field;

public class ReflectDemo2 {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
				
		ReflectPoint pt1 = new ReflectPoint(4, 5);
		Field fieldX = pt1.getClass().getField("x");
		//fieldX不是对象身上的变量，而是类上，要用它去取谋个对象上对应 的值。
		System.out.println(fieldX.get(pt1));
		//由于y的访问权限是private所以使用getDeclaredField()
		//Field fieldY = pt1.getClass().getField("y");
		Field fieldY = pt1.getClass().getDeclaredField("y");
		//将y强行设置为可见
		fieldY.setAccessible(true);
		System.out.println(fieldY.get(pt1));
		
		changeStringValue(pt1);
		System.out.println(pt1);
	}

	private static void changeStringValue(Object obj) throws Exception{
		// TODO Auto-generated method stub
		Field[] fields = obj.getClass().getFields();
		for(Field f :fields){
			//因为是同一份字节码，所以用 == 最好。
			if(f.getType()==String.class){
				String oldVal = (String)f.get(obj);
				String newVal = oldVal.replace("b", "B");
				f.set(obj, newVal);
			}
		}
	}
}

 

Method类

 

Method类代表某个类中的一个成员方法

package com.lee.demo;

import java.lang.reflect.Method;

public class ReflectDemo3 {

	public static void main(String[] args) throws Exception {
				
		String str = "abc";
		//得到Method对象
		Method charAtMethod = String.class.getMethod("charAt", int.class);
		//如果传递给Method对象的invoke()方法的第一个参数为null，这标明与该Method对象对应的是一个静态方法
		System.out.println(charAtMethod.invoke(str, 2));//输出c
		System.out.println(charAtMethod.invoke(str, new Object[]{1}));//JDK1.4  输出b  
	}

}


用反射的方式执行某个类的main方法

 

问题：启动java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射

方式来调用这个main方法时，如何为invoke方法传参呢？

按照1.5的语法，整个数组是一个参数，而按照1.4的语法，数组中的每一个元素对应一个参数，当把一个字符串

数组作为参数传递给invoke方法时，JDK1.5要兼容JDK1.4的语法，会按照1.4的语法进行处理， 即把数组

打散成若干个单独的参数。所以，在给main方法传递参数时，不能使用代码:

mainMethod .invoke(null,new String[]{"aaa","bbb"};

因为java只能把它当作jdk1.4的语法进行理解，而不是1.5的语法解释，因此会出现参数类型不对的问题。

 

解决办法：

mainMethod .invoke(null,new Object[]{new String[]{"aaa","bbb"}};

mainMethod .invoke(null,(Object)new String[]{"aaa","bbb"};编译器会作特殊处理，编译时不把参数作为数组，也就不会把数组打散成若干个参数了

package com.lee.demo;

import java.lang.reflect.Method;

public class ReflectDemo3 {

	public static void main(String[] args) throws Exception {
		
		Method mainMethod = TestArguments.class.getMethod("main", String[].class);
		
		//mainMethod.invoke(null, new Object[]{new String[]{"dasd","dasd"}});
		mainMethod.invoke(null, (Object)new String[]{"banana","cat"});
	}

}

class TestArguments{
	public static void main(String[] args) {
		for(String arg:args){
			System.out.println(arg);
		}
	}
}


数组反射

 

具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

 

代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。

 

基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；

非基本类型的一维数组，既可以当作Object类型使用，又可以当作Object[]类型使用

 

Arrays.asList()方法处理int[]和String[]时的差异。
 

package com.lee.demo;

import java.lang.reflect.Array;
import java.util.Arrays;

public class ReflectDemo4 {

	public static void main(String[] args) throws Exception {
		int[] a1 = new int[]{1,2,3};
		int[] a2 = new int[4];
		int[][] a3 = new int[2][3];
		String[] a4 = new String[]{"a","b","c"};
		System.out.println(a1.getClass()==a2.getClass());
		//System.out.println(a2.getClass()==a3.getClass());
		//System.out.println(a1.getClass()==a3.getClass());
		
		Object obj1 = a1;
		Object obj2 = a4;
		//Object[] obj3 = a1;基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用
		Object[] obj4 = a3;
		Object[] obj5 = a4;
		
		System.out.println(a1);
		System.out.println(a4);
		//Arrays.asList()方法处理int[]和String[]时的差异。
		System.out.println(Arrays.asList(a1));//输出 [[I@6ae11a87]
		System.out.println(Arrays.asList(a4));//输出 [a, b, c]
	
		printObject(a1);
		printObject(a4);
		printObject("YEAR");
	}

	private static void printObject(Object obj) {
		// TODO Auto-generated method stub
		Class clazz = obj.getClass();
		//根据字节码判断是否是数组
		if(clazz.isArray()){
			//得到数组中元素的个数
			int len = Array.getLength(obj);
			for(int i=0;i<len;i++){
				System.out.println(Array.get(obj, i));
			}
		}else{
			System.out.println(obj);
		}
	}
}



 

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 

详情请查看：http://edu.youkuaiyun.com

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值