小白的成長來源于努力學習，堅持每天的積累。 ——半杯态
一、擷取Class類型；
1.類型名.class
這種方式：簡潔，但是編譯期才可以使用。
public void test01() {
Class B1 = int.class; //基本資料類型
Class<Void> voidClass = void.class; // 特殊的空類型
Class<String> stringClass = String.class; //jdk 定義的類型
Class<Serializable> serializableClass = Serializable.class; //擷取接口類型
Class<int[]> arryList = int[].class; // 擷取數組類型
Class<TestClass> testClassClass = TestClass.class; //自定義類型
Class<ElementType> elementTypeClass = ElementType.class; //枚舉類型
System.out.println(elementTypeClass);
}
2.對象.getClass()
這個方法在java.lang.Object類型中聲明的，傳回對象的運作時類型
@Test
public void test02() {
Class c2 = String.class;
//重點在student
Student student = new Student();
student.getClass();
Class c1 = "".getClass();
Class<Student> studentClass = Student.class;
System.out.println(studentClass);
System.out.println(c1 == c2);
}
3.Class.forName(“類型全名稱”)
這個類型可以在編譯期間未知，這個類名稱可以在代碼中出現，也可以配置在配置檔案中，或者鍵盤輸入等方式來指定。
@Test
public void test03() throws ClassNotFoundException {
Class<?> name = Class.forName("com.banbeitai.reflect.Student");
System.out.println(name);
}
4.使用類加載器對象.loadClass(“類型全名稱”)
一般都是用在自定義類加載器對象去加載指定路徑下的類
@Test
public void test04() throws ClassNotFoundException {
Class<TestClass> testClassClass = TestClass.class;
ClassLoader classLoader = testClassClass.getClassLoader();
Class<?> loadClass = classLoader.loadClass("com.banbeitai.reflect.Student");
System.out.println(loadClass);
}
二、反射的作用與運用
1、在運作時能夠擷取任意類型的詳細資訊
2、在運作時能夠建立任意引用資料類型的對象
3、在運作時可以為任意對象的任意屬性指派，或者擷取任意對象的任意屬性的值
4、在運作時可以調用任意對象的任意方法
5、在運作時讀取某個注解資訊
6、在運作時讀取某個類的泛型實參
使用步驟：
（1）擷取這個類的Class對象
（2）擷取類的資訊
①包名②類名③類的修飾符Modifier④直接父類⑤父接口⑥屬性⑦構造器⑧方法
package com.banbeitai.reflect;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.lang.reflect.*;
import java.util.Arrays;
import java.util.Properties;
public class TestClassInfo {
private Class clazz;
@Before
public void loadClass() throws IOException, ClassNotFoundException {
Properties pro = new Properties();
pro.load(TestClassInfo.class.getResourceAsStream("bean.properties"));
String className = pro.getProperty("className");
clazz = Class.forName(className);
System.out.println(className);
}
@Test
public void getProperty() {
//擷取類所在的包名
Package aPackage = clazz.getPackage();
System.out.println("擷取包名：" + aPackage);
//擷取類名
System.out.println("擷取包名：" + clazz.getName());
//擷取類的修飾符
int mod = clazz.getModifiers();
System.out.println("修飾符的值：" + mod);
System.out.println("修飾符：" + Modifier.toString(mod));
//擷取類的父類
System.out.println("父類是：" + clazz.getSuperclass());
//傳回該類實作和繼承的接口
Class[] interfaces = clazz.getInterfaces();
for (Class inter : interfaces) {
System.out.println(inter.getName());
}
//每一個屬性就是一個Field的對象
/*
* (1)Field[] getFields() 得到所有公共的屬性 包含本類非私有修飾的以及父級（接口，類）的全部的成員變量
* (2)Field[] getDeclaredFields() 得到所有聲明的屬性
*/
Field[] fields = clazz.getFields();
//Field[] fields = clazz.getDeclaredFields();
int count = 0;
for (Field field : fields) {
count++;
int fMod = field.getModifiers();
System.out.println("序号：" + count + ":屬性名：" + field.getName());
System.out.println("序号：" + count + ":屬性的資料類型：" + field.getType().getName());
System.out.println("序号：" + count + ":屬性的修飾符：：" + Modifier.toString(fMod));
}
/*
* Constructor[] getConstructors()：得到所有的公共的構造器
* Constructor[] getDeclaredConstructors()()：得到所有的聲明的構造器
*/
count = 0;
Constructor[] constructors = clazz.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println("序号：" + count + ":構造器名字：" + constructor.getName());
int cMod = constructor.getModifiers();
System.out.println("序号：" + count + ":構造器修飾符：" + Modifier.toString(cMod));
Class[] parameterTypes = constructor.getParameterTypes();
Parameter[] parameters = constructor.getParameters();
for (Parameter parameter : parameters) {
System.out.println(parameter.toString());
}
System.out.println(count + "：構造器的形參清單：" + Arrays.toString(parameterTypes));
/* (1)Method[] getMethods(); 得到所有公共的方法
* (2)Method[] getDeclaredMethods(); 得到所有聲明的方法
*/
}
/* (1)Method[] getMethods(); 得到所有公共的方法
* (2)Method[] getDeclaredMethods(); 得到所有聲明的方法
*/
count=0;
Method[] declaredMethods = clazz.getDeclaredMethods();
for (Method method : declaredMethods) {
count++;
int mMod = method.getModifiers();
System.out.println(count + "：方法的修飾符：" + Modifier.toString(mMod));
System.out.println(count +"：方法的傳回值類型：" + method.getReturnType());
System.out.println(count + "：方法的名稱：" + method.getName());
System.out.print(count + "：抛出的異常類型們：");
Class<?>[] exceptionTypes = method.getExceptionTypes();
System.out.println(Arrays.toString(exceptionTypes));
Class[] parameterTypes = method.getParameterTypes();
System.out.println(count + "：方法的形參清單：" + Arrays.toString(parameterTypes));
}
}
}
2.1 建立對象
方式一：使用Class對象直接new對象
方式二：使用構造器建立對象
package com.banbeitai.reflect.Demo2;
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.time.LocalDate;
public class TestNewInstance {
//使用反射建立對象
@Test
public void createObject() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class<?> forName = Class.forName("com.banbeitai.reflect.demo1.Student");
//通過Class類建立對象
Object instance = forName.newInstance();
System.out.println(instance);
System.out.println("--------通過構造器建立對象---------");
Constructor<?> constructor = forName.getConstructor();
Object newInstance = constructor.newInstance();
System.out.println(newInstance);
System.out.println("--------通過有參構造器建立對象---------");
Constructor<?> nameConstructor = forName.getConstructor(String.class, LocalDate.class);
Object paramConstructor = nameConstructor.newInstance("小米", LocalDate.now());
System.out.println(paramConstructor);
System.out.println("---------------擷取私有構造器---------------------");
Constructor<?> privateonstructor = forName.getDeclaredConstructor(String.class);
//開啟擷取私有修飾内容的權限
privateonstructor.setAccessible(true);
Object privateObj = privateonstructor.newInstance("小軍");
System.out.println(privateObj);
}
}
2.2 為對象的屬性指派，以及擷取對應屬性的值
| 方法 | 含義/解釋 |
|---|---|
| set(Object obj, Object value） | 為成員屬性設定值，參數介紹：第一個參數是對象，第二參數是屬性的值（Field） |
| Object get(Object obj) | 擷取某個屬性的值，參數介紹：對象 |
| setAccessible(true) | 開啟通路權限，true為可以通路 |
package com.banbeitai.reflect.Demo2;
import org.junit.Test;
import java.lang.reflect.Field;
import java.time.LocalDate;
public class TestField {
@Test
public void getField() {
//（1）擷取某個類型的Class對象
try {
Class clazz = Class.forName("com.banbeitai.reflect.demo1.Student");
Object newInstance = clazz.newInstance();
Field field = clazz.getDeclaredField("name");
Field localDate = clazz.getDeclaredField("localDate");
localDate.setAccessible(true);
field.setAccessible(true);
field.set(newInstance, "小軍");
localDate.set(newInstance, LocalDate.now());
System.out.println(newInstance);
Object obj = field.get(newInstance);
System.out.println(obj);
System.out.println(localDate.get(newInstance));
} catch (Exception e) {
e.printStackTrace();
}
}
}
2.3 得到所有公共的方法/私有方法 Method類
package com.banbeitai.reflect.Demo3;
import java.lang.reflect.Method;
public class TestFastMethod {
public static void main(String[] args) throws Exception {
//（1）擷取Class對象:四種方式之一
Class clazz = Class.forName("com.banbeitai.reflect.demo1.Student");
//（2）得到方法Method對象
//例如：得到void setInfo(String info)方法
/*
* (1)Method clazz.getMethod(name, parameterTypes)：得到公共的方法
* (2)Method clazz.getDeclaredMethod(name, parameterTypes)：得到聲明的方法
* 一個類中方法是可能重載，如何定位到某一個方法 方法名 + 形參清單
*/
Method method = clazz.getDeclaredMethod("getInfo", String.class);
//(3)調用方法
/*
* 靜态方法：
* 類名.方法(【實參清單】)
* 非靜态方法
* 對象名.方法(【實參清單】)
*/
//建立對象
Object obj = clazz.newInstance();
//調用方法
method.invoke(obj, "半杯态");
System.out.println(obj);
//擷取public static void
Method testMethod = clazz.getDeclaredMethod("test", int.class);
//調用方法
testMethod.invoke(null, 10);
}
}
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)