Python生成隨機資料
阿新 • • 發佈：2020-11-04
1.反射機制是什麼
反射機制是在執行狀態中，對於任何一個類，都能知道這個類的所有屬性和方法；對於任意一個物件，都能夠呼叫它的任意一個方法和屬性；這種動態獲取資訊以及動態呼叫物件的方法的功能叫做java的反射機制
2.反射機制能做什麼
- 在執行時判斷任意一個物件所屬的類；
- 在執行時判斷任意一個類所具有的成員變數和方法；
- 在執行時構造任意一個類的物件；
- 在執行時呼叫任意一個物件的方法；
- 生成動態代理
3.反射機制的相關API
- 通過一個物件獲得完整的包名和類名
Test test=new Test(); System.out.println(test.getClass().getName);
2.例項化Class類物件
Class<?> class1=null; Class<?> class1=null; Class<?> class1=null; //一般採用這種形式 class1=Class.forName("com.lj.Test"); class2=Test().getClass(); class3=Test.class; System.out.println(“類名稱”+class1.getName); System.out.println(“類名稱”+class2.getName); System.out.println(“類名稱”+class3.getName);
3.獲取一個物件的父類與實現的介面
Class<?> clazz=Class.forName("com.lj.Test");
//取得父類
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());
}
4.獲取某個類的全部建構函式，通過反射機制例項化一個類的物件
Class<?> class1=null;
class1=Class.forName(com.lj.user);
//第一種方式，例項化預設構造方法，呼叫set賦值
User user=（User）class1.newInstance();
user.setName("jeck");
user.setAge(20);
System.out.println(user);
//第二種方式，取得全部的建構函式，使用建構函式賦值
Constructor<?> cons[]= class1.getConstructor();
//檢視每個構造方法需要的引數
for(int i=0;i<cons.length;i++){
Class<?> clazzs[]=cons[i].getParameterTypes();
System.out.printl("cons["+i+"](");
for(int j=0;j<clazzs.length;j++){
if(j==clazzs.length-1)
System.out.println(clazzs[j].getName);
else
System.out.println(clazzs[j].getName()+",");
}
System.out.println(")")
}
//根據獲得的結果選擇建構函式例項化類的物件
//cons[0](java.lang.String)
//cons[1](int,java.lang.String)
//cons[2]()
user =(User)cons[0].getInstance("jeck");
System.out.println(user);
user =(User)cons[1].getInstance(20,"jeck");
System.out.println(user);
5.獲取某個類的全部屬性
Class<?> clazz=Class.forName("com.lj.Test");
System.out.println("---------本類屬性---------");
//取得本類的全部屬性
Field[] field=clazz.getDeclaredFields();
for(int i=0;i<filed.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[] field1=clazz.getFileds();
for(int j=0;j<field1.length;j++){
//許可權修飾符
int mo=field[j].getModifiers();
String priv=Modifier.toString(mo);
//屬性型別
Class<?> type=field[i].getType();
System.out.println(priv+""+type.getName()+"")+field[j].getName()+";");
}
6.獲取某個類的全部方法
Class<?> clazz=Class.forName("com.lj.Test");
Method method[]=clazz.getMethods();//獲取類的全部方法
for(int i=0;i,method.length;i++){
Class<?> returnType=method[i].getReturnType();//取得方法的返回型別
Class<?> para[]=method[i].getParameterTypes();
int temp=method[i].getModifiers();//許可權修飾符
System.out.print(Modifier.toString(temp)+"");
System.out.print(returnType.getName+"");
System.out.print(method[i].getName+"");
System.out.print("(")
for(int j=0;i,para.length;j++){
System.out.println(para[j].getName()+""+"arg"+j);
if(j<para.length-1){
System.out.println(",");
}
Class<?> exce[]=method[i].getExceptionType[];
if(exce.length>0){
System.out.println(")throws");
for(int k=0;k<exce.length;i++){
System.out.print(exce[k].getName()+"");
if(k<length-1){
System.out.print(",");
}
}
}else{
System.out.print(")");
}
System.out.println();
}
}
7.通過反射機制呼叫每個類的方法
Class<?> clazz=Class.forName(com.lj.Test);
//呼叫Test類中的test1方法
Method method=clazz.getMethod("test1");
method.invoke(clazz.newInstance);
//呼叫Test類的test2方法
method=clazz.getMethod("test2",int.class,String.class);
method.invoke(clazz.newInstance(),20,"jeck");
public void test1(){
System.out.println("java反射機制呼叫某個類的方法一")；
}
public void test2(int age,String name){
System.out.println("java反射機制呼叫某個類的方法二")；
System.out.println("age->"+age+".name->"+name);
}
8.通過反射機制操作某個類的屬性
package com.lj;
import java.lang.reflect.field;
public class Test{
private String proprety=null;
public static void main(String[] args)throws Exception{
Class<?> clazz=Class.forName("com.lj.Test");
Object obj=clazz.newInstance();
//可以直接對private的屬性賦值
Field field=clazz.getDeclaredField("proprety");
field.setAccessible(true);
field.set(obj,"java反射機制");
System.out.println(field.get(obj));
}
}
9.反射機制的動態代理
4.反射機制的應用例項
1.在泛型為Interger的ArrayList中存放一個String型別的物件
ArrayList<Interger> list=new ArrayList<Interger>();
Method method=list.getClass().getMethod("add",Object.class);
method.invoke(list,"java反射機制的例項。");
System.out.println(list.get(0));
2.通過反射取得並修改陣列的資訊
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));
3.通過反射機制修改陣列的大小
int[] temp={1,2,3,4,5,6,7,8,9};
int[] newTemp=(int[])arrayInc(temp,15);
print(newTemp);
String[] art={"a","b","c"};
String[] atr1=(String[])arrayInc(atr,8);
print(str);
//修改陣列大小
public Static Object arrayInc(Object obj,int len){
Class<?> arr=obj.getClass().getComponentType();
Object newArr=Array.newInstance(arr,len);
int co=Array.getLength(obj);
System.arraycopy(obj,0,newArr,0,co);
return newArr
}
//列印
public static void print(Object obj){
Class<?> c=obj.getClass();
if(!c.isArray()){
return;
}
System.out.println("陣列長度為:"+Array.getLength(obj));
for(int i=0;i<Array.getLength(obj);i++){
System.out.print(Array.get(obj,i)+"");
}
System.out.println();
}
4.將反射機制應用於工廠模式
package com.lj
interface fruit{
public static 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;
}
}
public class Test{
public static void main(String[] args)throws Exception{
friut f=Factory.getInstance("com.lj.Apple");
if(f!=null){
f.eat();
}
}
}