java反射机制的运用

为什么要用反射？直接用new不行么？干嘛弄得那么麻烦！

Xun m=(Xun)Class.forName(s).newInstance();m.ShuChu();

Xun m=new Xun();//m.ShuChu();//上面两者有什么区别吗

从结果来说没有区别。只是通过反射能够实现一些更为动态的效果，用new只能在编译期就确定对象的类型

1.基本上效果差不多，但是new对象，无法调用该类里面私有的东西，反射反之，具体怎么做请参考java AIP，不过反射需要以牺牲性能做代价。

反射大概比直接调用慢50~100倍，但是需要你在执行100万遍的时候才会有所感觉
判断一个函数的性能，你需要把这个函数执行100万遍甚至1000万遍
如果你只是偶尔调用一下反射，请忘记反射带来的性能影响
如果你需要大量调用反射，请考虑缓存。
你的编程的思想才是限制你程序性能的最主要的因素

2.在不知道类名的情况下，你怎么去new？我相信很多人看到这句话都迷糊了(新手)，肯定有这样的疑问，不知道类名，你怎么反射啊？

那么接下来在讲讲new和反射本质上的区别，new属于静态编译，而反射属于动态编译，意思就说只有到运行时他才会去获得该对象的实例，可能讲的有些抽象（也有可能讲的不太正确）

一般机制是java知道类的定义（比如import了这个类，或者就在同一个包里），然后根据类定义去new一个实例出来。反射机制是不知道类是什么样的，根据字符串之类的类名字等去获取一个实例，然后根据方法名字去执行方法。好比说，一般情况下画一只老虎，我得先知道老虎长什么样子才能画出来；有了反射机制，我只要知道“老虎”这个名字就能画出来。

举例：spring框架是事先就写好的框架，他内部的处理并不知道用户要写哪些类，应为那是以后由用他的人来定的，这时候你还能在spring内部去new吗？所以用户在用的时候才去配置文件中配置类路径，这是一个典型反射的例子，在很多面试中就问道了这个问题。

 

 

静态编译和动态编译的区别：来自网上，借花献佛，

静态编译就是在编译的时候把你所有的模块都编译进exe里去，当你启动这个exe的时候所有模块都加载进来了。你写小程序没问题，但程序一大，加载的过程（就是当你运行程序时初始化的过程）就比较费力了。。大多数ppc的硬件配置还是很一般的。

 

动态编译就不一样了，你编译的时候那些模块都没有编译进去，一般情况下你可以把那些模块都编译成dll，这样你启动程序（初始化）的时候这些模块不会被加载，而是在运行的时候，用到那个模块就调用哪个模块。

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

（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