因爲要開始學習Java框架，所以特地簡單的學習了一下Java的反射，只是一些基礎的使用並沒有涉及比較深層次的東西，比較適合小白.....
一.先進行準備工作：
在這裏我定義了2個接口:MyInterface MyInterface2
1個實體類： Person
由實體類繼承了兩個接口；
兩個接口：
package cn.skh.reflect;
public interface MyInterface {
void interfaceMethod() ;
}
package cn.skh.reflect;
public interface MyInterface2 {
void Interface02() ;
}
實體類：
package cn.skh.reflect;
public class Person implements MyInterface,MyInterface2{
private int age;
private String name;
private int id;
@Override
public void interfaceMethod() {
System.out.println("Interface Method.....");
}
public static void staticMethod() {
System.out.println("This is Static Method......");
}
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;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Person(int age, String name, int id) {
this.age = age;
this.name = name;
this.id = id;
}
public Person(int id) {
this.id = id;
}
public Person() {
}
private Person(String name) {
this.name = name;
}
private void privateMethod() {
System.out.println("This is a privateMethid...");
}
private void privateMethod2(String name) {
System.out.println("privateMethod...."+name);
}
@Override
public void Interface02() {
System.out.println("This is a Interface02 Method......");
}
}
二、反射Demo
1.demo01：通過反射獲取類的基本信息： 更具體的說明都寫在了代碼的註釋裏面，這裏就不在敘述。
tips：你會發現在下面的代碼中，不管是獲取方法還是屬性都會有兩個方法 區別就是Declared的有無，在這裏說明一下，有它只能獲取當前的屬性，不管是私有還是公有都可以。如果沒有這個declared那麼只能得到公有屬性，但他的範圍變大了，不僅可以得到當前類的，也可以獲取父類的和所繼承的接口的方法，但只能是public
package cn.skh.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectDemo01 {
//通過反射獲取類
public static void demo01() {
//獲取反射對象（反射入口）：Class ，1 Class.forName(全類名) 2 類名.class 3 對象.getClass()
//1 Class.forName("全類名")
try {
Class<?> perClazz = Class.forName("cn.skh.reflect.Person") ;
System.out.println(perClazz);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
// 2 類名.class
Class<?> perClazz2 = Person.class ;
System.out.println(perClazz2);
// 3 對象.getClass()
Person per = new Person();
Class<?> perClazz3 = per.getClass() ;
System.out.println(perClazz3);
}
//獲取公共方法
public static void demo02() {
//Class入口
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//獲取所有的 公共的方法(1.本類 以及 父類、接口中的所有方法 2.符合訪問修飾符規律)
Method[] methods = perClazz.getMethods();
for(Method method:methods) {
System.out.println(method);
}
System.out.println("==========");
//獲取當前類的所有方法（1.只能是當前類 2.忽略訪問修飾符限制）
Method[] declaredMethods = perClazz.getDeclaredMethods();
for(Method declaredMethod:declaredMethods) {
System.out.println(declaredMethod);
}
}
//獲取所有的接口
public static void demo03() {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Class<?>[] interfaces = perClazz.getInterfaces() ;
for(Class<?> inter:interfaces) {
System.out.println(inter);
}
}
//獲取所有的父類
public static void demo04() {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Class<?> superclass = perClazz.getSuperclass() ;
System.out.println(superclass);
}
//獲取所有的構造方法
public static void demo05() {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Constructor<?>[] constructors = perClazz.getConstructors() ;
for(Constructor<?> constructor:constructors) {
System.out.println(constructor);
}
}
//獲取所有的公共屬性
public static void demo06() {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//公共屬性
Field[] fields = perClazz.getFields() ;
for(Field field:fields) {
System.out.println(field);
}
System.out.println("====");
//所有屬性 (屬性的 ：公共屬性\所有屬性的區別 同“方法”)
Field[] declaredFields = perClazz.getDeclaredFields() ;
for(Field declaredField:declaredFields) {
System.out.println(declaredField);
}
}
//獲取當前反射所代表類（接口） 的對象（實例）
public static void demo07() throws InstantiationException, IllegalAccessException {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Object instance = perClazz.newInstance() ;
Person per = (Person)instance ;
per.Interface02();
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
// demo01();
// demo02();
// demo03();
// demo04();
// demo05();
// demo06();
demo07();
}
}
2.demo02: 通過反射獲取對象實例 並操作對象
tips: 在這裏需要注意的是，如果操作私有的方法或者屬性，必須要暫時代開權限 纔可以對私有的變量進行賦值 或者調用私有的方法：
package cn.skh.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
/*
* 獲取對象實例 並操作對象
*/
public class ReflectDemo02 {
public static void demo01() throws InstantiationException, IllegalAccessException {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Person p = (Person) perClazz.newInstance();
p.setName("skh");
p.setAge(18);
p.setId(1);
System.out.println(p.getName());
}
//操作屬性
public static void demo02() throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Person p = (Person) perClazz.newInstance();
Field namefield = perClazz.getDeclaredField("name");
//只能設置public 可以修改權限
namefield.setAccessible(true);//此時私有變量也可以使用
namefield.set(p, "zxx");//等價於語句 p.setName("zxx"); 只能操作公有變量
System.out.println(p.getName());
System.out.println("======================");
Method method = perClazz.getDeclaredMethod("privateMethod2", String.class);//第一個爲方法名 第二個爲方法的參數類型的class入口 沒有就是null
//因爲我這個方法也是私有的 所以也要設置權限纔可以調用
method.setAccessible(true);
method.invoke(p, "skh");//調用方法用invoke skh爲給方法傳入的參數
}
//操作構造方法
public static void demo03() throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Person p = (Person) perClazz.newInstance();
//得到本類所有的構造方法
Constructor<?>[] constructors = perClazz.getDeclaredConstructors();
//獲取指定的構造方法
Constructor<?> constructor = perClazz.getConstructor(int.class);//無參構造的話就不需要了反射入口
//在這裏我們得到了構造方法 有構造方法可產生對象
Person p1 = (Person) constructor.newInstance(1);
//操作私有構造方法
Constructor<?> constructor2 = perClazz.getDeclaredConstructor(String.class);
//注意 這裏也要放開權限 因爲是私有的構造方法
constructor2.setAccessible(true);
Person p2 = (Person) constructor2.newInstance("skh");
System.out.println(p+"--"+p1+"--"+p2);
}
//反射可以 越過泛型檢查
//雖然可以通過反射 訪問private等訪問修飾符不允許訪問的屬性/方法，也可以忽略掉泛型的約束；但實際開發 不建議這樣使用，因此可能造成程序的混亂。
public static void demo04() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
ArrayList<Integer> list = new ArrayList<>() ;
list.add(123) ;
list.add(3) ;
list.add(2) ;
// list.add("zs") ;
Class<?> listClazz = list.getClass() ;
Method method = listClazz.getMethod("add", Object.class) ;
method.invoke(list , "zs...") ;
System.out.println(list);
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
//demo01();
//demo02();
//demo03();
demo04();
}
}
就先說這些吧，應該夠用了.......