java反射总结_java反射总结
Class類的使用
1)在面向對象的世界里，萬事萬物皆對象
java語言中，靜態的成員、普通數據類型不是對象
1.1 類是誰的對象呢？類是對象，類是java.lang.Class類的實例對象
1.2 這個對象到底如何表示？ There is a class named Class
public class ClassDemo1 {
public static void main(String[] args) {
Foo foo1 = new Foo();//Foo的實例對象
//Foo這個類也是一個實例對象，Class類的實例對象應該如何表示？
//任何一個類都是Class類的實例對象，這個實例對象有三種表示方式
//第一種表示方式--->實際在告訴我們任何一個類都有一個隱含的靜態成員變量class
Class c1 = Foo.class; //Class實例對象
//第二種表達方式，已經知道該類的對象，通過getClass方法
Class c2 = foo1.getClass();
/*官網c1，c2表示了Foo類的類類型(class type)
* 萬事萬物皆對象
* 類也是對象，是Class類的實例對象
* 這個對象我們稱為該類的類類型
*/
//不管c1 or c2都代表了Foo類的類類型，一個類只能是Class類的一個實例對象
System.out.println(c1 == c2);
//第三種表達方式
Class c3 = null;
try {
c3 = Class.forName("com.Reflect.Foo");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println(c2 == c3);
//我們完全可以通過類的類類型創建該類的對象實例--->通過c1 or c2 or c3創建Foo的實例
try {
Foo foo = (Foo) c1.newInstance(); //需要有無參數的構造方法
foo.print();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
class Foo{
void print(){
System.out.println("Foo");
}
}
2)動態加載類；Class.forName("類的全稱")
不僅表示了類的類類型，還代表了動態加載類
請大家區分編譯、運行
編譯時刻加載類是靜態加載類、運行時刻加載類是動態加載類
功能性的類一般使用動態加載(如已經有了word和excel的功能，如需要增加ppt的功能，則只需要其他程序員再寫一個對應的類即可)
如電腦上有運行的殺毒軟件，在殺毒軟件在線升級的時候，原來的版本是不需要刪除的，是通過動態加載的方式實現升級的
public class OfficeBetter {
public static void main(String[] args) {
try {
//動態加載類，在運行時刻加載
Class c = Class.forName(args[0]);
//通過類類型，創建該類對象
//Word w = (Word) c.newInstance(); 因為無法預知調用什么類，所以不能使用對應類的強制轉換類型
//需要為它們統一標準
OfficeAble oa = null;
try {
oa = (OfficeAble) c.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
oa.start();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
interface OfficeAble {
public void start();
}
3)基本的數據類型
基本的數據類型， void關鍵字等都存在數據類型
// 獲取基本數據類型的類類型
public class ClassDemo2 {
public static void main(String[] args) {
Class c1 = int.class; //int 的類類型
Class c2 = String.class; //String 類的類類型，String類字節碼
Class c3 = double.class; //數據類型的字節碼表示方式
Class c4 = Double.class; //Double類的字節碼表示方式
Class c5 = void.class;
// Class c6 = package.class; 不是在類里面聲明的
System.out.println(c1.getName());
System.out.println(c2.getName());
System.out.println(c3.getSimpleName()); //打印不包含包名的類的名稱
}
}
4)Class類的基本API操作(ClassUtil和ClassDemo3)
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ClassUtil {
/**
* 打印類的信息，包括類的成員函數
* @param obj 該對象所屬類的信息
*/
public static void printClassMessage(Object obj){
//要獲取類的信息，首先要獲取類的類類型
Class c = obj.getClass(); //傳遞的是哪個子類的對象，c就是該子類的類類型(Object類是任何類的父類)
//接下來獲取類的名稱
System.out.println("類的名稱是：" + c.getName());
//方法是Method的對象
/**
* Method類，方法對象
* 一個成員變量就是一個Method對象
* getMethod方法獲取的是所有的public函數，包括父類繼承而來的
* getDeclaredMethods獲取的是所有該類自己聲明的方法，不問訪問權限(繼承而來的就無法獲取)
*/
Method[] ms = c.getMethods(); //c.getDeclaredMethods();
//獲取方法的信息
for(int i = 0; i
//得到方法的返回值類型的類類型
Class returnType = ms[i].getReturnType();
System.out.print(returnType.getName() + "("); //獲取返回值類型的名字
//得到方法的名稱
System.out.print(ms[i].getName());
//獲取參數類型--->得到的是參數列表的類型的類類型
Class[] paramTypes = ms[i].getParameterTypes();
for(Class class1: paramTypes){
System.out.print(class1.getName() + ",");
}
System.out.print(")\n");
}
}
/**
* 獲取成員變量的信息
* @param obj
*/
public static void printFieldMessage(Object obj) {
/**
* 成員變量也是對象
* java.lang.reflect.Field
* Field類封裝了關于成員變量的操作
* getFields方法獲取的是所有的public的成員變量的信息
* getDeclaredFields獲取的是該類自己聲明的成員變量的信息
*/
// Field[] fs = c.getFields();
Class c = obj.getClass();
Field[] fs = c.getDeclaredFields();
for(Field field: fs){
//得到成員變量的類型的類類型(如果成員變量是String類型，這里得到的是String.class)
Class fieldType = field.getType();
//得到成員變量類型的名字
String typeName = fieldType.getTypeName();
//得到成員變量的名字
String fieldName = field.getName();
System.out.println(typeName + " " + fieldName);
}
}
/**
* 打印對象的構造函數的信息
* @param obj
*/
public static void printConMessage(Object obj){
Class c = obj.getClass();
/**
* 構造函數也是對象
* java.lang.Constructor中封裝了構造函數的信息
* getConstructor獲取所有的public的構造函數
* getDeclaredConstructors得到所有的構造函數
* 構造函數都是自己聲明的
*/
Constructor[] cs = c.getConstructors();
for(Constructor constructor : cs){
System.out.print(constructor.getName() + "(");
//獲取構造函數的參數列表--->得到的是參數列表的類類型
Class[] paramTypes = constructor.getParameterTypes();
for(Class class1: paramTypes){
System.out.print(class1.getName() + "");
}
System.out.println(constructor.getName() + ")");
}
}
}
5)方法重構：
選中需要重構的方法體--->Refactor--->Extract--->Method--->輸入方法名
2、方法的反射：
方法的正常調用方式：a1.print(10,20)；
但是方法的反射操作是用m對象類進行方法調用，和a1.print調用的效果完全相同
import java.lang.reflect.Method;
/**
* 如何去獲得方法對象
* 然后用方法對象進行反射操作
*/
public class MethodDemo1 {
public static void main(String[] args) {
/**
* 要獲取print(int, int)方法
* 1.要獲取一個方法就是獲取類的信息，獲取類的信息，首先要獲取類的類類型
*/
A a1 = new A();
Class c = a1.getClass();
/**
* 2.獲取方法名稱和參數列表
* getMethod獲取的是public的方法
* getDeclaredMethod
*/
try {
//Method m = c.getMethod("print", new Class[]{int.class, int.class});
Method m = c.getMethod("print", int.class, int.class);
System.out.println("===========================================");
Method m1 = c.getMethod("print", String.class, String.class);
System.out.println("===========================================");
Method m2 = c.getMethod("print");
//方法的反射操作
//a1.print(10,20)；方法的反射操作是用m對象類進行方法調用，和a1.print調用的效果完全相同
//用print方法對象來操作a1
//方法如果沒有返回值，則返回null；如果有返回值，則返回具體的返回值
m.invoke(a1,new Object[]{10, 20});
m.invoke(a1,10,20);
m1.invoke(a1, "hello", "world");
m2.invoke(a1);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class A{
public void print(){
System.out.println("HelloWorld!");
}
public void print(int a, int b){
System.out.println( a + b);
}
public void print(String a, String b){
System.out.println(a.toUpperCase() + "," + b.toUpperCase());
}
}
3、了解泛型的本質：通過Class，Method來認識泛型的本質
泛型是為了防止錯誤輸入的，只是在編譯階段有效，繞過編譯就無效了(編譯之后就沒有泛型存在了)
而反射的操作都是編譯之后的操作
因此若使用反射方法進行對象的操作，便可以繞過泛型()
package com.Reflect;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class MethodDemo4 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
ArrayList list1 = new ArrayList();
//泛型是為了防止錯誤輸入的
list1.add("hello");
// list1.add(20);
Class c1 = list.getClass();
Class c2 = list.getClass();
System.out.println(c1 == c2);
//反射的操作都是編譯之后的操作
/*
*c1 == c2結果返回true說明編譯之后，集合的泛型是去泛型化的
*java中結合的泛型，是防止錯誤輸入的，只是在編譯階段有效
* 繞過編譯就無效了(編譯之后就沒有泛型存在了)
* 驗證：我們可以通過方法的反射來操作，繞過編譯
*/
try {
Method m = c1.getMethod("add", Object.class);
m.invoke(list1, 20); //繞過編譯去操作就繞過了泛型
System.out.println(list1.size());
System.out.println(list1);
// for(String s: list1){ //foreach操作的時候會出錯，會有類型轉換錯誤
// System.out.println(s);
// }
} catch (Exception e) {
e.printStackTrace();
}
}
}
總結
以上是生活随笔為你收集整理的java反射总结_java反射总结的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java反射 初始化bean_通用jav
- 下一篇： java类使用其他类的变量_如何将jav