`
Luob.
  • 浏览: 1592380 次
  • 来自: 上海
社区版块
存档分类
最新评论
阅读更多
反射:就是将一个类的各个成员映射成相应的类
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;

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

		Class clazz=void.class;
		String str1="abc";
		
		Class cls=str1.getClass();
		Class cls1=String.class;
		Class cls2=Class.forName("java.lang.String");
		
		System.out.println(cls==cls1);
		System.out.println(cls1==cls2);
		
		//字节码是否是 基本数据类型
		System.out.println(cls.getName());  //获取 class的 名字
		System.out.println(cls.isPrimitive());
		System.out.println(int.class.isPrimitive());
		System.out.println(int.class==Integer.class);

		//获取Integer的基本类型
		System.out.println(Integer.TYPE==int.class);  
		//判断数组是不是基本数据类型
		System.out.println(int[].class.isPrimitive());
		//判断class 是不是 数组类型
		System.out.println(int[].class.isArray());
		
		//反射调用构造函数
		getConstructor();
		
		//使用 反射创建对象
		newInstance();
		
		//反射获取 字段
		reflectGetField();
		
		//反射 获取方法 并调用方法
		reflectInvoke(str1);
		
		//调用main方法
		TestArgusments.main(new String[]{"sdf","sdf","sdf"});
		
		//使用反射调用main方法
		String  className=args[0];
		Method mainMethod=Class.forName(className).getMethod("main", String[].class);
		mainMethod.invoke(null, (Object)new String[]{"aaa","bbb","ccc"});  //由于 jdk1.5  要兼容 1.4  所以就采用jdk1.4 的方式(1.4进行拆包)
		
		//数组的反射
		reflectArray();
	}
	
	//获取 Class 的构造方法
	public static void getConstructor() throws Exception{
		Constructor [] constructors=String.class.getConstructors();
		System.out.println("length:"+constructors.length+"\ndetail:"+Arrays.toString(constructors));
		
		//使用反射 调用构造方法 实现 创建对象 
		//new String(new StringBuffer("abc"));
		Constructor constructor=String.class.getConstructor(int[].class,int.class,int.class);
		constructor=String.class.getConstructor(StringBuffer.class);
		String str2=(String) constructor.newInstance(new StringBuffer("abc"));
		System.out.println(str2.charAt(2));
	}
	//Class 的 newInstance 省略了 构造函数的 newInstance 步骤
	public static void newInstance() throws Exception{
		String str1=(String)Class.forName("java.lang.String").newInstance();
		System.out.println(str1);
	}
	
	
	public static void reflectGetField() throws Exception{
		Class clazz=Class.forName("com.enhance.reflect.ReflectPoint");
		Constructor<ReflectPoint> cons=clazz.getConstructor(int.class,int.class);
		ReflectPoint rfp=rfp=(ReflectPoint)clazz.newInstance();  //声明的类必须要有 无参构造方法 
		System.out.println(rfp.y);
		rfp=cons.newInstance(3,5);
		System.out.println(rfp.y);
		
		Field [] fields=clazz.getFields();  //只能获取 非私有字段 
		System.out.println(Arrays.toString(fields));  //只能 处理 私有的字段  其他都能获取
		
		fields=clazz.getDeclaredFields();  //获取所有 声明的字段
		System.out.println(Arrays.toString(fields));  //只能 处理 私有的字段  其他都能获取
		
		Field fy=rfp.getClass().getField("y");
		System.out.println(fy.get(rfp));  //从某个对象中获取  字段的值
		System.out.println(Modifier.toString(fy.getModifiers()));  //获取修饰符
		System.out.println(fy.getType());  //获取字段类型
		
		//获取私有字段
		Field fx=rfp.getClass().getDeclaredField("x");  //
		fx.setAccessible(true);// 暴力访问 
		System.out.println(fx.get(rfp));
		
		reflectReplace(rfp);
		System.out.println(rfp);
		
		
	}
	
	public static void reflectReplace(Object obj) throws Exception{
		
		Field[] fields=obj.getClass().getDeclaredFields();
		for (Field field : fields) {
			//字节码 用 ==进行比较 
			if(field.getType()==String.class){  
				if(field.getModifiers()==Modifier.PRIVATE){
					field.setAccessible(true);
					System.out.println("accessible");
				}
				String oldVal=(String)field.get(obj);
				String newVal=oldVal.replace('b', 'a');
				field.set(obj, newVal);
			}
			
		}
	}
	
	public static void reflectInvoke(String str) throws Exception{
		Method methodCharAt=str.getClass().getMethod("charAt", int.class);
		System.out.println(methodCharAt.invoke(str, 1));
		
		methodCharAt.invoke(str, 1);  //改方法 是静态 方法 ,不需要对象 
	}
	
	
	public static void reflectArray(){
		int[] a1=new int[]{1,2,3};
		int[] a2=new int[]{1,2,3,4};
		int[][] a3=new int[2][3];
		
		String [] a4=new String[]{"a","b","c"};
		
		System.out.println(a1.getClass()==a2.getClass());
		//System.out.println(a1.getClass()==a4.getClass());
		//System.out.println(a1.getClass()==a3.getClass());
		System.out.println(a1.getClass().getName());
		System.out.println(a1.getClass().getSuperclass().getName());
		System.out.println(a3.getClass().getName());
		System.out.println(a3.getClass().getSuperclass().getName());
		System.out.println(a4.getClass().getSuperclass().getName());
		System.out.println(a4.getClass().getName());
		
		Object aobj=a1;
		Object bobj=a3;
	//	Object[] aobj1=a1;
		Object obj5=a4;
		System.out.println("=================");
		System.out.println(Arrays.asList(a1));
		System.out.println(Arrays.asList(a4));
		
		//使用反射开始
		printObj("xyz");
		printObj(a4);
		HashSetAndArryList();
	}
	
	//hashCode  
	public static void HashSetAndArryList(){
		Collection collections=new ArrayList();
		ReflectPoint pt1=new ReflectPoint(2,2);
		ReflectPoint pt2=new ReflectPoint(5,5);
		ReflectPoint pt3=new ReflectPoint(2,2);
		
		collections.add(pt1);
		collections.add(pt2);
		collections.add(pt3);
		collections.add(pt1);
		System.out.println(collections.size());
		
		collections=new HashSet();
		collections.add(pt1);
		collections.add(pt2);
		collections.add(pt3);
		collections.add(pt1);
		System.out.println(collections.size());
		pt1.y=3;
		collections.remove(pt1);  //没有删除掉. 会内存溢出了
		System.out.println(collections.size());
		
	}
	
	
	public static void printObj(Object obj){
		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);
		}
		
		
	}
}

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

//使用反射操作 javabean
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;

/**
 * 使用内省的方式来操作javabean
 * 
 * 使用BeanUtils
 * @author Bin
 */
public class IntroSpectorTest {

	@SuppressWarnings("deprecation")
	public static void main(String[] args) throws Exception{
		System.runFinalizersOnExit(true);
		
		
		ReflectPoint pt=new ReflectPoint(3,7);
		String propertyName="x";
		//"x"--->"X"---->getX---->MethodgetX
		
		Object retVal = getProperty(pt, propertyName);
		System.out.println(retVal);
		//BeanUtils
		System.out.println(BeanUtils.getProperty(pt, "x"));

		//BeanUtils.接受和返回的都是String类型
		System.out.println(BeanUtils.getProperty(pt, "x").getClass().getName());
		
		Object value=7;
		Object retVal1 = setProperty(pt, propertyName, value);
		BeanUtils.setProperty(pt, "x", "9");
		
		System.out.println(retVal1);
		System.out.println(pt.getX());
		
		
		//BeanUtils 给复合属性复制 
		BeanUtils.setProperty(pt, "birthday.time", "1111");
		System.out.println(BeanUtils.getProperty(pt, "birthday"));
		
		//java 7 的新特性 给Map设置
		/*Map map={name:"zxx",age:18};
		BeanUtils.setProperty(map, "name", "lhm");*/
		
		PropertyUtils.setProperty(pt, "x", 15);
		System.out.println(PropertyUtils.getProperty(pt, "x"));
	}

	@Deprecated
	private static Object setProperty(Object obj, String propertyName,
			Object value) throws IntrospectionException,
			IllegalAccessException, InvocationTargetException {
		PropertyDescriptor pd2=new PropertyDescriptor(propertyName, obj.getClass());
		Method methodSet=pd2.getWriteMethod();
		Object retVal1=methodSet.invoke(obj, value);
		return retVal1;
	}

	
	private static Object getProperty(Object obj, String propertyName)
			throws IntrospectionException, IllegalAccessException,
			InvocationTargetException {
		//优秀的代码
		PropertyDescriptor pd1=new PropertyDescriptor(propertyName, obj.getClass());
		Method methodGet=pd1.getReadMethod();
		Object retVal=methodGet.invoke(obj);
		
		//不太好的代码
		BeanInfo beanInfo=Introspector.getBeanInfo(obj.getClass());
		PropertyDescriptor [] pds=beanInfo.getPropertyDescriptors();
		for (PropertyDescriptor pd : pds) {
			if(propertyName.equals(pd.getName())){
				retVal=pd.getReadMethod().invoke(obj);
				break;
			}
		}
		return retVal;
	}
}





public class ReflectPoint {
	
	private Date birthday=new Date();
	private int x;
	public int y;
	public boolean flag;
	private String CPU;
	private String bRide;
	

	private String str = "ball";
	public String str1 = "basketball";
	String str2 = "football";
	protected String str3 = "Vectball";

	public ReflectPoint() {
		super();
		// TODO Auto-generated constructor stub
	}

	public ReflectPoint(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return str + ":" + str1 + ":" + str2;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + x;
		result = prime * result + y;
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		ReflectPoint other = (ReflectPoint) obj;
		if (x != other.x)
			return false;
		if (y != other.y)
			return false;
		return true;
	}

	public boolean isFlag() {
		return flag;
	}

	public void setFlag(boolean flag) {
		this.flag = flag;
	}

	public String getCPU() {
		return CPU;
	}

	public void setCPU(String cPU) {
		CPU = cPU;
	}

	public int getX() {
		return x;
	}

	public void setX(int x) {
		this.x = x;
	}

	public int getY() {
		return y;
	}

	public void setY(int y) {
		this.y = y;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	
}

public class LoadProperties {
	public static void main(String[] args){
		try {
			//InputStream ips=new FileInputStream("src/com/enhance/reflect/config.properties");//src/com/enhance/reflect/config.properties
			
//			InputStream ips=LoadProperties.class.getClassLoader().getResourceAsStream("com/enhance/reflect/config.properties");
			//InputStream ips=LoadProperties.class.getResourceAsStream("config.properties");
			InputStream ips=LoadProperties.class.getResourceAsStream("resource/config.properties");
			
			Properties props=new Properties();
			props.load(ips);
			ips.close();
			String classname=props.getProperty("classname");
			Collection collections=(Collection)Class.forName(classname).newInstance();
			
			ReflectPoint pt1=new ReflectPoint(3,3);
			ReflectPoint pt2=new ReflectPoint(4,3);
			ReflectPoint pt3=new ReflectPoint(3,3);
			collections.add(pt1);
			collections.add(pt2);
			collections.add(pt3);
			
			System.out.println(collections.size());
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
	}
}




package com.enhance.Generic;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.Vector;

import org.junit.runners.Parameterized;

/**
 *使用反射 获取 某个 类中 方法 的参数类型,包括 泛型类型
 */
public class GenericTest {
	public static void main(String[] args) throws Exception{


Method applyMethod=GenericTest.class.getMethod("applyVector", Vector.class);
		Type[] types =applyMethod.getGenericParameterTypes();
		ParameterizedType pType=(ParameterizedType)types[0];
		System.out.println(pType.getRawType());
		System.out.println(pType.getActualTypeArguments()[0]);
		
		Method applyMethod1=GenericTest.class.getMethod("applyString", String.class);
		Class[] cls =applyMethod1.getParameterTypes();
		System.out.println(cls[0]);
		
		System.out.println("=============");
		Method[] mms=GenericTest.class.getMethods();
		for (Method method : mms) {
			Class[] cls1 =method.getParameterTypes();
			System.out.println(method.getName()+":"+Arrays.toString(cls1));
		}

}


	//自动类型转换   泛型 可以根据返回值类型来定义
	public static <T> T autoConvert(Object obj){
		return (T)obj;
	}
	
	//使用反射获取 applyVector方法中  参数的类型 ,包括  Vector 中 T 泛型类型 
	public static void applyVector(Vector<Date> v1){
		
	}
	
	public static void applyString(String v1){
		
	}
0
2
分享到:
评论

相关推荐

    java实例100个

    4. **封装、继承和多态**:这是面向对象的三大特性。封装是保护数据的安全,继承使得子类可以扩展父类的功能,多态则提供了代码的灵活性。 5. **数组**:Java中的数组是存储同类型元素的集合,理解其初始化、遍历和...

    Java开发案例资源大礼包

    最后,"Java编程100实例.rar"很可能是100个不同的Java编程练习,覆盖了Java的基础语法、异常处理、集合框架、IO流、反射、枚举、多线程等各个方面。通过实践这些实例,你可以巩固理论知识,提高解决问题的能力,这...

    大公司java面试资料

    在准备大公司的Java面试时,了解并掌握一系列关键知识点至关重要。以下是一些核心的Java编程概念和技术,这些都可能在面试中出现: 1. **Java基础**:面试通常会从基础开始,涵盖变量、数据类型、运算符、流程控制...

    疯狂java实战演绎

    10. **反射与注解**:Java反射机制允许在运行时检查类的信息,而注解可以用于代码的元数据,这两部分在很多高级应用中都有所体现。 11. **Java虚拟机(JVM)**:理解JVM的工作原理,包括类加载、内存模型、垃圾回收...

    java 软件工程师培训

    8. **Java反射机制**:反射允许在运行时检查和操作类、接口、字段和方法,是实现动态代理、元编程等高级功能的基础。 9. **Spring框架**:Spring是Java企业级应用最常用的框架,涵盖了依赖注入、AOP(面向切面编程...

    合肥工业大学薛峰老师Java课件 即 所有代码

    同时,课程还会涉及Java的高级特性,如反射、注解、泛型等。此外,薛峰老师的课件可能还会介绍如何使用开发工具(如Eclipse或IntelliJ IDEA)以及如何管理项目依赖(如Maven或Gradle)。通过实践代码,学习者可以...

    计算机等级二级JAVA真题

    8. **反射机制**:理解Java反射机制,能够动态获取类的信息,创建并调用对象的方法。 9. **枚举与注解**:了解枚举类型的使用,理解注解的作用及其在编译、运行时的处理。 10. **JNI与JNI接口**:虽然在二级考试中...

    Java语言程序设计实验上机指导

    13. **反射机制**:动态获取类信息,创建和调用类的对象,以及修改私有成员的方法。 14. **枚举与注解**:枚举类型的应用,注解的定义与使用,以及元注解的了解。 15. **Java标准库的使用**:如集合框架、IO流、...

    【独家高薪面试题库】与【实战配套练习演练】1.Java概述1

    Java的反射机制允许程序在运行时检查类、接口、方法和字段,甚至可以动态调用方法和改变字段值。动态代理则允许在运行时创建接口的代理实现,用于拦截和增强方法调用。 以上是Java的一些主要特点和关键知识点,...

    疯狂的Java

    《疯狂的Java》是一本深度剖析Java编程技术的实践指南,其内容涵盖了Java语言的核心概念、语法特性以及实际...结合书中的代码示例和实战演练,读者可以更好地理解Java语言,提升编程技能,成为真正的“疯狂Java”专家。

    Java语言程序设计(一)教材(04747)和历年真题(08年到17年)

    9. **反射**:反射机制允许在运行时动态地获取类的信息并操作对象,是Java的高级特性,常用于框架开发和自动化测试。 10. **JVM和内存管理**:理解Java虚拟机的工作原理,包括垃圾回收机制,内存区域划分(堆、栈、...

    java二级试题

    Java二级考试是中国计算机技术与软件专业技术资格(水平)考试中的一个重要部分,主要考察考生对Java编程语言的基础理论和实际应用能力。...历年真题的演练有助于熟悉考试格式和难度,帮助考生更好地准备Java二级考试。

    java学习,考试,面试资料大综合

    "java学习,考试,面试资料大综合"这个压缩包显然包含了丰富的资源,旨在帮助从初学者到有一定经验的开发者全面掌握Java知识,为考试和面试做好准备。 1. **Java版精华区.chm**: 这个CHM文件可能是一个Java知识点的...

    JAVA高并发高性能高可用高扩展架构视频教程

    企业架构师必备技能(JAVA核心技术反射) JavaWeb之基础(手写实现Tomcat服务器) java多线程编程 纯手写实现SpringIOC实现过程 JEE企业级开发(企业级项目开发权威指南) 网络爬虫之JAVA正则表达式 手写springMVC框架 老...

    入门神器《20天上手Java基础视频》

    再者,课程深入剖析JDK源码,讲解了Java反射和动态代理等高级特性,帮助学员建立深厚的Java技术根基。最后,尚硅谷提供了免费的技术讲师在线答疑服务,为学员解决了学习过程中的疑惑,增强了学习效果。 课程内容...

    Java开发详解视频教程(孙鑫)9a

    7. **反射与注解**:这部分可能会讲解Java的反射机制,如何在运行时动态获取类的信息并进行操作,以及注解的使用和自定义注解的创建,这些都是高级Java开发中常见的技术。 8. **JVM原理**:对于软件设计师来说,...

    SCJP大全(考证和学习java基础的人必备)

    通过"SCJP大全.exe"的学习资源,你可以系统地掌握这些Java基础知识,并通过模拟试题进行实战演练,提升编程能力,为通过SCJP认证做好充分准备。同时,这个资源对于任何希望加深对Java理解的人来说,都是一个宝贵的...

    新版Java面试专题视频教程

    8. **反射机制**:Java的反射机制允许在运行时动态地获取类的信息并操作对象,面试中可能会考察Class类的使用、构造方法的反射调用等。 9. **JVM内存模型**:理解JVM的工作原理对于优化程序性能至关重要,面试中...

    liqingchuan_华为java编程

    文件操作、异常处理、线程并发、网络编程、反射机制、设计模式等都是Java进阶学习的重点。在华为的项目中,这些技术常用于实现高效的数据处理、服务间的通信以及系统优化。 三、Java框架与工具 在实际开发中,...

    java认证试题库

    8. **反射机制**:理解反射的基本原理,如何在运行时获取类信息,动态创建对象和调用方法。 9. **JVM内存管理**:理解垃圾收集机制,堆和栈内存的分配,以及内存泄漏的概念。 10. **Java EE相关**:对于更高级的...

Global site tag (gtag.js) - Google Analytics