java抽象method反射

『壹』 java有幾個學習方向

java作為計算機編程使用最多的語言之一，就業面是比較廣的，是一個不錯的選擇。

作為世界上最通用的編程語言之一，Java現在幾乎在平台、技術和經濟領域都得到了廣泛的應用。這就是為什麼對Java開發人員的需求不斷增加的原因。基本上每一家專業的IT培訓學校，都會開設有Java方向的課程。這里簡單列舉下學習Java要學習的內容。

Java的學習內容：

①Java編程基礎

②web前端開發技術（MySQL資料庫、HTML5、CSS3、js、linux系統）

③後台開發主流的技術框架（SSM框架、SSH框架）

④前後端分離的開發模式（GitHub、Maven）

⑤分布式微服架構技術以及SpringCloud等技術（Dubbox的微服實戰、Spring Cloud的微服實戰、Nosql資料庫、Vue.js實戰等）

互聯網行業目前還是最熱門的行業之一，學習IT技能之後足夠優秀是有機會進入騰訊、阿里、網易等互聯網大廠高薪就業的，發展前景非常好，普通人也可以學習。

想要系統學習，你可以考察對比一下開設有相關專業的熱門學校，好的學校擁有根據當下企業需求自主研發課程的能力，能夠在校期間取得大專或本科學歷，中博軟體學院、南京課工場、南京北大青鳥等開設相關專業的學校都是不錯的，建議實地考察對比一下。

祝你學有所成，望採納。

『貳』 尚學堂的Java課程分為哪幾種

JavaEE基礎，Java Web開發，主流框架技術及項目實戰

『叄』 什麼是類，什麼是對象，Java中類的聲明格式是什麼，簡單舉例說明。

2.Java中的類和對象【第一部分草案】 收藏
（本章的學習量相對比較大，我把整體分為三個部分講解，第一個部分和第二個部分為Java關於類和對象以及OO的基礎，第三個部分為在OO設計技巧中針對Java程序的一些性能提升的小技巧，因為盡量保證Java關於類和對象的基本概念以及關鍵知識點都能夠涉及到，一是為了方便查詢，二是按照常用的關鍵點來進行的整理，其中的關鍵點都是在開發過程中的一些相關內容涉及，所以本文特意提供了一個目錄進行檢索。類和對象屬於面向對象的基本概念，在開發過程中，需要掌握了對象和類的基本思想過後才明白如何進行OO設計，Java本身是純面向對象的語言，這篇文章的主要目的是針對Java裡面一些關於類和對象的基本操作進行簡單的講解，若有筆誤，請來Email提點，謝謝：[email protected]）
本文目錄：【藍色部分為本章的目錄】
1.基本概念
2.Java變數相關
1)Java變數分類
2)Java中變數的初始化
3)Java變數修飾符和訪問域
4)Java類修飾符[不包含內部類]
3.Java涉及OO的關鍵知識點【主體】
1)繼承的基本概念
2)抽象類、介面、final類：
3)重載和重寫：
4)對象的拷貝[深拷貝和淺拷貝]：
5)關鍵字this、super
6)Java中的inlining[內聯]
7)帶繼承的構造函數以及構造順序
8)談談Object中的方法：equals、hashCode、toString
9)帶繼承的類型轉換以及轉換中關於成員變數和成員函數的調用
10)Java語言中的反射
11)按引用傳遞和值傳遞原理
12)Java中的包和導入
13)匿名類和內部類
4.Java編程OO設計技巧
1)對象創建以及周期
2)對象屬性設置
3)垃圾回收
4)繼承、介面、抽象類
5.總結

