目錄
一.反射
1.1反射的基本情況
1.2反射中最重要的類
1.2.1 Class類
1.2.2Field類
1.2.3Constructor類
1.2.4Method類
1.3反射優(yōu)缺點?
二.枚舉
2.1概念
2.2枚舉（enum）類方法
2.3枚舉的構造
三.Lambda表達式
3.1Lambda介紹
3.2 函數(shù)式接口
3.3使用lambda表達式
3.2.1不使用Lambda表達式調(diào)用
3.2.2使用Lambda表達式
3.2.3二者區(qū)別
3.4變量捕獲
3.4.1匿名內(nèi)部類的變量捕獲
?3.4.2Lambda變量捕獲
總結
??個人主頁：tq02的博客_CSDN博客-C語言,Java,Java數(shù)據(jù)結構領域博主
???夢的目標：努力學習，向Java進發(fā)，拼搏一切，讓自己的未來不會有遺憾。
???歡迎各位→點贊?? + 收藏? + 評論??+關注?
? 本章講解內(nèi)容：反射、枚舉以及Lambda表達式? ? ??使用編譯器：IDEA
一.反射
1.1反射的基本情況
定義：Java在 運行 狀態(tài)時，對于任意一個類，都能知道這個類的所有屬性和方法。
? ??這種動態(tài)獲取信息以及動態(tài)調(diào)用對象方法的功能稱為java語言的反射（reflection）機制
?用途：1.在日常的第三方應用開發(fā)過程中，經(jīng)常會遇到某個類的某個成員變量、方法或是屬性是私有的或是只對系統(tǒng)應用開放，這時候就可以利用?Java的反射機制?來獲取所需的私有成員或是方法 。
????????2. 反射最重要的用途就是開發(fā)各種通用框架，比如在spring中，我們將所有的類Bean交給spring容器管理，無論是XML配置Bean還是注解配置，當我們從容器中獲取Bean來依賴注入時，容器會讀取配置，而配置中給的就是類的信息，spring根據(jù)這些信息，需要創(chuàng)建那些Bean，spring就動態(tài)的創(chuàng)建這些類。
1.2反射中最重要的類
| 類名 | ? ? ? ? 用途 |
| class類 | 代表類的實體，在運行的Java應用程序中表示類和接口 |
| Field類 | 代表類的成員變量、類的屬性 |
| Method類 | 代表類的方法 |
| Constructor類 | 代表類的構造方法 |
在講解這些類之前，我們需要先構建一個類，方便進行反射的操作：
class Student{
//私有屬性name
private String name = "tq02";
//公有屬性age
public int age = 22;
//不帶參數(shù)的構造方法
public Student(){
System.out.println("Student()");
}
private Student(String name,int age) {
this.name = name;
this.age = age;
System.out.println("Student(String,name)");
}
private void eat(){
System.out.println("i am eat");
}
public void sleep(){
System.out.println("i am pig");
}
private void function(String str) {
System.out.println(str);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}?注：1.反射私有的構造方法、屬性、方法時，Java具有安全性，因此我們需要使用.setAccessible("boolean");
? ? ? ? 2.使用Class類、Field、Constructor類時，需要處理異常。
1.2.1 Class類
? ? ? ? ?在反射之前，第一步就是先拿到當前需要反射的類的Class對象，然后通過Class對象的核心方法，達到反射的目的，即：在運行狀態(tài)中，對于任意一個類，都能夠知道這個類的所有屬性和方法；對于任意一個對象， 都能夠調(diào)用它的任意方法和屬性，既然能拿到，我們就可以修改部分類型信息。
使用Class獲取 類 的三種方法：
第一種：使用Class.forName("類的全路徑名“”); //靜態(tài)方法
第二種：使用.class方法。
第三種：使用類對象的getClass()方法;
注：無論哪種方法獲取，其實獲取的都是同一個類。
代碼實例 :
public class TestDemo {
public static void main(String[] args) {
//1.通過getClass獲取Class對象
Student s1 = new Student();
Class c1 = s1.getClass();
//2.直接通過 類名.class 的方式得到,該方法最為安全可靠，程序性能更高
//這說明任何一個類都有一個隱含的靜態(tài)成員變量 class
Class c2 = Student.class;
//3、通過 Class 對象的 forName() 靜態(tài)方法來獲取，用的最多，
//但可能拋出 ClassNotFoundException 異常
Class c3 = null;
try {
//注意這里是類的全路徑，如果有包需要加包的路徑
c3 = Class.forName("Student");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//一個類在 JVM 中只會有一個 Class 實例,即我們對上面獲取的
//c1,c2,c3進行 equals 比較，發(fā)現(xiàn)都是true
System.out.println(c1.equals(c2));
System.out.println(c1.equals(c3));
System.out.println(c2.equals(c3));
}
1.2.2Field類
作用：可對類中屬性進行操作
| 方法 | 用途 |
| getFiled（String name） | 獲取某個公有的屬性對象 |
| getFileds() | 獲取所有公用的屬性對象 |
| getDeclaredField(String name) | 獲取某個屬性對象 |
| getDeclcareFileds（） | 獲取所有屬性對象 |
public static void reflectPrivateField() {
try {
Class<?> classStudent = Class.forName("Student");
//獲取name成員變量
Field field = classStudent.getDeclaredField("name");
field.setAccessible(true);
Student student= (Student)classStudent.newInstance();
//修改成員變量，將student中的name值改成"小明"；
field.set(student, "小明");
String name = (String) field.get(student);
System.out.println("反射私有屬性修改了name：" + name);
} catch (Exception ex) {
ex.printStackTrace();
}
}1.2.3Constructor類
作用：對構造方法進行操作
| 方法 | 用途 |
| getConstructor(類型.class,類型.class） | 獲取該類中與參數(shù)類型匹配的公有構造方法 |
| getConstructors(） | 獲得該類的所有公有構造方法 |
| getDeclaredConstructors(類型.class,類型.class） | 獲取該類中與參數(shù)匹配的構造方法(包含私有構造方法) |
| getDeclaredConstructors（） | 獲取該類所有的構造方法 |
?代碼實例：
//反射構造方法
public static void reflect() {
try {
Class<?> c1 = Class.forName("Student");
Constructor<?> c2= c1.getDeclaredConstructor(String.class,int.class);
c2.setAccessible(true);
c2.newInstance("湯琦",22);
}catch(Exception ex)
{
ex.printStackTrace();
}
}1.2.4Method類
作用：對類中方法進行操作
| 方法 | 用途 |
| getMethod("方法名"，類型.class) | 使用該類的某個公有的方法 |
| getMethods（） | 使用該類所有公有的方法 |
| getDeclaredMethod("方法名"，類型.class) | 使用該類的某個方法 |
| getDeclaredMethod() | 使用該類所有方法 |
實例代碼：
public static void reflectPrivateMethod() {
try {
Class<?> c1 = Class.forName("Student");
Method m1=c1.getDeclaredMethod("function", String.class);
m1.setAccessible(true);
Student fw=(Student) c1.newInstance();
m1.invoke(fw,"給私有的function函數(shù)傳的參數(shù)");
}catch(Exception ex)
{
ex.printStackTrace();
}
}1.3反射優(yōu)缺點?
優(yōu)點：?1. 對于任意一個類，都能夠知道這個類的所有屬性和方法；對?于任意一個對象，都能夠調(diào)用它的任意一個方法
? ? ? ? ? 2. 增加程序的靈活性和擴展性，降低耦合性，提高自適應能力
? ? ? ? ? 3. 反射已經(jīng)運用在了很多流行框架如：Struts、Hibernate、Spring 等等。
缺點：?1. 使用反射會有效率問題。會導致程序效率降低。具體參考里：鏈接
? ? ? ? ? ? 2. 反射技術繞過了源代碼的技術，因而會帶來維護問題。反射代碼比相應的直接代碼更復雜?
二.枚舉
2.1概念
??????在Java中，可以說是一個集合，從下標0開始的集合。注：枚舉是jdk1.5以后引用的。
使用格式：? ?public enum? 類名{
? ? ? ? ? ? ? ? ? ? ?常量1、常量2、常量3；? ? ? ? ? ??
? ? ? ? ? ? ? ? ? ? }
就是將class換成了enum
代碼實例：
public enum TestEnum {
RED,BLACK,GREEN,WHITE;//相當于集合，第一個常量下標值為0，第二個常量下標值為1......
public static void main(String[] args) {
TestEnum testEnum2 = TestEnum.BLACK;
switch (testEnum2) {
case RED: System.out.println("red"); break;
case BLACK:System.out.println("black");break;
case WHITE:System.out.println("WHITE");break;
case GREEN:System.out.println("black");break;
default:break;
}
}2.2枚舉（enum）類方法
| 方法名 | 用法 |
| values() | 以數(shù)組形式返回枚舉的所有類型 |
| ordinal() |
獲取該枚舉成員的下標值 |
| valueOf() | 將普通字符串轉換成枚舉實例 |
| compareTo() | 比較兩個枚舉成員定義時的順序 |
2.3枚舉的構造
? ? ? 枚舉的構造方法默認是私有的。
public enum TestEnum {
RED("red",1),BLACK("black",2),WHITE("white",3),GREEN("green",4);
private String name;
private int key;
/**
* 1、當枚舉對象有參數(shù)后，需要提供相應的構造函數(shù)
* 2、枚舉的構造函數(shù)默認是私有的 這個一定要記住
* @param name
* @param key
*/
private TestEnum (String name,int key) {
this.name = name;
this.key = key;
}
public static TestEnum getEnumKey (int key) {
for (TestEnum t: TestEnum.values()) {
if(t.key == key) {
return t;
}
}
return null;
}
public static void main(String[] args) {
System.out.println(getEnumKey(2));
}
}注：自己寫的枚舉類，默認繼承與enum這個類的。
三.Lambda表達式
3.1Lambda介紹
Lambda本質(zhì)是匿名函數(shù)，基于數(shù)學中的λ演算得名，也可稱為閉包（Closure）
語法格式：（parameters）->expression 或 (parameters)->{ statements;}
parameters:類似方法中的形參列表，這里的參數(shù)是函數(shù)式接口里的參數(shù)。這里的參數(shù)類型可以明確的聲明也可不聲明而由JVM隱含的推斷。另外當只有一個推斷類型時可以省略掉圓括號。
->：可理解為“被用于”的意思
方法體：可以是表達式也可以代碼塊，是函數(shù)式接口里方法的實現(xiàn)。代碼塊可返回一個值或者什么都不反回，這里的代碼塊塊等同于方法的方法體。如果是表達式，也可以返回一個值或者什么都不反回。
常見表達式：
// 1. 不需要參數(shù),返回值為 2
() -> 2
// 2. 接收一個參數(shù)(數(shù)字類型),返回其2倍的值
x -> 2 * x
// 3. 接受2個參數(shù)(數(shù)字),并返回他們的和
(x, y) -> x + y
// 4. 接收2個int型整數(shù),返回他們的乘積
(int x, int y) -> x * y
// 5. 接受一個 string 對象,并在控制臺打印,不返回任何值(看起來像是返回void)
(String s) -> System.out.print(s)
3.2 函數(shù)式接口
? ? ? ? 定義：該接口有且只有一個?抽象方法
注：如果某接口含有@FunctionalInterface?注解，那么編譯器就會按照函數(shù)式接口的定義來要求該接口，這樣如果有兩個抽象方法，程序編譯就會報錯的。
代碼實例：
@FunctionalInterface
interface NoParameterNoReturn {
//注意：只能有一個方法
void test();
}3.3使用lambda表達式
先建立幾個接口：
//無返回值無參數(shù)
@FunctionalInterface
interface NoParameterNoReturn {
void test();
}
//無返回值一個參數(shù)
@FunctionalInterface
interface OneParameterNoReturn {
void test(int a);
}
//無返回值多個參數(shù)
@FunctionalInterface
interface MoreParameterNoReturn {
void test(int a,int b);
}
//有返回值無參數(shù)
@FunctionalInterface
interface NoParameterReturn {
int test();
}
//有返回值一個參數(shù)
@FunctionalInterface
interface OneParameterReturn {
int test(int a);
}
//有返回值多參數(shù)
@FunctionalInterface
interface MoreParameterReturn {
int test(int a,int b);
}Lambda就是匿名內(nèi)部類的簡化，實際上是創(chuàng)建了一個類，實現(xiàn)了接口，重寫了接口的方法 。
3.3.1不使用Lambda表達式調(diào)用
public class TestDemo {
public static void main(String[] args) {
//接口使用匿名內(nèi)部類
NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
@Override
public void test() {
System.out.println("hello");
}
};
noParameterNoReturn.test();
}3.3.2使用Lambda表達式
public class TestDemo {
public static void main(String[] args) {
NoParameterNoReturn noParameterNoReturn = ()->{
System.out.println("無參數(shù)無返回值");
};
noParameterNoReturn.test();
OneParameterNoReturn oneParameterNoReturn = (int a)->{
System.out.println("一個參數(shù)無返回值："+ a);
};
oneParameterNoReturn.test(10);
MoreParameterNoReturn moreParameterNoReturn = (int a,int b)->{
System.out.println("多個參數(shù)無返回值："+a+" "+b);
};
moreParameterNoReturn.test(20,30);
NoParameterReturn noParameterReturn = ()->{
System.out.println("有返回值無參數(shù)！");
return 40;
};
//接收函數(shù)的返回值
int ret = noParameterReturn.test();
System.out.println(ret);
OneParameterReturn oneParameterReturn = (int a)->{
System.out.println("有返回值有一個參數(shù)！");
return a;
};
ret = oneParameterReturn.test(50);
System.out.println(ret);
MoreParameterReturn moreParameterReturn = (int a,int b)->{
System.out.println("有返回值多個參數(shù)！");
return a+b;
};
ret = moreParameterReturn.test(60,70);
System.out.println(ret);
}
}3.3.3二者區(qū)別
代碼實例：
?1. 參數(shù)類型可以省略，如果需要省略，每個參數(shù)的類型都要省略。
?2. 參數(shù)的小括號里面只有一個參數(shù)，那么小括號可以省略
?3. 如果方法體當中只有一句代碼，那么大括號可以省略
?4. 如果方法體中只有一條語句，且是return語句，那么大括號可以省略，且去掉return關鍵字。
3.4變量捕獲
變量捕獲，在匿名內(nèi)部類中也存在，而類似匿名內(nèi)部類的Lambda表達式，自然而然也存在。
3.4.1匿名內(nèi)部類的變量捕獲
?如上圖，在匿名內(nèi)部類外，已經(jīng)定義了a的值，因此匿名內(nèi)部類直接捕獲了外部的a變量。
?3.4.2Lambda變量捕獲
??如上圖，使用直接捕獲了外部的a變量。
注：無論是匿名內(nèi)部類的變量捕獲還是Lambda變量捕獲，方法體里，不可修改外部變量的值。文章來源：http://www.zghlxwxcb.cn/news/detail-476281.html
總結
反射、枚舉以及Lambda表達式很少使用，算是偏僻的知識點，因此不要求掌握，只要求熟悉。文章來源地址http://www.zghlxwxcb.cn/news/detail-476281.html
到了這里，關于Java語言----反射、枚舉以及l(fā)ambda表達式的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！
