package com.reflect.sym;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class TestReflect {
/**
* @param args
*
* Java反射是Java语言的一个很重要的特征,它使得Java具有了"动态性"。
* 在Java运行环境中,对于任意一个类,能否知道这个类有哪些属性和方法?
* 对于任意一个对象,能否调用它的任意一个方法?答案是肯定的。这种动态获取
* 类的信息以及动态调用对象的方法的功能来自于Java语言的反射(Reflection)机制。
* Reflection是Java被视为动态(或准动态)语言的一个关键性质,这个机制允许程序在运行时透过
* Reflection APIs取得任何一个已知名称的class的内部信息,包括modifiers(诸如public,static等等)、superclass(例如object)、
* 实现之interfaces(如Serializable),也包括fields和methods的所有信息,并可于运行时改变fields内容或者调用methods。
* 程序运行时,允许改变程序结构或者变量类型,这种语言称为动态语言。从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C#不是动态语言。
* 在JDK中,主要由以下类来实现Java反射机制,这些类都位于java.lang.reflect包中:
* Class类:代表一个类。
* Field类:代表类的成员变量。
* Method类:代表类的方法。
* Constructor类:代表类的构造方法。
* Array类:提供了动态创建数组,以及访问数组的元素的静态方法。
*/
public static void main(String[] args) {
/*
* 通过一个对象获取完整的包名和类名
*/
// Animal dog=new Dog();
// System.out.print(dog.getClass().getName());//打印:com.reflect.sym.Dog
/*
* 所有类的对象其实都是Class的实例
*/
// Class<?> dog1=null;
// Class<?> dog2=null;
// Class<?> dog3=null;
// try {
// dog1=Class.forName("com.reflect.sym.Dog");
// } catch (ClassNotFoundException e) {
// e.printStackTrace();
// }
// dog2=new Dog().getClass();
// dog3=Dog.class;
// System.out.println("类名称:"+dog1.getName());//类名称:com.reflect.sym.Dog
// System.out.println("类名称:"+dog2.getName());//类名称:com.reflect.sym.Dog
// System.out.println("类名称:"+dog3.getName());//类名称:com.reflect.sym.Dog
//
/*
* 通过Class实例化其他类的对象
* 在使用Class实例化其他类的对象的时候,一定要自己定义无参数的构造函数
*/
// Class<?> dog = null;
// try {
// dog = Class.forName("com.reflect.sym.Dog");
// } catch (ClassNotFoundException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// Dog dogd = null;
// try {
// dogd = (Dog) dog.newInstance();
// } catch (InstantiationException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// } catch (IllegalAccessException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// dogd.setAge(4);
// System.out.print(dogd);
// /*打印结果:age为:4*/
/*
* 通过Class调用其他类中的构造函数(也可以通过这种方式通过Class创建其他类的对象)
* 此时构造方法可以有参数
*/
// Class<?>cat=null;
// try {
// cat=Class.forName("com.reflect.sym.Cat");
// } catch (ClassNotFoundException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// Cat cat1=null;
// Cat cat2=null;
// Cat cat3=null;
// Cat cat4=null;
// Constructor<?>cons[]=cat.getConstructors();
// for(Constructor<?> con:cons){
// System.out.println(con);
// }
// /*
// * 打印结果:public com.reflect.sym.Cat(int)
// * public com.reflect.sym.Cat(java.lang.String)
// * public com.reflect.sym.Cat(int,java.lang.String)
// * public com.reflect.sym.Cat()
// */
// try {
// /*
// * 特别要注意这里的构造函数与类中的构造函数顺序不一定相同
// */
// cat4=(Cat) cons[3].newInstance();
// cat1=(Cat) cons[0].newInstance(20);
// cat2=(Cat) cons[1].newInstance("kate");
// cat3=(Cat) cons[2].newInstance(20,"Kate");
// } catch (IllegalArgumentException 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 (InvocationTargetException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// System.out.println(cat1);//age:20name:null
// System.out.println(cat2);//age:0name:kate
// System.out.println(cat3);//age:20name:Kate
// System.out.println(cat4);//age:0name:null
/*
* 获取其他类的继承的接口
*/
// Class<?>cat=null;
// try {
// cat=Class.forName("com.reflect.sym.Cat");
// } catch (ClassNotFoundException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// Class<?>intes[]=cat.getInterfaces();
// for(Class<?> inte:intes){
// System.out.print("实现的接口:"+inte.getName());//实现的接口:com.reflect.sym.Animal
// }
/*
* 获取其他类的继承的父类
*/
// Class<?>cat=null;
// try {
// cat=Class.forName("com.reflect.sym.Cat");
// } catch (ClassNotFoundException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// Class<?>father= cat.getSuperclass();
// System.out.print("实现的父类:"+father.getName());//实现的父类:java.lang.Object
//
// Class<?>cat=null;
// try {
// cat=Class.forName("com.reflect.sym.Cat");
// } catch (ClassNotFoundException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// Constructor<?>[]constrouts=cat.getConstructors();
// for(Constructor<?> constrout:constrouts){
// System.out.println("拥有的构造函数:"+constrout);
// }
// /*打印结果:拥有的构造函数:public com.reflect.sym.Cat(int)
// 拥有的构造函数:public com.reflect.sym.Cat(java.lang.String)
// 拥有的构造函数:public com.reflect.sym.Cat(int,java.lang.String)
// 拥有的构造函数:public com.reflect.sym.Cat()*/
//
/*
* 获取构造函数的修饰符
*/
// Class<?>cat=null;
// try {
// cat=Class.forName("com.reflect.sym.Cat");
// } catch (ClassNotFoundException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// Constructor<?>[]constrouts=cat.getConstructors();
// for(int i=0;i<constrouts.length;i++){
// Class<?> p[]=constrouts[i].getParameterTypes();
// int mo=constrouts[i].getModifiers();
// System.out.print(Modifier.toString(mo)+" ");//这个打印出“public”
// System.out.print(constrouts[i].getName());//com.reflect.sym.Cat
// System.out.print("(");
// for(int j=0;j<p.length;++j){
// System.out.print(p[j].getName()+" arg"+i);
// if(j<p.length-1){
// System.out.print(",");
// }
// }
// System.out.println("){}");
// }
// /*打印结果:public com.reflect.sym.Cat(int arg0){}
// public com.reflect.sym.Cat(java.lang.String arg1){}
// public com.reflect.sym.Cat(int arg2,java.lang.String arg2){}
// public com.reflect.sym.Cat(){}*/
/*
* 打印出方法,有时候出现异常的方法
*/
// Class<?>cat=null;
// try {
// cat=Class.forName("com.reflect.sym.Cat");
// } catch (ClassNotFoundException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// Method method[]=cat.getMethods();
// for(int i=0;i<method.length;++i){
// Class<?> returnType=method[i].getReturnType();
// Class<?> para[]=method[i].getParameterTypes();
// int temp=method[i].getModifiers();
// System.out.print(Modifier.toString(temp)+" ");
// System.out.print(returnType.getName()+" ");
// System.out.print(method[i].getName()+" ");
// System.out.print("(");
// for(int j=0;j<para.length;++j){
// System.out.print(para[j].getName()+" "+"arg"+j);
// if(j<para.length-1){
// System.out.print(",");
// }
// }
// Class<?> exce[]=method[i].getExceptionTypes();
// if(exce.length>0){
// System.out.print(") throws ");
// for(int k=0;k<exce.length;++k){
// System.out.print(exce[k].getName()+" ");
// if(k<exce.length-1){
// System.out.print(",");
// }
// }
// }else{
// System.out.print(")");
// }
// System.out.println();
// }
// /* 打印结果:public java.lang.String toString ()
// public java.lang.String getName ()
// public void setName (java.lang.String arg0)
// public void call (java.lang.String arg0)
// public java.lang.String eat ()
// public int getAge ()
// public void setAge (int arg0)
// public final void wait () throws java.lang.InterruptedException
// public final void wait (long arg0,int arg1) throws java.lang.InterruptedException
// public final native void wait (long arg0) throws java.lang.InterruptedException
// public native int hashCode ()
// public final native java.lang.Class getClass ()
// public boolean equals (java.lang.Object arg0)
// public final native void notify ()
// public final native void notifyAll ()*/
//
/*
* 获取其他类的全部属性
*/
// Class<?> cat = null;
// try {
// cat = Class.forName("com.reflect.sym.Cat");
// } catch (Exception e) {
// e.printStackTrace();
// }
// System.out.println("===============本类属性========================");
// // 取得本类的全部属性
// Field[] field = cat.getDeclaredFields();
// for (int i = 0; i < field.length; i++) {
// // 权限修饰符
// int mo = field[i].getModifiers();
// String priv = Modifier.toString(mo);
// // 属性类型
// Class<?> type = field[i].getType();
// System.out.println(priv + " " + type.getName() + " "
// + field[i].getName() + ";");
// }
// System.out.println("===============实现的接口或者父类的属性========================");
// // 取得实现的接口或者父类的属性
// Field[] filed1 = cat.getFields();
// for (int j = 0; j < filed1.length; j++) {
// // 权限修饰符
// int mo = filed1[j].getModifiers();
// String priv = Modifier.toString(mo);
// // 属性类型
// Class<?> type = filed1[j].getType();
// System.out.println(priv + " " + type.getName() + " "
// + filed1[j].getName() + ";");
// }
// /*打印结果: ===============本类属性========================
// int age;
// java.lang.String name;
// ===============实现的接口或者父类的属性========================
// public static final int data;*/
/*
* 通过反射调用其他类中的方法
*/
// Class<?> cat = null;
// try {
// cat = Class.forName("com.reflect.sym.Cat");
// } catch (Exception e) {
// e.printStackTrace();
// }
// try{
// //调用Cat类中的toString方法,这里只是显示控制台上的,只显示出System.out.print("")中的内容
// Method method=null;
// method=cat.getMethod("toString");
// method.invoke(cat.newInstance());
// //调用Cat的call方法
// method=cat.getMethod("call", String.class);
// method.invoke(cat.newInstance(),"Rollen");
// }catch (Exception e) {
// e.printStackTrace();
// }
//
// /* 打印结果:Rollen*/
/*
* 获取get和set方法
*/
// Class<?> cat = null;
// Object obj = null;
// try {
// cat = Class.forName("com.reflect.sym.Cat");
// } catch (Exception e) {
// e.printStackTrace();
// }
// try {
// obj = cat.newInstance();
// } catch (Exception e) {
// e.printStackTrace();
// }
// Method method;
// //此处注意要先set后get
// try {
// method = obj.getClass().getMethod("set" + "Name", String.class);
// try {
// method.invoke(obj, "Kate");
// method = obj.getClass().getMethod("get" + "Name");
// System.out.println(method.invoke(obj));
// } catch (IllegalArgumentException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// } catch (IllegalAccessException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// } catch (InvocationTargetException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
//
// } catch (SecurityException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// } catch (NoSuchMethodException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
//打印结果:Kate
/*
* 通过反射操作属性
*/
//
// Class<?> cat = null;
// Object obj = null;
//
// try {
// cat = Class.forName("com.reflect.sym.Cat");
// try {
// obj = cat.newInstance();
// Field field;
// try {
// field = cat.getDeclaredField("name");
// field.setAccessible(true);
// field.set(obj, "Kate");
// System.out.println(field.get(obj));
// } catch (SecurityException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// } catch (NoSuchFieldException 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();
// }
// /*
// * 打印结果:Kate
// */
/*
* 通过反射取得并修改数组的信息
*/
// int[] temp={1,2,3,4,5};
// Class<?>cat=temp.getClass().getComponentType();
// System.out.println("数组类型: "+cat.getName());
// System.out.println("数组长度 "+Array.getLength(temp));
// System.out.println("数组的第一个元素: "+Array.get(temp, 0));
// Array.set(temp, 0, 100);
// System.out.println("修改之后数组第一个元素为: "+Array.get(temp, 0));
// /* 打印结果:数组类型: int
// 数组长度 5
// 数组的第一个元素: 1
// 修改之后数组第一个元素为: 100*/
/*
* 反射修改数组的大小
*
*/
// int[] temp={1,2,3,4,5,6,7,8,9};
// Class<?>arr=temp.getClass().getComponentType();
// Object newArr=Array.newInstance(arr, 15);
// int co=Array.getLength(temp);
// System.arraycopy(temp, 0, newArr, 0, co);
// int[] newTemp=(int[])newArr;
// Class<?>c=temp.getClass();
// if(!c.isArray()){
// return;
// }
// System.out.println("数组长度为: "+Array.getLength(temp));
// for (int i = 0; i < Array.getLength(temp); i++) {
// System.out.print(Array.get(temp, i)+" ");
// }
// System.out.println("=====================");
// String[] atr={"a","b","c"};
// Class<?>arr1=atr.getClass().getComponentType();
// Object newArr1=Array.newInstance(arr1, 8);
// int co1=Array.getLength(atr);
// System.arraycopy(atr, 0, newArr1, 0, co1);
// String[] str1=(String[])newArr1;
// Class<?>c1=atr.getClass();
// if(!c1.isArray()){
// return;
// }
// System.out.println("数组长度为: "+Array.getLength(atr));
// for (int i = 0; i < Array.getLength(atr); i++) {
// System.out.print(Array.get(atr, i)+" ");
// }
// /*打印结果: 数组长度为: 9
// 1 2 3 4 5 6 7 8 9 =====================
// 数组长度为: 3
// a b c*/
/*
* 如何获取类加载器
*/
// Cat cat=new Cat();
// System.out.println("类加载器 "+cat.getClass().getClassLoader().getClass().getName());
// /* 打印结果:类加载器 sun.misc.Launcher$AppClassLoader*/
// /* 其实在java中有三种类类加载器。
//
// 1)Bootstrap ClassLoader 此加载器采用c++编写,一般开发中很少见。
//
// 2)Extension ClassLoader 用来进行扩展类的加载,一般对应的是jre\lib\ext目录中的类
//
// 3)AppClassLoader 加载classpath指定的类,是最常用的加载器。同时也是java中默认的加载器。*/
/*
* 动态代理
*/
MyInvocationHandler demo = new MyInvocationHandler();
Animal sub = (Animal) demo.bind(new Cat());
sub.call("Kate");
/* 打印结果:Kate*/
}
}
================================================================================
Animal接口:
package com.reflect.sym;
import sun.font.EAttribute;
public interface Animal {
// 属性一定是public final static
int data = 0;
// 方法一定是public的
void call(String str);
String eat();
}
=================================================================================
Cat类:
package com.reflect.sym;
public class Cat implements Animal {
int age;
String name;
public Cat() {
// TODO Auto-generated constructor stub
}
public Cat(int age) {
this.age = age;
}
public Cat(String name) {
this.name = name;
}
public Cat(int age, String name) {
this.age = age;
this.name = name;
}
public void call(String str) {
// TODO Auto-generated method stub
System.out.print(str);
}
@Override
public String eat() {
// TODO Auto-generated method stub
return null;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "age:" + age+"name:"+name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
=================================================================================
Dog类:
package com.reflect.sym;
public class Dog implements Animal {
int age;
public Dog() {
// TODO Auto-generated constructor stub
}
public void call(String str) {
// TODO Auto-generated method stub
}
@Override
public String eat() {
// TODO Auto-generated method stub
return null;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return "age为:"+age;
}
}
================================================================================
InvocationHandler类(代理用):
package com.reflect.sym;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MyInvocationHandler implements InvocationHandler {
private Object obj = null;
public Object bind(Object obj) {
this.obj = obj;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object temp = method.invoke(this.obj, args);
return temp;
}
}
分享到:
相关推荐
Java反射机制主要依赖于`java.lang.reflect`包下的API,其中包括: - `java.lang.Class`:表示一个类的运行时信息。 - `java.lang.reflect.Method`:表示类的方法。 - `java.lang.reflect.Field`:表示类的字段。 -...
本文将通过实例深入解析Java反射机制。 首先,我们来看`TestParam.java`和`ParamClass.java`这两个文件,它们可能涉及到参数化类的使用。在Java中,反射可以帮助我们在运行时获取泛型信息。尽管Java的类型擦除导致...
Java 反射机制是 Java 语言中的一种动态获取信息和动态调用对象方法的功能。它允许在运行时判断任意一个对象所属的类、在运行时构造任意一个类的对象、在运行时判断任意一个类所具有的成员变量和方法、在运行时调用...
Java反射机制允许运行中的程序检查自身,并能直接操作程序的内部属性。这是其他许多编程语言(如Pascal、C或C++)不具备的能力。 **1.1 Reflection的工作机制** 为了展示反射如何工作,我们来看一个简单的例子: ...
Java的反射机制与动态代理是Java编程中两个非常重要的高级特性,它们在许多实际场景中发挥着关键作用,如框架开发、插件系统、元数据处理等。下面将详细讲解这两个概念及其应用。 首先,Java的反射机制允许我们在...
### Java的反射机制及其实际应用 #### 一、引言 ...总之,Java反射机制是一项强大的工具,它能够在运行时动态地获取和操作类的信息。然而,应该谨慎使用反射,避免滥用造成不必要的性能损失或安全风险。
Java反射机制主要通过`java.lang.reflect`包下的API实现,其中最重要的类包括: - `Class`:代表一个类,是所有反射操作的基础。 - `Method`:表示类中的一个方法。 - `Constructor`:表示类中的一个构造函数。...
### Java反射机制详解 #### 一、反射机制是什么 反射机制是Java编程语言的一个核心特性,它允许程序在运行时动态地获取类的信息,并且能够动态地创建对象和调用对象的方法。简单来说,反射机制使得Java程序可以...
### Java反射机制详解 #### 一、什么是Java的反射机制 Java反射机制是Java语言的一种重要特性,使得Java成为了一种动态性很强的语言。通过反射,可以在程序运行时获取类的信息,包括类名、父类、接口、字段、方法...
Java反射机制的实现主要依赖于`java.lang.reflect`包中的几个核心类: - **Class类**:表示一个类,是反射机制的核心。通过Class类可以获取类的各种信息,如构造器、方法、字段等。 - **Field类**:表示类的成员...
Java反射机制是Java编程语言中的一个强大特性,它允许程序在运行时检查和操作类、接口、对象等的内部结构。通过反射,开发者可以动态地获取类的信息并调用其方法,创建对象,访问私有成员,甚至改变类的行为。在深入...
### 反射实例—JAVA反射机制 #### 一、反射概念及原理 反射在计算机科学领域,特别是程序设计中,是指程序有能力访问、检测和修改其自身的结构和行为。这一概念最早由Smith于1982年提出,并迅速应用于各种编程语言...
Java反射机制是Java编程语言中的一个重要特性,它允许程序在运行时动态地获取类的信息并操作类的对象。这种机制使得Java具有高度的灵活性和动态性,可以在编译时未知类的情况下进行类的加载、实例化、方法调用等操作...
Java反射机制是Java编程语言中一个强大的特性,它允许运行时的程序动态地获取类的信息并操作类的对象。在Java中,反射主要涉及到`java.lang.Class`类、`java.lang.reflect`包下的类如`Constructor`、`Method`和`...
Java反射(Reflect)是Java语言中的一个重要特性,它允许运行时的Java程序访问、操作类、接口、字段和方法的信息,甚至动态调用方法。在Java编程中,反射提供了强大的能力,可以用来实现一些高级功能,如元编程、...