java反射与newInstance

今天看了工厂模式，里面有关于通过反射机制来创建对象。我目前为止我的理解是这样的（以下只是个人理解，不对之处请拍砖哈~）：

（1）通过Class的静态方法Class.forName(String classpath)将.class文件加载到虚拟机中，所谓加载实际上做的事情包括：1）为静态变量分配空间并初始化。2）执行静态块代码。3）生成类对象，即Class类的对象，该对象描述了被加载类的信息。

   可以对该生成的类对象进行相关的操作，如得到对象的名称，得到静态方法并执行。

（2）通过类对象的不同构造器，生成相应的对象，并调用方法。

对new 和instance区别的理解：

new：强类型，高效率

instance：弱类型，低效率

· 通过new进行对象生成时，实际上在程序代码中已经默认知道了类的名称信息，因此二者存在某种耦合。而instance生成对象的方法将待生成对象的信息通过字符串作为参数传输，代码本身并没有生成类进行关联，因此实现了解耦。

· new一次性实现了类的加载，类的实例；而instance将这两个过程分开，可以对类对象进行控制。当然通过new生成对象后可以通过对象getClass方法得到对象的类对象。

我写的测试代码如下：

package com.ht.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Test {

    private int i = 10;

    private static int j = 5;

    static {
        System.out.println("j = " + j);

        System.out.println("this is static section");
    }

    public Test() {
        i = 20;
    }

    public Test(int val) {
        this.i = val;
    }

    public Test(int a, int b) {
        this.i = a + b;
    }

    public void print() {
        System.out.println("i="+i);
    }

    public static int getJ() {
        return j;
    }

    public static int getJ(int i) {
        return j * i;
    }

    /**
     * @param args
     * @throws ClassNotFoundException
     * @throws SecurityException
     * @throws NoSuchMethodException
     * @throws InvocationTargetException
     * @throws IllegalArgumentException
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

        //1.加载.class文件，生成类对象
        Class cls = Class.forName("com.ht.test.Test");
        System.out.println(cls.getName()+"类加载完毕");

        System.out.println("-----------操 作 类 对 象 方 法-----------");
        //2.1根据类对象调用静态方法getJ()方法
        Method m1 = cls.getMethod("getJ", null);
        Object ret1 = m1.invoke(new Test(), null);
        System.out.println("2.1:"+ret1.toString());
        
        //2.2根据类对象调用静态方法getJ(int)重载方法
        Method m2 = cls.getMethod("getJ", Integer.TYPE);
        Object ret2 = m2.invoke(new Test(), new Integer(9));
        System.out.println("2.2:"+ret2.toString());
        
        Method m3 = cls.getMethod("print", null);
        m3.invoke(new Test(), null);

        
        System.out.println("-----------根据类对象构造器构造对象-----------");
        //3.根据类对象得到不同的构造函数，并分别构造不同的对象
        //3.1 无参构造
        Constructor cons[] = cls.getConstructors();
        for (int i = 0; i < cons.length; i++) {
            try {
                Test t = (Test) cons[i].newInstance(new Object[]{});
                t.print();
                t.getClass();
                break;
            } catch (Exception e) {
                //e.printStackTrace();
            }
            
        }
        
        //3.2 单参数构造
        for (int i = 0; i < cons.length; i++) {
            try {
                Test t = (Test) cons[i].newInstance(new Object[] { 77 });
                t.print();
                break;
            } catch (Exception e) {
                //e.printStackTrace();
            }        
        }
        
        //3.3 2个参数构造
        for (int i = 0; i < cons.length; i++) {
            try {
                Test t = (Test) cons[i].newInstance(new Object[] { 33, 66 });
                t.print();
                break;
            } catch (Exception e) {
                //e.printStackTrace();
            }        
        }

    }

}

运行结果如下：

j = 5
this is static section
com.ht.test.Test类加载完毕
-----------操 作 类 对 象 方 法-----------
2.1:5
2.2:45
i=20
-----------根据类对象构造器构造对象-----------
i=20
i=77
i=99