1.基本概念：
類和對象：OO裡面什麼稱為類，類一般性我們定義為創建對象的一個藍圖，當我們根據某個類創建了一個對象的時候，我們就說該對象是這個類的一個實例（instance），類描述了某些對象的基本結構，是對對象的相關屬性的一種定義，它定義了對象所具有的屬性、方法、事件等各種基本點。
類設計的關鍵概念：封裝是對象在工作的時候的一個關鍵概念，也是我們在進行OO設計的時候的一個需要掌握的點，封裝簡單講就是將對象內部的一些細節實現隱藏起來不對外公布，僅僅對外公布某個對象能夠提供的操作結果，從而實現信息隱藏的目的。在封裝過程，對象內的數據我們一般稱為成員變數（instance fields），對象內針對這些數據執行的操作我們可以叫做操作方法（成員函數）（methods），一個對象這些屬性的集合所反映出來的就是該對象的狀態。
在Java裡面，所有的復合數據都是從Object類繼承而來的，這一點可以通過使用Java反射去獲取父類的名稱來獲得。
對象：在OO設計裡面，對象有幾個需要掌握的基本點：
對象的行為：對象的行為指代的是這個對象能夠做什麼，不能做什麼，包括這個對象有哪些介面是對外提供了我們可以直接進行使用等相關概念。
對象的狀態：對象的狀態指代的是在程序運行過程，某個對象實例的一些屬性發生了相關的變化過後產生的一個對象狀態，在ORM設計中我們經常會遇到對象狀態的操作。
對象的標識：對象的標識指代的是這個對象如何區別於其他對象，即是是同一個類產生的新實例，其本質上講它們屬於兩個不同的對象，而不應該是同一個對象。
類與類的關系：
依賴（Dependence）：依賴關系簡單講就是users-a的關系，兩個類創建的對象實例本身沒有任何關系，在編程過程反映出來的就是兩個對象在相互之間的調用關系，比如某個對象在執行它自己的行為的時候調用了其他對象的方法這些相關操作都屬於users-a的基本關系，或者說在某個Class裡面使用了其他Class來定義成員變數。
組合（Aggregation）：組合關系可以認為是has-a的關系，這種關系的兩個類存在一個包含關系，很容易理解就是比如某個類包含了另外一個類，這種概念嚴格上講不在操作，主要是成員變數，比如一個用戶有個姓名屬性成為NameInfo，然後這個NameInfo定義為一個包含了兩個String的對象，一個是FirstName，另外一個是LastName，這種情況可以認為該對象本身和NameInfo之間的關系是has-a的關系。
繼承（Inheritance）：繼承關系屬於is-a的關系，這種關系意味著兩個類存在父類（superclass）和子類（subclass）的概念，Java裡面使用extends和implements兩個關鍵字來體現兩個類的集成關系。
（上邊這些概念基本上在各種OO語言學習的開篇都會遇到，沒什麼特殊的，所以熟悉的人可以不用去了解）
Java中的Class：
預定義Class：在Java裡面，什麼稱為預定義Class，學過Java的人都知道，JVM會在我們編寫java程序的時候默認載入包java.lang，而java.lang裡面已經存在了很多Class，這種Class就屬於預定義的Class；不僅僅如此，以及Java API裡面提供的Network相關類、IO相關類、XML相關類，這些可以不需要我們自定義，只需要import過後就可以直接使用的類就屬於預定義的類。預定義類的各種使用方法可以參考JDK的API文檔，裡面針對目前存在的很多類都有詳細的描述信息，有些類還提供了我們所需要的相關使用Demo可做參考。
一些代碼的使用例子。
自定義Class：如果我們要使用自己的Class就需要在Java中自己定義Class，定義語法如下：
class UserInfo{
……
}
使用該語法我們就可以定義一個屬於自己的Class，而在Class裡面我們就可以根據自己的需求來設計相關成員變數和成員函數以及其他相關信息。

2.Java變數：
1)Java中的變數分為四種：類變數（又稱為靜態變數）、實例變數、局部變數、塊變數
類變數——類變數只能在一個class域裡面進行定義，同樣只能在類裡面使用，使用關鍵字為static關鍵字，這種變數可以直接通過Class.VAR的方式來調用，而且不需要對象實例存在就可以調用，它的執行原理在於當JVM的類載入器將類載入進來的時候，這個變數就已經存在的，而且可以使用了。定義方式和調用方式如下，下邊的A就屬於類變數：
class UserInfo{
static int A;
public static void main(String args[])
{
System.out.println(UserInfo.A);
}
}

『肆』 Java9都快發布了,Java8的十大新特性你了解多少呢

一、Lambda表達式

Lambda表達式可以說是Java 8最大的賣點，她將函數式編程引入了Java。Lambda允許把函數作為一個方法的參數，或者把代碼看成數據。

一個Lambda表達式可以由用逗號分隔的參數列表、–>符號與函數體三部分表示。例如：

Arrays.asList( "p", "k", "u","f", "o", "r","k").forEach( e -> System.out.println( e ) );

1 Arrays.asList( "p", "k", "u","f", "o", "r","k").forEach( e -> System.out.println( e ) );

