什麽是反射

　　反射機制就是指程序運行時能夠獲取自身的信息。在Java中，只要給出類的名字，就可以通過反射機制來獲取類的信息

哪裏用的到反射機制

　　在jdbc中就是使用的反射來實例化對象，比如：Class.forName("com.mysql.jdbc.Driver.class").newInstance();

　　 框架都用到反射機制，spring，hibernate、struts都是用反射機制實現的。

反射機制的優點和缺點

　為什麽要用反射機制？直接創建對象不就可以了嗎，這就涉及到了動態與靜態的概念，
靜態編譯：在編譯時確定類型，綁定對象,即通過。
動態編譯：運行時確定類型，綁定對象。動態編譯最大限度發揮了java的靈活性，體現了多
態的應用，有以降低類之間的藕合性。
一句話，反射機制的優點就是可以實現動態創建對象和編譯，體現出很大的靈活性，特別是在J2EE的開發中.

　 它的靈活性就表現的十分明顯。比如，一個大型的軟件，不可能一次就把把它設計的很完美，當這個程序編譯後，發布了，當發現需要更新某些功能時，我們不可能要用戶把以前的卸載，再重新安裝新的版本，假如這樣的話，這個軟件肯定是沒有多少人用的。采用靜態的話，需要把整個程序重新編譯一次才可以實現功能的更新，而采用反射機制的話，它就可以不用卸載，只需要在運行時才動態的創建和編譯，就可以實現該功
能。
它的缺點是對性能有影響。使用反射基本上是一種解釋操作，我們可以告訴JVM，我們希望做什麽並且它
滿足我們的要求。這類操作總是慢於只直接執行相同的操作。

利用反射機制能幹什麽

Class c=Class.forName("className");註明：className必須為全名，也就是得包含包名，比如，cn.netjava.pojo.UserInfo;
Object obj=c.newInstance();//創建對象的實例

獲取構造器

　　Constructor getConstructor(Class[] params)//根據指定參數獲得public構造器

　　Constructor[] getConstructors()//獲得public的所有構造器

　　Constructor getDeclaredConstructor(Class[] params)//根據指定參數獲得public和非public的構造器

　　Constructor[] getDeclaredConstructors()//獲得public的所有構造器

獲取類的方法

　Method getMethod(String name, Class[] params),根據方法名，參數類型獲得方法

Method[] getMethods()//獲得所有的public方法

Method getDeclaredMethod(String name, Class[] params)//根據方法名和參數類型，獲得public和非public的方法

Method[] getDeclaredMethods()//獲得所以的public和非public方法

獲取類的屬性

　　Field getField(String name)//根據變量名得到相應的public變量

Field[] getFields()//獲得類中所以public的方法

Field getDeclaredField(String name)//根據方法名獲得public和非public變量

Field[] getDeclaredFields()//獲得類中所有的public和非public方法

使用實例

獲取類屬性：

public class TestGetField extends Object {
    private static final long serialVersionUID = -2862585049955236662L;

    public static void main(String args[]) throws Exception {
        Class<?> clazz = Class.forName("reflect.TestGetField");
        System.out.println("===============本類屬性===============");
        // 取得本類屬性
        Field[] fields = clazz.getDeclaredFields();
        getField(fields);


        System.out.println("==========實現的接口或者父類的屬性==========");
        // 取得實現的接口或者父類的屬性
        Field[] fatherField = clazz.getFields();
        getField(fatherField);
    }

    public static void getField(Field[] fields) {
        for (Field field : fields) {
            // 權限修飾符
            int mo = field.getModifiers();
            String priv = Modifier.toString(mo);
            Class<?> type = field.getType();
            System.out.println(priv + " " + type.getName() + " " + field.getName() + ";");
        }
    }
}

獲取類的方法：

public class TestGetMethod implements Serializable{
    private static final String  testString= "hello";
    public static void main(String args[]) throws Exception{
        Class<?> clazz = Class.forName("reflect.TestGetMethod");
        Method[] methods = clazz.getMethods();
        for (Method method :methods){
            Class<?> returnType = method.getReturnType();
            Class<?> para[] = method.getParameterTypes();
            int temp = method.getModifiers();
            System.out.print(Modifier.toString(temp));
            System.out.print(returnType.getName());
            System.out.print(method.getName());

            for (Class par:para){
                System.out.println(par.getName());
            }
            
        }
    }
}

實例化類：

public class TestNewInstance {
    public static void main(String[] args) throws Exception{
        Class<?> class1 = null;
        class1 = Class.forName("reflect.User");
        // 第一種方法，實例化默認構造方法，調用set賦值
        User user = (User)class1.newInstance();
        user.setAge(20);
        user.setName("adf");
        System.out.println(user);
        // 第二種 取得全部的構造函數 使用構造函數賦值

    }
}

class User {
    private int age;
    private String name;
    public User() {
        super();
    }
    public User(String name) {
        super();
        this.name = name;
    }
    public User(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "User [age=" + age + ", name=" + name + "]";
    }
}

使用類的方法：

public class TestUseMethod {
    public static void main(String[] args)throws Exception{
        Class<?> clazz = Class.forName("reflect.TestUseMethod");
        // 調用reflect1方法
        Method method = clazz.getMethod("reflect1");
        method.invoke(clazz.newInstance());

        // 調用reflect2方法
        method = clazz.getMethod("reflect2", int.class, String.class);
        method.invoke(clazz.newInstance(),20,"test");
    }

    public void reflect1() {
        System.out.println("Java 反射機制 - 調用某個類的方法1.");
    }
    public void reflect2(int age, String name) {
        System.out.println("Java 反射機制 - 調用某個類的方法2.");
        System.out.println("age -> " + age + ". name -> " + name);
    }
}

動態代理：

public class TestProxy {
    public static void main(String args[]) throws Exception{
        MyInvocationHandler demo = new MyInvocationHandler();
        Subject subject = (Subject) demo.bind(new RealSubject());
        System.out.println(subject.say("janti",20));
    }
}

interface Subject{
    public String say(String name, int age);
}

// 定義真實項目
class RealSubject implements Subject {
    public String say(String name, int age) {
        return name + "  " + age;
    }
}

//如果想要完成動態代理，首先需要定義一個InvocationHandler接口的子類，已完成代理的具體操作。

class MyInvocationHandler implements InvocationHandler{

    private Object object = null;
    public Object bind(Object obj){
        this.object = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object temp = method.invoke(this.object,args);
        return temp;
    }
}

Java基礎鞏固——反射