java 反射以及jdk動態代碼

<code></code><pre name="code" class="java"><code style="background-color: rgb(255, 255, 255);"></code><pre name="code" class="java">package com.tracy.proxy.reflect;


public class reflect {
public static void main(String[] args) throws  Exception {
	Boolean var1 = true;

	Class<?> classType2 = var1.getClass();
	//class java.lang.Boolean
	System.out.println(classType2);//class java.lang.Boolean
	
	Class<?> classType4 = Boolean.class;

	System.out.println(classType4);//class java.lang.Boolean
	
	Class<?> classType5 = Class.forName("java.lang.Boolean");

	System.out.println(classType5);//class java.lang.Boolean
	
	Class<?> classType3 = Boolean.TYPE;

	System.out.println(classType3);//boolean 
	
	System.out.println(Integer.TYPE);//int
			impTestReflect timpTestReflect = (impTestReflect) Class.forName("com.tracy.proxy.reflect.impTestReflect").newInstance();
			timpTestReflect.sayme();
			// TODO Auto-generated catch block
			// TODO Auto-generated catch block
}
}

</pre><pre name="code" class="java"><span style="font-size:18px;">反射根據class  類路徑 來new一個實例對象
Constructor提供關於類的單個構造方法的信息以及對它的訪問權限。

Constructor 允許在將實參與帶有基礎構造方法的形參的 newInstance() 匹配時進行擴展轉換，但是如果發生收縮轉換，則拋出IllegalArgumentException。</span>

外部調用java類的私有方法：  利用java.lang.reflect包裏面提供的方法

package com.tracy.proxy.reflect;

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

public class UsePrivate {
    public static void main(String[] args) {
    	//返回一個constructor對象的一個數組,這些對象反映此 Class 對象表示的類聲明的所有構造方法。
    	//Constructor 提供關於類的單個構造方法的信息以及對它的訪問權限  (Class類對象的方法)
    	//返回 Constructor 對象的一個數組，這些對象反映此 Class 對象表示的類聲明的所有構造方法。
    	//Class 類的實例表示正在運行的 Java 應用程序中的類和接口
    	Constructor<?> constructor = privateDTO.class.getDeclaredConstructors()[0];
    	//設置不需要檢查此對象的java語言性是否可以訪問
    	constructor.setAccessible(true);
    	try {
    		
    		privateDTO privateDTO	= (com.tracy.proxy.reflect.privateDTO) constructor.newInstance();
    		privateDTO.sayhello();
            //privateDTO.sayhi();//私有方法不能訪問
    		//返回一個 Method 對象，該對象反映此 Class 對象所表示的類或接口的指定已聲明方法。
    		for(Method method:privateDTO.class.getDeclaredMethods())
    		{
    			//得到對對象之後，再得到方法
    			method.setAccessible(true);
    			if(method.getName().equals("sayhi"))
    			{
    				method.invoke(privateDTO);
    			}
    			else if(method.getName().equals("add"))
    			{
    				method.invoke(privateDTO, 1,7);
    			}
    		}
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
}

代理模式：動態代理 

package com.tracy.proxy.reflect;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


class MethodSelector implements InvocationHandler {
	private Object proxied;

	//構造方法
	public MethodSelector(Object proxied) {
		this.proxied = proxied;
	}

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		if (method.getName().equals("interesting"))
			System.out.println("Proxy detected the interesting method");
	    //在代理實例上處理方法調用並返回結果
		return method.invoke(proxied, args);
	}
}

interface SomeMethods {
	void boring1();

	void boring2();

	void interesting(String arg);

	void boring3();
}

 class Implementation implements SomeMethods {
	public void boring1() {
		System.out.println("boring1");
	}

	public void boring2() {
		System.out.println("boring2");
	}

	public void interesting(String arg) {
		System.out.println("interesting " + arg);
	}

	public void boring3() {
		System.out.println("boring3");
	}
}

public class SelectingMethods {
	public static void main(String[] args) {
		////傳進去的參數,類加載器是負責加載類的對象 ，代理類要實現的接口接口列表，指派方法方法調用的調用處理程序
		SomeMethods proxy = (SomeMethods) Proxy.newProxyInstance(
				SomeMethods.class.getClassLoader(),
				new Class[] { SomeMethods.class }, new MethodSelector(
						new Implementation()));
		proxy.boring1();
		proxy.boring2();
		proxy.interesting("bonobo");
		proxy.boring3();
	}
}