為了使現有函數更好的支持Lambda表達式，Java
8引入了函數式介面的概念。函數式介面就是只有一個方法的普通介面。java.lang.Runnable與java.util.concurrent.Callable是函數式介面最典型的例子。為此，Java
8增加了一種特殊的註解@FunctionalInterface：

1 @FunctionalInterface
2 public interface Functional {
3 void method();
4 }

二、介面的默認方法與靜態方法

我們可以在介面中定義默認方法，使用default關鍵字，並提供默認的實現。所有實現這個介面的類都會接受默認方法的實現，除非子類提供的自己的實現。例如：

1 public interface DefaultFunctionInterface {
2 default String defaultFunction() {
3 return "default function";
4 }
5 }

我們還可以在介面中定義靜態方法，使用static關鍵字，也可以提供實現。例如：

1 public interface StaticFunctionInterface {
2 static String staticFunction() {
3 return "static function";
4 }
5 }

介面的默認方法和靜態方法的引入，其實可以認為引入了C＋＋中抽象類的理念，以後我們再也不用在每個實現類中都寫重復的代碼了。

三、方法引用

通常與Lambda表達式聯合使用，可以直接引用已有Java類或對象的方法。一般有四種不同的方法引用：

構造器引用。語法是Class::new，或者更一般的Class< T >::new，要求構造器方法是沒有參數；

靜態方法引用。語法是Class::static_method，要求接受一個Class類型的參數；

特定類的任意對象方法引用。它的語法是Class::method。要求方法是沒有參數的；

特定對象的方法引用，它的語法是instance::method。要求方法接受一個參數，與3不同的地方在於，3是在列表元素上分別調用方法，而4是在某個對象上調用方法，將列表元素作為參數傳入；

四、重復註解

在Java 5中使用註解有一個限制，即相同的註解在同一位置只能聲明一次。Java
8引入重復註解，這樣相同的註解在同一地方也可以聲明多次。重復註解機制本身需要用@Repeatable註解。Java
8在編譯器層做了優化，相同註解會以集合的方式保存，因此底層的原理並沒有變化。

五、擴展註解的支持

Java 8擴展了註解的上下文，幾乎可以為任何東西添加註解，包括局部變數、泛型類、父類與介面的實現，連方法的異常也能添加註解。

六、Optional

Java 8引入Optional類來防止空指針異常，Optional類最先是由Google的Guava項目引入的。Optional類實際上是個容器：它可以保存類型T的值，或者保存null。使用Optional類我們就不用顯式進行空指針檢查了。

七、Stream

Stream
API是把真正的函數式編程風格引入到Java中。其實簡單來說可以把Stream理解為MapRece，當然Google的MapRece的靈感也是來自函數式編程。她其實是一連串支持連續、並行聚集操作的元素。從語法上看，也很像linux的管道、或者鏈式編程，代碼寫起來簡潔明了，非常酷帥！

八、Date/Time API (JSR 310)

Java 8新的Date-Time API (JSR 310)受Joda-Time的影響，提供了新的java.time包，可以用來替代
java.util.Date和java.util.Calendar。一般會用到Clock、LocaleDate、LocalTime、LocaleDateTime、ZonedDateTime、Duration這些類，對於時間日期的改進還是非常不錯的。

九、JavaScript引擎Nashorn

Nashorn允許在JVM上開發運行JavaScript應用，允許Java與JavaScript相互調用。

十、Base64

在Java 8中，Base64編碼成為了Java類庫的標准。Base64類同時還提供了對URL、MIME友好的編碼器與解碼器。

除了這十大新特性之外，還有另外的一些新特性：

更好的類型推測機制：Java 8在類型推測方面有了很大的提高，這就使代碼更整潔，不需要太多的強制類型轉換了。

編譯器優化：Java 8將方法的參數名加入了位元組碼中，這樣在運行時通過反射就能獲取到參數名，只需要在編譯時使用-parameters參數。

並行（parallel）數組：支持對數組進行並行處理，主要是parallelSort()方法，它可以在多核機器上極大提高數組排序的速度。

並發（Concurrency）：在新增Stream機制與Lambda的基礎之上，加入了一些新方法來支持聚集操作。

Nashorn引擎jjs：基於Nashorn引擎的命令行工具。它接受一些JavaScript源代碼為參數，並且執行這些源代碼。

