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反射总结的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。