反射的具體應用反射出方法和類等等

  首先建立一個類，裏面有各種各樣的方法的字段，然後用反射來調用，調用的時候用junit來測試

package com.fts.reflect;

import java.io.InputStream;
import java.util.List;

public class Person {
	public String name="first test";
	private int passwd=123;
	private static int age=100;
	
	
	
	public Person(){
		System.out.println("person");
	}
	public Person(String name){
		System.out.println("person name:"+name);
	}
	public Person(String name,int passwd){
		System.out.println("person name:"+name+"  passwd:"+passwd);
	}
    private Person(List list){
    	System.out.println("list");
    }
    public void test(){
    	System.out.println("test");
    }
    public void test(String name,int passwd){
    	System.out.println("test:"+name+"   :"+passwd);
    }
    public Class[] test(String name,int[] passwd){
    	return new Class[]{String.class};
    }
    private void test(InputStream in){
    	System.out.println(in);
    }
    public static void test(int num){
    	System.out.println(num);
    }
    public static void main(String[] args){
    	System.out.println("main method");
    }
}

反射，加載類的三種方法

package com.fts.reflect;

public class Demo1 {

	/**
	 * 反射，加載類，獲得類的字節碼
	 * @param args
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws ClassNotFoundException {
		// TODO Auto-generated method stub
        //方法一
		Class clazz=Class.forName("com.fts.reflect.Person");
	    
		//方法二
		Class clazz1=new Person().getClass();
		
		//方法三
		Class clazz2=Person.class;
	
	    System.out.println(clazz==clazz1);
	    System.out.println(clazz1==clazz2);
	}

}

反射出構造函數

package com.fts.reflect;

import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

/*
 * 解剖構造函數，創建類的對象
 */
public class Demo2 {
	//反射構造函數 public Person(){}
	@Test
	public void test1() throws Exception{
		//將類加載進內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
		//解剖構造函數
		Constructor c=clazz.getConstructor(null);
		//創建一個對象
		Person p=(Person) c.newInstance(null);
		System.out.println(p.name);
		
	}
	//反射構造函數 public Person(string name){}
	@Test
	public void test2() throws Exception{
		//將類加載進內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
		//解剖構造函數
		Constructor c=clazz.getConstructor(String.class);
		//創建一個對象
		Person p=(Person) c.newInstance("my name");
		System.out.println(p.name);
		
	}
	//反射構造函數 public Person(string name,int passwd){}
	@Test
	public void test3() throws Exception{
		//將類加載進內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
		//解剖構造函數
		Constructor c=clazz.getConstructor(String.class,int.class);
		//創建一個對象
		Person p=(Person) c.newInstance("my name",888888);
		System.out.println(p.name);
		
	}
	//反射構造函數 private Person(List list){}
	@Test
	public void test4() throws Exception{
		//將類加載進內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
		//解剖構造函數
		Constructor c=clazz.getDeclaredConstructor(List.class);
		c.setAccessible(true);//暴力強暴打開
		//創建一個對象
		Person p=(Person) c.newInstance(new ArrayList());
		System.out.println(p.name);
		
	}
	//創建對象的另一種形式
	@Test
	public void test5() throws Exception{
		//將類加載進內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
		Person p=(Person) clazz.newInstance();
		System.out.println(p);
		
		
	}

}

反射類的其它方法

package com.fts.reflect;

import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Method;

import org.junit.Test;

//反射類的方法
public class Demo3 {
	//反射類的方法 public void test(){}
	@Test
	public void test1() throws Exception{
		Person p=new Person();
		//將類加載在內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    //加載類的方法
		Method method=clazz.getMethod("test",null);
		method.invoke(p, null);
	
	}
	//反射類的方法 public void test(String name,int passwd){}
	@Test
	public void test2() throws Exception{
		Person p=new Person();
		//將類加載在內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    //加載類的方法
		Method method=clazz.getMethod("test",String.class,int.class);
		method.invoke(p, "fengtansong",100);
	
	}
	//反射類的方法 public Class[] test(String name,int[] passwd)
	@Test
	public void test3() throws Exception{
		Person p=new Person();
		//將類加載在內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    //加載類的方法
		Method method=clazz.getMethod("test",String.class,int[].class);
		Class cs[]=(Class[]) method.invoke(p, "fengtansong",new int[]{1,2,3});
	    System.out.println(cs[0]);
	}
	//反射類的方法 private void test(InputStream in)
	@Test
	public void test4() throws Exception{
		Person p=new Person();
		//將類加載在內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    //加載類的方法
		Method method=clazz.getDeclaredMethod("test",InputStream.class);
		method.setAccessible(true);
		method.invoke(p,new FileInputStream("c:\\1.txt"));
		
	}
	//反射類的方法 public static void test(int num)
	@Test
	public void test5() throws Exception{
		//將類加載在內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    //加載類的方法
		Method method=clazz.getMethod("test",int.class);
		//靜態方法調用不需要對象
		method.invoke(null,1000);
		
	}
	//反射類的方法 public static void main(String[] args)
	@Test
	public void test6() throws Exception{
		//將類加載在內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    //加載類的方法
		Method method=clazz.getMethod("main",String[].class);
		//靜態方法調用不需要對象
		//method.invoke(null,new Object[]{new String[]{"1"}});
		method.invoke(null,(Object)new String[]{"1"});
		
	}

}

反射出字段

package com.fts.reflect;

import java.lang.reflect.Field;

import org.junit.Test;

//反射字段
public class Demo4 {
	//反射字段public String name="first test";
	@Test
	public void test1() throws Exception{
		Person p=new Person();
		//將類加載到內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    Field f=clazz.getField("name");	
	    //String name=(String) f.get(p);
	    //System.out.println(name);
	   // Class type=f.getType();
	   // System.out.println(type);
	    //獲取字段的值
	    Object value=f.get(p);
	    //獲取字段的類型
	    Class type=f.getType();
	    if(type.equals(String.class)){
	    	String svalue=(String) value;
	    	System.out.println(svalue);
	    }
	    
	    //設置字段的值
	    f.set(p,"xxxxxxxxxx");
	    System.out.println(p.name);
	}
	//反射字段private int passwd=123;
	@Test
	public void test2() throws Exception{
		Person p=new Person();
		//將類加載到內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	   //獲得對象
		Field f=clazz.getDeclaredField("passwd");
		f.setAccessible(true);
		System.out.println(f.get(p));
	}
	//反射字段private static int age=100;
	@Test
	public void test3() throws Exception{
		Person p=new Person();
		//將類加載到內存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	   //獲得對象
		Field f=clazz.getDeclaredField("age");
		f.setAccessible(true);
		System.out.println(f.get(p));
	}

}

通過以上的例子簡單理解了反射的應用

在JDK中，主要由以下類來實現Java反射機制，這些類都位於java.lang.reflect包中：
Class類：代表一個類。
Field 類：代表類的成員變量（成員變量也稱爲類的屬性）。
Method類：代表類的方法。
Constructor 類：代表類的構造方法。
Array類：提供了動態創建數組，以及訪問數組的元素的靜態方法。
 
一、通過Class類獲取成員變量、成員方法、接口、超類、構造方法等
 
在java.lang.Object 類中定義了getClass()方法，因此對於任意一個Java對象，都可以通過此方法獲得對象的類型。Class類是Reflection API 中的核心類，它有以下方法
getName()：獲得類的完整名字。
getFields()：獲得類的public類型的屬性。
getDeclaredFields()：獲得類的所有屬性。
getMethods()：獲得類的public類型的方法。
getDeclaredMethods()：獲得類的所有方法。
getMethod(String name, Class[] parameterTypes)：獲得類的特定方法，name參數指定方法的名字，parameterTypes 參數指定方法的參數類型。
getConstructors()：獲得類的public類型的構造方法。
getConstructor(Class[] parameterTypes)：獲得類的特定構造方法，parameterTypes 參數指定構造方法的參數類型。
newInstance()：通過類的不帶參數的構造方法創建這個類的一個對象。