JAVA反射小结

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) ;
 }
};