本文目錄一覽：
- 1、java反射機制詳解
- 2、java課程分享Java的反射機制
- 3、java中的反射機制是什麼，有什麼作用啊？
- 4、java中的反射機制是什麼？有什麼作用呢？求解，謝謝。
- 5、什麼是反射？什麼Java反射？
java反射機制詳解
反射就是把Java的各種成分映射成相應的Java類。
Class類的構造方法是private，由JVM創建。
反射是java語言的一個特性，它允程序在運行時（注意不是編譯的時候）來進行自我檢查並且對內部的成員進行操作。例如它允許一個java的類獲取他所有的成員變量和方法並且顯示出來。Java 的這一能力在實際應用中也許用得不是很多，但是在其它的程序設計語言中根本就不存在這一特性。例如，Pascal、C 或者 C++ 中就沒有辦法在程序中獲得函數定義相關的信息。（來自Sun）
JavaBean 是 reflection 的實際應用之一，它能讓一些工具可視化的操作軟件組件。這些工具通過 reflection 動態的載入並取得 Java 組件(類) 的屬性。
反射是從1.2就有的，後面的三大框架都會用到反射機制,涉及到類”Class”,無法直接new CLass()，其對象是內存里的一份位元組碼.
Class 類的實例表示正在運行的 Java 應用程序中的類和接口。枚舉是一種類，注釋是一種接口。每個數組屬於被映射為 Class 對象的一個類，所有具有相同元素類型和維數的數組都共享該 Class 對象。
基本的 Java類型（boolean、byte、char、short、int、long、float 和 double）和關鍵字 void 也表示為 Class 對象。Class 沒有公共構造方法。
Class 對象是在加載類時由 Java 虛擬機以及通過調用類加載器中的 defineClass 方法自動構造的。
Person p1 = new Person();
//下面的這三種方式都可以得到位元組碼
CLass c1 = Date.class();
p1.getClass();
//若存在則加載，否則新建,往往使用第三種,類的名字在寫源程序時不需要知道，到運行時再傳遞過來
Class.forName(“java.lang.String”);
Class.forName()位元組碼已經加載到java虛擬機中，去得到位元組碼；java虛擬機中還沒有生成位元組碼 用類加載器進行加載，加載的位元組碼緩衝到虛擬機中。
另外，大家可以關注微信公眾號Java技術棧回復：JVM，獲取我整理的系列JVM教程，都是乾貨。
考慮下面這個簡單的例子，讓我們看看 reflection 是如何工作的。
import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(“java.util.Stack”);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i m.length; i++)
System.out.println(m[i].toString());
}
catch (Throwable e){
System.err.println(e);
}
}
}
public synchronized java.lang.Object java.util.Stack.pop()
public java.lang.Object java.util.Stack.push(java.lang.Object)
public boolean java.util.Stack.empty()
public synchronized java.lang.Object java.util.Stack.peek()
public synchronized int java.util.Stack.search(java.lang.Object)
這樣就列出了java.util.Stack 類的各方法名以及它們的限制符和返回類型。這個程序使用 Class.forName 載入指定的類，然後調用 getDeclaredMethods 來獲取這個類中定義了的方法列表。java.lang.reflect.Methods 是用來描述某個類中單個方法的一個類。
以下示例使用 Class 對象來顯示對象的類名：
void printClassName(Object obj) {
System.out.println(“The class of ” + obj +
” is ” + obj.getClass().getName());
}
還可以使用一個類字面值（JLS Section 15.8.2）來獲取指定類型（或 void）的 Class 對象。例如：
System.out.println(“The name of class Foo is: “+Foo.class.getName());
在沒有對象實例的時候，主要有兩種辦法。
//獲得類類型的兩種方式
Class cls1 = Role.class;
Class cls2 = Class.forName(“yui.Role”);
注意第二種方式中，forName中的參數一定是完整的類名（包名+類名），並且這個方法需要捕獲異常。現在得到cls1就可以創建一個Role類的實例了，利用Class的newInstance方法相當於調用類的默認的構造器。
Object o = cls1.newInstance();
//創建一個實例
//Object o1 = new Role(); //與上面的方法等價
java課程分享Java的反射機制
Java反射機制是一個非常強大的功能，在很多大型項目比如Spring,Mybatis都可以看見反射的身影。通過反射機制我們可以在運行期間獲取對象的類型信息，利用這一特性我們可以實現工廠模式和代理模式等設計模式，同時也可以解決Java泛型擦除等令人苦惱的問題。下面java課程就從實際應用的角度出發，來應用一下Java的反射機制。
反射基礎
p.s:本文需要讀者對反射機制的API有一定程度的了解，如果之前沒有接觸過的話，建議先看一下官方文檔的QuickStart。
在應用反射機制之前，首先我們先來看一下如何獲取一個對象對應的反射類Class，在Java中我們有三種方法可以獲取一個對象的反射類。
通過getClass方法
在Java中，每一個Object都有一個getClass方法，通過getClass方法我們可以獲取到這個對象對應的反射類：
Strings=”ziwenxie”;
Class?c=s.getClass();
通過forName方法
我們也可以調用Class類的靜態方法forName：
Class?c=Class.forName(“java.lang.String”);
使用.class
或者我們也可以直接使用.class：
Class?c=String.class;
獲取類型信息
在文章開頭我們就提到反射的一大好處就是可以允許我們在運行期間獲取對象的類型信息，下面我們通過一個例子來具體看一下。
首先我們在typeinfo.interfacea包下面新建一個接口A：
packagetypeinfo.interfacea;
publicinterfaceA{voidf();}
接着我們在typeinfo.packageaccess包下面新建一個接口C，接口C繼承自接口A，並且我們還另外創建了幾個用於測試的方法，注意下面幾個方法的權限都是不同的。
java中的反射機制是什麼，有什麼作用啊？
JAVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。
JAVA反射（放射）機制：「程序運行時，允許改變程序結構或變量類型，這種語言稱為動態語言」。從這個觀點看，Perl，Python，Ruby是動態語言，C++，Java，C#不是動態語言。但是JAVA有着一個非常突出的動態相關機制：Reflection，用在Java身上指的是我們可以於運行時加載、探知、使用編譯期間完全未知的classes。換句話說，Java程序可以加載一個運行時才得知名稱的class，獲悉其完整構造（但不包括methods定義），並生成其對象實體、或對其fields設值、或喚起其methods。
Java反射機制主要提供了以下功能： 在運行時判斷任意一個對象所屬的類；在運行時構造任意一個類的對象；在運行時判斷任意一個類所具有的成員變量和方法；在運行時調用任意一個對象的方法；生成動態代理。
有時候我們說某個語言具有很強的動態性，有時候我們會區分動態和靜態的不同技術與作法。我們朗朗上口動態綁定（dynamic binding）、動態鏈接（dynamic linking）、動態加載（dynamic loading）等。然而「動態」一詞其實沒有絕對而普遍適用的嚴格定義，有時候甚至像面向對象當初被導入編程領域一樣，一人一把號，各吹各的調。
一般而言，開發者社群說到動態語言，大致認同的一個定義是：「程序運行時，允許改變程序結構或變量類型，這種語言稱為動態語言」。從這個觀點看，Perl，Python，Ruby是動態語言，C++，Java，C#不是動態語言。
儘管在這樣的定義與分類下Java不是動態語言，它卻有着一個非常突出的動態相關機制：Reflection。這個字的意思是「反射、映象、倒影」，用在Java身上指的是我們可以於運行時加載、探知、使用編譯期間完全未知的classes。換句話說，Java程序可以加載一個運行時才得知名稱的class，獲悉其完整構造（但不包括methods定義），並生成其對象實體、或對其fields設值、或喚起其methods。這種「看透class」的能力（the ability of the program to examine itself）被稱為introspection（內省、內觀、反省）。Reflection和introspection是常被並提的兩個術語。
Java如何能夠做出上述的動態特性呢？這是一個深遠話題，本文對此只簡單介紹一些概念。整個篇幅最主要還是介紹Reflection APIs，也就是讓讀者知道如何探索class的結構、如何對某個「運行時才獲知名稱的class」生成一份實體、為其fields設值、調用其methods。本文將談到java.lang.Class，以及java.lang.reflect中的Method、Field、Constructor等等classes。
java中的反射機制是什麼？有什麼作用呢？求解，謝謝。
Java反射機制詳解
1. 反射機制是什麼
反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。
2. 反射機制能做什麼
反射機制主要提供了以下功能：
在運行時判斷任意一個對象所屬的類；
在運行時構造任意一個類的對象；
在運行時判斷任意一個類所具有的成員變量和方法；
在運行時調用任意一個對象的方法；
生成動態代理。
3. 反射機制的相關API
通過一個對象獲得完整的包名和類名
package net.xsoftlab.baike;
public class TestReflect {
public static void main(String[] args) throws Exception {
TestReflect testReflect = new TestReflect();
System.out.println(testReflect.getClass().getName());
// 結果 net.xsoftlab.baike.TestReflect
}
}
實例化Class類對象
package net.xsoftlab.baike;
public class TestReflect {
public static void main(String[] args) throws Exception {
Class? class1 = null;
Class? class2 = null;
Class? class3 = null;
// 一般採用這種形式
class1 = Class.forName(“net.xsoftlab.baike.TestReflect”);
class2 = new TestReflect().getClass();
class3 = TestReflect.class;
System.out.println(“類名稱 ” + class1.getName());
System.out.println(“類名稱 ” + class2.getName());
System.out.println(“類名稱 ” + class3.getName());
}
}
獲取一個對象的父類與實現的接口
package net.xsoftlab.baike;
import java.io.Serializable;
public class TestReflect implements Serializable {
private static final long serialVersionUID = -2862585049955236662L;
public static void main(String[] args) throws Exception {
Class? clazz = Class.forName(“net.xsoftlab.baike.TestReflect”);
// 取得父類
Class? parentClass = clazz.getSuperclass();
System.out.println(“clazz的父類為：” + parentClass.getName());
// clazz的父類為： java.lang.Object
// 獲取所有的接口
Class? intes[] = clazz.getInterfaces();
System.out.println(“clazz實現的接口有：”);
for (int i = 0; i intes.length; i++) {
System.out.println((i + 1) + “：” + intes[i].getName());
}
// clazz實現的接口有：
// 1：java.io.Serializable
}
}
獲取某個類中的全部構造函數 – 詳見下例
通過反射機制實例化一個類的對象
package net.xsoftlab.baike;
import java.lang.reflect.Constructor;
public class TestReflect {
public static void main(String[] args) throws Exception {
Class? class1 = null;
class1 = Class.forName(“net.xsoftlab.baike.User”);
// 第一種方法，實例化默認構造方法，調用set賦值
User user = (User) class1.newInstance();
user.setAge(20);
user.setName(“Rollen”);
System.out.println(user);
// 結果 User [age=20, name=Rollen]
// 第二種方法 取得全部的構造函數 使用構造函數賦值
Constructor? cons[] = class1.getConstructors();
// 查看每個構造方法需要的參數
for (int i = 0; i cons.length; i++) {
Class? clazzs[] = cons[i].getParameterTypes();
System.out.print(“cons[” + i + “] (“);
for (int j = 0; j clazzs.length; j++) {
if (j == clazzs.length – 1)
System.out.print(clazzs[j].getName());
else
System.out.print(clazzs[j].getName() + “,”);
}
System.out.println(“)”);
}
// 結果
// cons[0] (java.lang.String)
// cons[1] (int,java.lang.String)
// cons[2] ()
user = (User) cons[0].newInstance(“Rollen”);
System.out.println(user);
// 結果 User [age=0, name=Rollen]
user = (User) cons[1].newInstance(20, “Rollen”);
System.out.println(user);
// 結果 User [age=20, name=Rollen]
}
}
class User {
private int age;
private String name;
public User() {
super();
}
public User(String name) {
super();
this.name = name;
}
public User(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return “User [age=” + age + “, name=” + name + “]”;
}
}
獲取某個類的全部屬性
package net.xsoftlab.baike;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class TestReflect implements Serializable {
private static final long serialVersionUID = -2862585049955236662L;
public static void main(String[] args) throws Exception {
Class? clazz = Class.forName(“net.xsoftlab.baike.TestReflect”);
System.out.println(“===============本類屬性===============”);
// 取得本類的全部屬性
Field[] field = clazz.getDeclaredFields();
for (int i = 0; i field.length; i++) {
// 權限修飾符
int mo = field[i].getModifiers();
String priv = Modifier.toString(mo);
// 屬性類型
Class? type = field[i].getType();
System.out.println(priv + ” ” + type.getName() + ” ” + field[i].getName() + “;”);
}
System.out.println(“==========實現的接口或者父類的屬性==========”);
// 取得實現的接口或者父類的屬性
Field[] filed1 = clazz.getFields();
for (int j = 0; j filed1.length; j++) {
// 權限修飾符
int mo = filed1[j].getModifiers();
String priv = Modifier.toString(mo);
// 屬性類型
Class? type = filed1[j].getType();
System.out.println(priv + ” ” + type.getName() + ” ” + filed1[j].getName() + “;”);
}
}
}
通過反射機制調用某個類的方法
package net.xsoftlab.baike;
import java.lang.reflect.Method;
public class TestReflect {
public static void main(String[] args) throws Exception {
Class? clazz = Class.forName(“net.xsoftlab.baike.TestReflect”);
// 調用TestReflect類中的reflect1方法
Method method = clazz.getMethod(“reflect1”);
method.invoke(clazz.newInstance());
// Java 反射機制 – 調用某個類的方法1.
// 調用TestReflect的reflect2方法
method = clazz.getMethod(“reflect2”, int.class, String.class);
method.invoke(clazz.newInstance(), 20, “張三”);
// Java 反射機制 – 調用某個類的方法2.
// age – 20. name – 張三
}
public void reflect1() {
System.out.println(“Java 反射機制 – 調用某個類的方法1.”);
}
public void reflect2(int age, String name) {
System.out.println(“Java 反射機制 – 調用某個類的方法2.”);
System.out.println(“age – ” + age + “. name – ” + name);
}
}
通過反射機制操作某個類的屬性
package net.xsoftlab.baike;
import java.lang.reflect.Field;
public class TestReflect {
private String proprety = null;
public static void main(String[] args) throws Exception {
Class? clazz = Class.forName(“net.xsoftlab.baike.TestReflect”);
Object obj = clazz.newInstance();
// 可以直接對 private 的屬性賦值
Field field = clazz.getDeclaredField(“proprety”);
field.setAccessible(true);
field.set(obj, “Java反射機制”);
System.out.println(field.get(obj));
}
}
4. 反射機制的應用實例
在泛型為Integer的ArrayList中存放一個String類型的對象。
package net.xsoftlab.baike;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class TestReflect {
public static void main(String[] args) throws Exception {
ArrayListInteger list = new ArrayListInteger();
Method method = list.getClass().getMethod(“add”, Object.class);
method.invoke(list, “Java反射機制實例。”);
System.out.println(list.get(0));
}
}
通過反射取得並修改數組的信息
package net.xsoftlab.baike;
import java.lang.reflect.Array;
public class TestReflect {
public static void main(String[] args) throws Exception {
int[] temp = { 1, 2, 3, 4, 5 };
Class? demo = temp.getClass().getComponentType();
System.out.println(“數組類型： ” + demo.getName());
System.out.println(“數組長度 ” + Array.getLength(temp));
System.out.println(“數組的第一個元素: ” + Array.get(temp, 0));
Array.set(temp, 0, 100);
System.out.println(“修改之後數組第一個元素為： ” + Array.get(temp, 0));
}
}
將反射機制應用於工廠模式
package net.xsoftlab.baike;
interface fruit {
public abstract void eat();
}
class Apple implements fruit {
public void eat() {
System.out.println(“Apple”);
}
}
class Orange implements fruit {
public void eat() {
System.out.println(“Orange”);
}
}
class Factory {
public static fruit getInstance(String ClassName) {
fruit f = null;
try {
f = (fruit) Class.forName(ClassName).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return f;
}
}
/**
* 對於普通的工廠模式當我們在添加一個子類的時候，就需要對應的修改工廠類。 當我們添加很多的子類的時候，會很麻煩。
* Java 工廠模式可以參考
*
*
* 現在我們利用反射機制實現工廠模式，可以在不修改工廠類的情況下添加任意多個子類。
*
* 但是有一點仍然很麻煩，就是需要知道完整的包名和類名，這裡可以使用properties配置文件來完成。
*
* java 讀取 properties 配置文件 的方法可以參考
*
*
* @author xsoftlab.net
*/
public class TestReflect {
public static void main(String[] args) throws Exception {
fruit f = Factory.getInstance(“net.xsoftlab.baike.Apple”);
if (f != null) {
f.eat();
}
}
}
我有一個微信公眾號，經常會分享一些Java技術相關的乾貨，還有一些學習資源。
如果你喜歡我的分享，可以用微信搜索「Java團長」或者「javatuanzhang」關注。
什麼是反射？什麼Java反射？
java反射是什麼意思呢？下面帶大家了解一下。
JAVA反射是指程序可以訪問、檢測和修改它本身狀態或行為的一種能力。反射是一種強大的工具，能夠創建靈活的代碼，可以使代碼在運行時裝配，無需在組件之間進行源代表鏈接。
JAVA反射機制是在運行狀態中，知道所有屬性和方法，對於任意一個對象，能夠調用它的方法和屬性，這種動態獲取的信息以及動態調用對象的方法的功能的反射機制。
反射適合用在哪
首先我們先思考一個問題，反射適合使用在哪裡呢？從功能上看，反射似乎無所不能，幾乎所有的類，所有的屬性、方法、構造我們都能使用，但是我們細細思考一下，在實際開發中，並不是所有場景都需要使用反射獲取屬性或者方法進行操作，反而更多的使用實例.xxx方式操作，而當這些操作重複次數較多的時候，我們往往會考慮優化代碼，減少代碼冗餘，提高復用，比如實體構建賦值等操作，這個時候往往是我們最需要復用的地方，所以我們可以大體認為反射主要使用在實體操作過程中。而在一般操作數據的過程中，我們的實體一般都是知道並且依賴於對應的數據類型的，比如:
1.根據類型new的方式創建對象
2.根據類型定義變量，類型可能是基本類型也可能是引用類型、類或者接口
3.將對應類型的對象傳遞給方法
4.根據類型訪問對象的屬性，調用方法等操作
以上這些操作都是數據操作的過程中最常見也是最難復用優化的地方，而如果這裡的操作使用反射則可以實現動態的操作不同的類型的實例，通過調用反射入口類Class，獲取對應的屬性、構造、方法完成對應的操作
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/230238.html
微信掃一掃 
支付寶掃一掃 