1 JAVA的反射,其实就是通过一个实例化的对象反过来去找到一个类的完整信息,比如对于如下的形式:
X x=new X();
x.getClass().getName();
这里就会输出这个类所在的完整信息,即"包名.类名";
最常用的三种实例化CLASS类对象
Class<?> c1 = null ; // 指定泛型
Class<?> c2 = null ; // 指定泛型
Class<?> c3 = null ; // 指定泛型
try{
// 以下的操作形式是在开发中最常用的一种形式
c1 = Class.forName("org.lxh.demo15.getclassdemo.X") ;
}catch(ClassNotFoundException e){
e.printStackTrace() ;
}
c2 = new X().getClass() ; // 通过Object类中的方法实例化
c3 = X.class ; // 通过类.class实例化
System.out.println("类名称：" + c1.getName()) ; // 得到类的名称
System.out.println("类名称：" + c2.getName()) ; // 得到类的名称
System.out.println("类名称：" + c3.getName()) ; // 得到类的名称
2 通过无参构造实例化对象
假设有个类,其中必须存在一个无参数的构造函数,则可以用如下的这个方式进行
Class<?> c = null ; // 声明Class对象
try{
c = Class.forName("org.lxh.demo15.instancedemo.Person") ;
}catch(ClassNotFoundException e){
e.printStackTrace() ;
}
Person per = null ; // 声明Person对象
try{
per = (Person)c.newInstance() ; // 实例化对象
}catch(Exception e){
e.printStackTrace() ;
}
如果类中是存在有参数的构造函数的话,则用如下方式实现:
Class<?> c = null ; // 声明Class对象
try{
c = Class.forName("org.lxh.demo15.getclassdemo.Person") ;
}catch(ClassNotFoundException e){
e.printStackTrace() ;
}
Person per = null ; // 声明Person对象
Constructor<?> cons[] = null ;
cons = c.getConstructors() ;
try{
per = (Person)cons[0].newInstance("李兴华",30) ; // 实例化对象
}catch(Exception e){
e.printStackTrace() ;
}
这里是通过类中的getConsructors()取得本类中的全部构造方法.
3 取得类的结构:
A 取得类中的全部接口:
Class<?> c[] = c1.getInterfaces() ; // 以数组形式返回实现的全部接口
for(int i=0;i<c.length;i++){
System.out.println("实现的接口名称：" + c[i].getName()) ; // 输出接口名称
}
B 取得父类
Class<?> c2 = c1.getSuperclass() ; // 取得父类
C 取得全部的构造方法,并且通过modifier类修饰符来获得
import java.lang.reflect.Constructor ; // 导入构造方法的包
import java.lang.reflect.Modifier ; // 导入构造方法的包
public class GetConstructorDemo03{
public static void main(String args[]){
Class<?> c1 = null ; // 声明Class对象
try{
c1 = Class.forName("org.lxh.demo15.Person") ; // 实例化对象
}catch(ClassNotFoundException e){
e.printStackTrace() ;
}
Constructor<?> con[] = c1.getConstructors() ; // 取得一个类中的全部构造
for(int i=0;i<con.length;i++){
Class<?> p[] = con[i].getParameterTypes() ; // 得到构造方法中的全部
参数
System.out.print("构造方法：" ) ; // 输出构造，直接打印
int mo = con[i].getModifiers() ; // 得到所要的访问权限
System.out.print(Modifier.toString(mo) + " ") ; // 得到修饰符
System.out.print(con[i].getName()) ; // 取得构造方法的名字
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("){}") ;
}
}
}
D 取得一个类的全部构造方法
public class GetMethodDemo{
public static void main(String args[]){
Class<?> c1 = null ; // 声明Class对象
try{
c1 = Class.forName("org.lxh.demo15.Person") ; // 实例化对象
}catch(ClassNotFoundException e){
e.printStackTrace() ;
}
Method m[] = c1.getMethods() ; // 取得全部方法
for(int i=0;i<m.length;i++){
Class<?> r = m[i].getReturnType() ; // 得到返回值类型
Class<?> p[] = m[i].getParameterTypes() ; // 取得全部参数的类型
int xx = m[i].getModifiers() ; // 得到修饰符
System.out.print(Modifier.toString(xx) + " ") ; // 输出修饰符
System.out.print(r + " ") ;
System.out.print(m[i].getName()) ;
System.out.print("(") ;
for(int j=0;j<p.length;j++){
System.out.print(p[j].getName() + " " + "arg" + j) ;
if(j<p.length-1){
System.out.print(",") ;
}
}
Class<?> ex[] = m[i].getExceptionTypes() ; // 取出异常
if(ex.length>0){
System.out.print(") throws ") ;
}else{
System.out.print(")") ;
}
for(int j=0;j<ex.length;j++){
System.out.print(ex[j].getName()) ;
if(j<p.length-1){
System.out.print(",") ;
}
}
System.out.println() ;
}
}
}
4 通过反射调用类中的方法
Class<?> c1 = null ;
try{
c1 = Class.forName("org.lxh.demo15.Person") ; // 实例化Class对象
}catch(Exception e){}
try{
Method met = c1.getMethod("sayChina") ; // 找到sayChina()方法
met.invoke(c1.newInstance()) ; // 调用方法
}catch(Exception e){
e.printStackTrace() ;
}
}
如果要调用有参数的
Class<?> c1 = null ;
try{
c1 = Class.forName("org.lxh.demo15.Person") ; // 实例化Class对象
}catch(Exception e){}
try{
Method met = c1.getMethod("sayHello",String.class,int.class) ; // 找到sayChina
()方法
String rv = null ;
rv = (String)met.invoke(c1.newInstance(),"李兴华",30) ; // 调用方法
System.out.println(rv) ;
}catch(Exception e){
e.printStackTrace() ;
}
}
5 利用反射配合工厂模式
package org.lxh.demo15.factorydemo02 ;
import java.util.Properties ;
import java.io.File ;
import java.io.FileOutputStream ;
import java.io.FileInputStream ;
interface Fruit{
public void eat() ; // 吃水果
}
class Apple implements Fruit{
public void eat(){ // 覆写eat()方法
System.out.println("** 吃苹果");
}
};
class Orange implements Fruit{
public void eat(){
System.out.println("** 吃橘子") ;
}
};
class Init{
public static Properties getPro(){
Properties pro = new Properties() ;
File f = new File("d:\\fruit.properties") ; // 找到属性文件
try{
if(f.exists()){ // 文件存在
pro.load(new FileInputStream(f)) ; // 读取属性
}else{
pro.setProperty("apple","org.lxh.demo15.factorydemo02.Apple") ;
pro.setProperty("orange","org.lxh.demo15.factorydemo02.Orange") ;
pro.store(new FileOutputStream(f),"FRUIT CLASS") ;
}
}catch(Exception e){}
return pro ;
}
};
class Factory{
public static Fruit getInstance(String className){
Fruit fruit = null ;
try{
fruit = (Fruit)Class.forName(className).newInstance() ;
}catch(Exception e){
e.printStackTrace() ;
}
return fruit ;
}
};
public class FactoryDemo02{
public static void main(String args[]){
Properties pro = Init.getPro() ;
Fruit f = Factory.getInstance(pro.getProperty("apple")) ;
if(f!=null){
f.eat() ;
}
}
};
6 动态代理:
import java.lang.reflect.InvocationHandler ;
import java.lang.reflect.Proxy ;
import java.lang.reflect.Method ;
interface Subject{
public String say(String name,int age) ; // 定义抽象方法say
}
class RealSubject implements Subject{ // 实现接口
public String say(String name,int age){
return "姓名：" + name + "，年龄：" + age ;
}
};
class MyInvocationHandler implements InvocationHandler{
private Object obj ;
public Object bind(Object obj){
this.obj = obj ; // 真实主题类
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass
().getInterfaces(),this) ;
}
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
Object temp = method.invoke(this.obj,args) ; // 调用方法
return temp ;
}
};
public class DynaProxyDemo{
public static void main(String args[]){
Subject sub = (Subject)new MyInvocationHandler().bind(new RealSubject()) ;
String info = sub.say("李兴华",30) ;
System.out.println(info) ;
}
};