類依賴分析器jdeps：可以顯示Java類的包級別或類級別的依賴。

JVM的PermGen空間被移除：取代它的是Metaspace（JEP 122）。

『伍』 java基礎學習(12)RuntimeException和Exception

java將所有的錯誤封裝為一個對象，其根本父類為Throwable, Throwable有兩個子類：Error和Exception。Error是Throwable的子類，用於指示合理的應用程序不應該試圖捕獲的嚴重問題。大多數這樣的錯誤都是異常條件。雖然ThreadDeath錯誤是一個「正規」的條件，但它也是Error的子類，因為大多數應用程序都不應該試圖捕獲它。在執行該方法期間，無需在其throws子句中聲明可能拋出但是未能捕獲的Error的任何子類，因為這些錯誤可能是再也不會發生的異常條件。Exception類及其子類是Throwable的一種形式，它指出了合理的應用程序想要捕獲的條件。RuntimeException是那些可能在Java虛擬機正常運行期間拋出的異常的超類。可能在執行方法期間拋出但未被捕獲的RuntimeException 的任何子類都無需在throws子句中進行聲明。它是Exception的子類。異常的分類中，Error一般為底層的不可恢復的類； Exception分為未檢查異常(RuntimeException)和已檢查異常(非RuntimeException)。未檢查異常是因為程序員沒有進行必需要的檢查，因為疏忽和錯誤而引起的錯誤。RuntimeException：在定義方法時不需要聲明會拋出runtime exception； 在調用這個方法時不需要捕獲這個runtime exception； runtime exception是從java.lang.RuntimeException或java.lang.Error類衍生出來的。例如：nullpointexception，IndexOutOfBoundsException就屬於runtime exception。Exception：定義方法時必須聲明所有可能會拋出的exception； 在調用這個方法時，必須捕獲它的checked exception，不然就得把它的exception傳遞下去；exception是從java.lang.Exception類衍生出來的。例如：IOException，SQLException就屬於Exception。Exception屬於應用程序級別的異常，這類異常必須捕捉,Exception體系包括RuntimeException體系和其他非RuntimeException的體系；RuntimeException表示系統異常，比較嚴重，如果出現RuntimeException，那麼一定是程序員的錯誤。

常見的幾種RuntimeException一般面試中java Exception（runtimeException ）是必會被問到的問題。常見的異常列出四五種，是基本要求。常見的幾種如下：

• java.lang.AbstractMethodError 抽象方法錯誤。當應用試圖調用抽象方法時拋出。


• java.lang.AssertionError 斷言錯。用來指示一個斷言失敗的情況。


• java.lang.ClassCircularityError 類循環依賴錯誤。在初始化一個類時，若檢測到類之間循環依賴則拋出該異常。


• java.lang.ClassFormatError 類格式錯誤。當Java虛擬機試圖從一個文件中讀取Java類，而檢測到該文件的內容不符合類的有效格式時拋出。


• java.lang.Error 錯誤。是所有錯誤的基類，用於標識嚴重的程序運行問題。這些問題通常描述一些不應被應用程序捕獲的反常情況。


• java.lang.ExceptionInInitializerError 初始化程序錯誤。當執行一個類的靜態初始化程序的過程中，發生了異常時拋出。


• java.lang.IllegalAccessError 違法訪問錯誤。當一個應用試圖訪問、修改某個類的域（Field）或者調用其方法，但是又違反域或方法的可見性聲明，則拋出該異常。


• java.lang.IncompatibleClassChangeError 不兼容的類變化錯誤。當正在執行的方法所依賴的類定義發生了不兼容的改變時，拋出該異常。一般在修改了應用中的某些類的聲明定義而沒有對整個應用重新編譯而直接運行的情況下，容易引發該錯誤。


• java.lang.InstantiationError 實例化錯誤。當一個應用試圖通過Java的new操作符構造一個抽象類或者介面時拋出該異常.


• java.lang.InternalError 內部錯誤。用於指示Java虛擬機發生了內部錯誤。


• java.lang.LinkageError 鏈接錯誤。該錯誤及其所有子類指示某個類依賴於另外一些類，在該類編譯之後，被依賴的類改變了其類定義而沒有重新編譯所有的類，進而引發錯誤的情況。


• java.lang.NoClassDefFoundError 未找到類定義錯誤。當Java虛擬機或者類裝載器試圖實例化某個類，而找不到該類的定義時拋出該錯誤。


