java中的反射reflect

反射语句:class.forName(String);  返回一个class对象.

先讲用"反射reflect"在构造方法中的应用:

ParamClass.java

package key;
public class ParamClass{
   
    private int id;
   private String name;
   private String passWord;
 //这个类并没有提供默认的无参的构造方法.
 //对于反射语句"Class.forName().newInstance()"来说他只会去找
 //默认无参的构造方法.这时候怎么去通过反射创建实例呢????
 /*public ParamClass(){
 
    System.out.println("ok");
 }*/
 public ParamClass(int id){
 
     this.id = id;
 }

 public ParamClass(String name,String passWord){
 
     this.name = name;
     this.passWord = passWord;
 }
 public void say(){
 
     System.out.println("id: "+id);
     System.out.println("name:  "+name);
     System.out.println("passWord:   "+passWord);
 }
}

对ParamClass.java的测试类TestParam.java

package key;
import java.lang.reflect.*;
                  //通过这一个类去测试怎样通过反射这中方式去创建一个只带参数构造方法的类的实例.
                  //什么是反射?反射是java具备动态语言性质的一种机制.
                 //他的好处的可以让java在运行的时候才去加载,探索一个在编译时候未知的class.
                //通过这样来实现一个类的"动态加载"
public class TestParam{

    public ParamClass getParamClassById(int id) throws Exception{
                      /*
                         ParamClass pc = (ParamClass)Class.forName("key.ParamClass").newInstance();
                       */
                       //首先获取这一个类的元对象 .那么什么是元对象呢?我们可以把他想象成盖一座楼的蓝图.
                      //有了蓝图之后那么就可以盖房子了
   
                   //2.获取这一个类的构造器.因为这个构造器是对应类的构造方法的参数列表的.
                    //在获取这一个构造器的时候必须要对那些参数造型为class
    Class cl = Class.forName("key.ParamClass");
                   //public ParamClass(int id)
    Constructor ct = cl.getConstructor(new Class[]{int.class});

    ParamClass pc = (ParamClass)ct.newInstance(new Object[]{new Integer(id)});
   return pc;
 }

 public ParamClass getParamClassByOthers(String name,String passWord) throws Exception{
                               //1.获取这个类的元对象
      Class cl = Class.forName("key.ParamClass");
         
                         //2.获取这一个类的构造器.因为这个构造器是对应类的构造方法的参数列表的.
                          //在获取这一个构造器的时候必须要对那些参数造型为class
           
                            //public ParamClass(String name,String passWord)
       Constructor ct = cl.getConstructor(new Class[]{String.class,String.class});
   
                           //3.有了构造器那么就可以通过他来创建实例了.
                         //当然还是必须要传参数.但这时候传进来的就是真实的参数了
                        //把他们作为一个Object数组传送给构造器来创建实例
    ParamClass pc = (ParamClass)ct.newInstance(new Object[]{name,passWord});
   return pc;
 }

 public static void main(String args[]) throws Exception{
 
      new TestParam().getParamClassByOthers("zhangsan","1234").say();
 }
}

反射在一般方法中的应用研究:应用到了单态模式(singleton).

Singleton.java

package key;
public class Singleton{
          //这是一个单例doublecheck模式
   private static Singleton instance = null;
   private static String key = "key";

   private Singleton(){
      System.out.println("instance");
   }

   public static Singleton getInstance(){
  
      if(instance == null){
        synchronized(key){
           if(instance == null){
    
                  instance= new Singleton();
          }
       }
   }
   return instance;
   }
}

对Singleton.java的测试类:TestSingleton.java

package key;
import java.lang.reflect.*;

public class TestSingleton{

   public Singleton getSingleton()throws Exception{
                         //1.首先还是要获取这一个类的元对象
       Class cl = Class.forName("key.Singleton");
                        //2.因为这一个类的构造方法声明为private,但是它又为我们留了一个获取实例
                        //的public static方法.那么我们就可以调用这一个方法去获取实例了.
                        //因为普通方法与构造方法不同,普通方法是没有规则的,所以在获取Method 实例的时候
                            //需要指定到底是通过那一个方法去获取实例.
                           //所以这里第1个参数就是要调用的方法名
                             //第2个参数就是参数的列表了
    Method method = cl.getMethod("getInstance",new Class[]{});
      
    Singleton sl = (Singleton)method.invoke(cl,new Object[]{});
    System.out.println("sl:  "+sl);
    return sl;
   }

   public static void main(String args[]) throws Exception{
  
        new TestSingleton().getSingleton();
   }
}