• java.lang.NoSuchFieldError 域不存在錯誤。當應用試圖訪問或者修改某類的某個域，而該類的定義中沒有該域的定義時拋出該錯誤。


• java.lang.NoSuchMethodError 方法不存在錯誤。當應用試圖調用某類的某個方法，而該類的定義中沒有該方法的定義時拋出該錯誤。


• java.lang.OutOfMemoryError 內存不足錯誤。當可用內存不足以讓Java虛擬機分配給一個對象時拋出該錯誤。


• java.lang.StackOverflowError 堆棧溢出錯誤。當一個應用遞歸調用的層次太深而導致堆棧溢出時拋出該錯誤。


• java.lang.ThreadDeath 線程結束。當調用Thread類的stop方法時拋出該錯誤，用於指示線程結束。


• java.lang.UnknownError 未知錯誤。用於指示Java虛擬機發生了未知嚴重錯誤的情況。


• java.lang.UnsatisfiedLinkError 未滿足的鏈接錯誤。當Java虛擬機未找到某個類的聲明為native方法的本機語言定義時拋出。


• java.lang.UnsupportedClassVersionError 不支持的類版本錯誤。當Java虛擬機試圖從讀取某個類文件，但是發現該文件的主、次版本號不被當前Java虛擬機支持的時候，拋出該錯誤。


• java.lang.VerifyError 驗證錯誤。當驗證器檢測到某個類文件中存在內部不兼容或者安全問題時拋出該錯誤。


• java.lang.VirtualMachineError 虛擬機錯誤。用於指示虛擬機被破壞或者繼續執行操作所需的資源不足的情況。


• java.lang.ArithmeticException 算術條件異常。譬如：整數除零等。


• java.lang. 數組索引越界異常。當對數組的索引值為負數或大於等於數組大小時拋出。


• java.lang.ArrayStoreException 數組存儲異常。當向數組中存放非數組聲明類型對象時拋出。


• java.lang.ClassCastException 類造型異常。假設有類A和B（A不是B的父類或子類），O是A的實例，那麼當強制將O構造為類B的實例時拋出該異常。該異常經常被稱為強制類型轉換異常。


• java.lang.ClassNotFoundException 找不到類異常。當應用試圖根據字元串形式的類名構造類，而在遍歷CLASSPAH之後找不到對應名稱的class文件時，拋出該異常。


• java.lang.CloneNotSupportedException 不支持克隆異常。當沒有實現Cloneable介面或者不支持克隆方法時,調用其clone()方法則拋出該異常。


• java.lang. 枚舉常量不存在異常。當應用試圖通過名稱和枚舉類型訪問一個枚舉對象，但該枚舉對象並不包含常量時，拋出該異常。


• java.lang.Exception 根異常。用以描述應用程序希望捕獲的情況。


• java.lang.IllegalAccessException 違法的訪問異常。當應用試圖通過反射方式創建某個類的實例、訪問該類屬性、調用該類方法，而當時又無法訪問類的、屬性的、方法的或構造方法的定義時拋出該異常。


• java.lang.IllegalMonitorStateException 違法的監控狀態異常。當某個線程試圖等待一個自己並不擁有的對象（O）的監控器或者通知其他線程等待該對象（O）的監控器時，拋出該異常。


• java.lang.IllegalStateException 違法的狀態異常。當在Java環境和應用尚未處於某個方法的合法調用狀態，而調用了該方法時，拋出該異常。


• java.lang.IllegalThreadStateException 違法的線程狀態異常。當縣城尚未處於某個方法的合法調用狀態，而調用了該方法時，拋出異常。


• java.lang.IndexOutOfBoundsException 索引越界異常。當訪問某個序列的索引值小於0或大於等於序列大小時，拋出該異常。


• java.lang.InstantiationException 實例化異常。當試圖通過newInstance()方法創建某個類的實例，而該類是一個抽象類或介面時，拋出該異常。


• java.lang.InterruptedException 被中止異常。當某個線程處於長時間的等待、休眠或其他暫停狀態，而此時其他的線程通過Thread的interrupt方法終止該線程時拋出該異常。


• java.lang.NegativeArraySizeException 數組大小為負值異常。當使用負數大小值創建數組時拋出該異常。


• java.lang.NoSuchFieldException 屬性不存在異常。當訪問某個類的不存在的屬性時拋出該異常。


• java.lang.NoSuchMethodException 方法不存在異常。當訪問某個類的不存在的方法時拋出該異常。


• java.lang.NullPointerException 空指針異常。當應用試圖在要求使用對象的地方使用了null時，拋出該異常。譬如：調用null對象的實例方法、訪問null對象的屬性、計算null對象的長度、使用throw語句拋出null等等。


• java.lang.NumberFormatException 數字格式異常。當試圖將一個String轉換為指定的數字類型，而該字元串確不滿足數字類型要求的格式時，拋出該異常。


• java.lang.RuntimeException 運行時異常。是所有Java虛擬機正常操作期間可以被拋出的異常的父類。


• java.lang.SecurityException 安全異常。由安全管理器拋出，用於指示違反安全情況的異常。


• java.lang. 字元串索引越界異常。當使用索引值訪問某個字元串中的字元，而該索引值小於0或大於等於序列大小時，拋出該異常。


• java.lang.TypeNotPresentException 類型不存在異常。當應用試圖以某個類型名稱的字元串表達方式訪問該類型，但是根據給定的名稱又找不到該類型是拋出該異常。該異常與ClassNotFoundException的區別在於該異常是unchecked（不被檢查）異常，而ClassNotFoundException是checked（被檢查）異常。


• java.lang.UnsupportedOperationException 不支持的方法異常。指明請求的方法不被支持情況的異常。

『陸』 JAVA反射機製作用

一、什麼是反射：
反射的概念是由Smith在1982年首次提出的，主要是指程序可以訪問、檢測和修改它本身狀態或行為的一種能力。這一概念的提出很快引發了計算機科學領域關於應用反射性的研究。它首先被程序語言的設計領域所採用,並在Lisp和面向對象方面取得了成績。其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基於反射機制的語言。最近，反射機制也被應用到了視窗系統、操作系統和文件系統中。反射本身並不是一個新概念，盡管計算機科學賦予了反射概念新的含義。在計算機科學領域，反射是指一類應用，它們能夠自描述和自控制。也就是說，這類應用通過採用某種機制來實現對自己行為的描述（self-representation）和監測（examination），並能根據自身行為的狀態和結果，調整或修改應用所描述行為的狀態和相關的語義。二、什麼是Java中的類反射：
Reflection 是 Java 程序開發語言的特徵之一，它允許運行中的 Java 程序對自身進行檢查，或者說「自審」，並能直接操作程序的內部屬性和方法。Java 的這一能力在實際應用中用得不是很多，但是在其它的程序設計語言中根本就不存在這一特性。例如，Pascal、C 或者 C++ 中就沒有辦法在程序中獲得函數定義相關的信息。
Reflection 是 Java 被視為動態（或准動態）語言的關鍵，允許程序於執行期 Reflection APIs 取得任何已知名稱之 class 的內部信息，包括 package、type parameters、superclass、implemented interfaces、inner classes, outer class, fields、constructors、methods、modifiers，並可於執行期生成instances、變更 fields 內容或喚起 methods。三、Java類反射中所必須的類：
Java的類反射所需要的類並不多，它們分別是：Field、Constructor、Method、Class、Object，下面我將對這些類做一個簡單的說明。
Field類：提供有關類或介面的屬性的信息，以及對它的動態訪問許可權。反射的欄位可能是一個類（靜態）屬性或實例屬性，簡單的理解可以把它看成一個封裝反射類的屬性的類。
Constructor類：提供關於類的單個構造方法的信息以及對它的訪問許可權。這個類和Field類不同，Field類封裝了反射類的屬性，而Constructor類則封裝了反射類的構造方法。
Method類：提供關於類或介面上單獨某個方法的信息。所反映的方法可能是類方法或實例方法（包括抽象方法）。 這個類不難理解，它是用來封裝反射類方法的一個類。
Class類：類的實例表示正在運行的 Java 應用程序中的類和介面。枚舉是一種類，注釋是一種介面。每個數組屬於被映射為 Class 對象的一個類，所有具有相同元素類型和維數的數組都共享該 Class 對象。
Object類：每個類都使用 Object 作為超類。所有對象（包括數組）都實現這個類的方法。四、Java的反射類能做什麼：
看完上面的這么多我想你已經不耐煩了，你以為我在浪費你的時間，那麼好吧！下面我們就用一些簡單的小例子來說明它。
首先我們來看一下通過Java的反射機制我們能得到些什麼。
首先我們來寫一個類：java 代碼

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
class A extends Object implements ActionListener{
private int a = 3;
public Integer b = new Integer(4);
public A(){}
public A(int id,String name){}
public int abc(int id,String name){return 0;}
public void actionPerformed(ActionEvent e){}
} 你可能被我這個類弄糊塗了，你看不出我要做什麼，那就不要看這個類了，這個類是用來測試的，你知道知道它繼承了Object類，有一個介面是ActionListener，兩個屬性int和Integer,兩個構造方法和兩個方法，這就足夠了。
下面我們把A這個類作為一個反射類，來過去A類中的一些信息，首先我們先來過去一下反射類中的屬性和屬性值。java 代碼

import java.lang.reflect.*;
class B{
public static void main(String args[]){
A r = new A();
Class temp = r.getClass();
try{
System.out.println("反射類中所有公有的屬性");
Field[] fb =temp.getFields();
for(int j=0;j<fb.length;j++){
Class cl = fb[j].getType();
System.out.println("fb:"+cl);
}

System.out.println("反射類中所有的屬性");
Field[] fa = temp.getDeclaredFields();
for(int j=0;j<fa.length;j++){
Class cl = fa[j].getType();
System.out.println("fa:"+cl);
}
System.out.println("反射類中私有屬性的值");
Field f = temp.getDeclaredField("a");
f.setAccessible(true);
Integer i = (Integer)f.get(r);
System.out.println(i);
}catch(Exception e){
e.printStackTrace();
}
}

} 這里用到了兩個方法，getFields()、getDeclaredFields()，它們分別是用來獲取反射類中所有公有屬性和反射類中所有的屬性的方法。另外還有getField(String)和getDeclaredField(String)方法都是用來過去反射類中指定的屬性的方法，要注意的是getField方法只能取到反射類中公有的屬性，而getDeclaredField方法都能取到。
這里還用到了Field 類的setAccessible方法，它是用來設置是否有許可權訪問反射類中的私有屬性的，只有設置為true時才可以訪問，默認為false。另外 Field類還有set(Object AttributeName,Object value)方法，可以改變指定屬性的值。下面我們來看一下如何獲取反射類中的構造方法java 代碼

import java.lang.reflect.*;
public class SampleConstructor {
public static void main(String[] args) {
A r = new A();
printConstructors(r);
}

public static void printConstructors(A r) {
Class c = r.getClass();
//獲取指定類的類名
String className = c.getName();
try {
//獲取指定類的構造方法
Constructor[] theConstructors = c.getConstructors();
for(int i=0; i<theConstructors.length; i++) {
//獲取指定構造方法的參數的集合
Class[] parameterTypes = theConstructors[i].getParameterTypes();

System.out.print(className + "(");

for(int j=0; j<parameterTypes.length; j++)
System.out.print(parameterTypes[j].getName() + " ");

System.out.println(")");

}
}catch(Exception e) {
e.printStackTrace();
}
}
}
這個例子很簡單,只是用getConstructors()方法獲取了反射類的構造方法的集合，並用Constructor類的getParameterTypes()獲取該構造方法的參數。下面我們再來獲取一下反射類的父類（超類）和介面java 代碼

import java.io.*;
import java.lang.reflect.*;

public class SampleInterface {
public static void main(String[] args) throws Exception {
A raf = new A();
printInterfaceNames(raf);
}

public static void printInterfaceNames(Object o) {
Class c = o.getClass();
//獲取反射類的介面
Class[] theInterfaces = c.getInterfaces();
for(int i=0; i<theInterfaces.length; i++)
System.out.println(theInterfaces[i].getName());
//獲取反射類的父類（超類）
Class theSuperclass = c.getSuperclass();
System.out.println(theSuperclass.getName());
}
} 這個例子也很簡單，只是用Class類的getInterfaces()方法獲取反射類的所有介面，由於介面可以有多個，所以它返回一個 Class數組。用getSuperclass()方法來獲取反射類的父類（超類），由於一個類只能繼承自一個類，所以它返回一個Class對象。下面我們來獲取一下反射類的方法java 代碼

import java.lang.reflect.*;
public class SampleMethod {

public static void main(String[] args) {
A p = new A();
printMethods(p);
}

public static void printMethods(Object o) {
Class c = o.getClass();
String className = c.getName();
Method[] m = c.getMethods();
for(int i=0; i<m.length; i++) {
//輸出方法的返回類型
System.out.print(m[i].getReturnType().getName());
//輸出方法名
System.out.print(" "+m[i].getName()+"(");
//獲取方法的參數
Class[] parameterTypes = m[i].getParameterTypes();
for(int j=0; j<parameterTypes.length; j++){
System.out.print(parameterTypes[j].getName());
if(parameterTypes.length>j+1){
System.out.print(",");
}
}

System.out.println(")");
}

}

} 這個例子並不難，它只是獲得了反射類的所有方法，包括繼承自它父類的方法。然後獲取方法的返回類型、方法名和方法參數。接下來讓我們回過頭來想一想，我們獲取了反射類的屬性、構造方法、父類、介面和方法，可這些東西能幫我們做些什麼呢！！
下面我寫一個比較完整的小例子，來說明Java的反射類能做些什麼吧！！java 代碼

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class LoadMethod {
public Object Load(String cName,String MethodName,String[] type,String[] param){
Object retobj = null;
try {
//載入指定的Java類
Class cls = Class.forName(cName);

//獲取指定對象的實例
Constructor ct = cls.getConstructor(null);
Object obj = ct.newInstance(null);

//構建方法參數的數據類型
Class partypes[] = this.getMethodClass(type);

//在指定類中獲取指定的方法
Method meth = cls.getMethod(MethodName, partypes);

//構建方法的參數值
Object arglist[] = this.getMethodObject(type,param);

//調用指定的方法並獲取返回值為Object類型
retobj= meth.invoke(obj, arglist);

}
catch (Throwable e) {
System.err.println(e);
}
return retobj;
}

//獲取參數類型Class[]的方法
public Class[] getMethodClass(String[] type){
Class[] cs = new Class[type.length];
for (int i = 0; i < cs.length; i++) {
if(!type[i].trim().equals("")||type[i]!=null){
if(type[i].equals("int")||type[i].equals("Integer")){
cs[i]=Integer.TYPE;
}else if(type[i].equals("float")||type[i].equals("Float")){
cs[i]=Float.TYPE;
}else if(type[i].equals("double")||type[i].equals("Double")){
cs[i]=Double.TYPE;
}else if(type[i].equals("boolean")||type[i].equals("Boolean")){
cs[i]=Boolean.TYPE;
}else{
cs[i]=String.class;
}
}
}
return cs;
}

//獲取參數Object[]的方法
public Object[] getMethodObject(String[] type,String[] param){
Object[] obj = new Object[param.length];
for (int i = 0; i < obj.length; i++) {
if(!param[i].trim().equals("")||param[i]!=null){
if(type[i].equals("int")||type[i].equals("Integer")){
obj[i]= new Integer(param[i]);
}else if(type[i].equals("float")||type[i].equals("Float")){
obj[i]= new Float(param[i]);
}else if(type[i].equals("double")||type[i].equals("Double")){
obj[i]= new Double(param[i]);
}else if(type[i].equals("boolean")||type[i].equals("Boolean")){
obj[i]=new Boolean(param[i]);
}else{
obj[i] = param[i];
}
}
}
return obj;
}
} 這是我在工作中寫的一個實現Java在運行時載入指定的類，並調用指定方法的一個小例子。這里沒有main方法，你可以自己寫一個。
Load方法接收的五個參數分別是，Java的類名，方法名，參數的類型和參數的值。結束語：
Java語言反射提供一種動態鏈接程序組件的多功能方法。它允許程序創建和控制任何類的對象，無需提前硬編碼目標類。這些特性使得反射特別適用於創建以非常普通的方式與對象協作的庫。Java reflection 非常有用，它使類和數據結構能按名稱動態檢索相關信息，並允許在運行著的程序中操作這些信息。Java 的這一特性非常強大，並且是其它一些常用語言，如 C、C++、Fortran 或者 Pascal 等都不具備的。但反射有兩個缺點。第一個是性能問題。用於欄位和方法接入時反射要遠慢於直接代碼。性能問題的程度取決於程序中是如何使用反射的。如果它作為程序運行中相對很少涉及的部分，緩慢的性能將不會是一個問題。即使測試中最壞情況下的計時圖顯示的反射操作只耗用幾微秒。僅反射在性能關鍵的應用的核心邏輯中使用時性能問題才變得至關重要。