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

/**

• 通過反射技術呼叫方法

•  method.invoke(例項, method方法的實參列表) 
  

•  如果是靜態方法,在例項位置傳遞null
  

• @author Administrator

*/
public class Test06 {
public static void main(String[] args) throws Exception {
//1) 建立Class物件
Class<?> class1 = String.class;
//2) 建立例項, 通過Class物件建立例項,會呼叫無參構造
Object str1 = class1.newInstance(); //new String()
//反射構造方法,建立例項 String(byte[] bytes)
Constructor<?> constructor = class1.getConstructor( byte[].class );
byte[] bytes = {65,66,67,68,69,70};
Object str2 = constructor.newInstance(bytes); //new String( bytes )
//3)反射方法 equals(Object obj)
Method equalsM = class1.getMethod(“equals”, Object.class);
//4)呼叫方法,invoke( 例項, equals方法的實參 )
Object result = equalsM.invoke(str2, str1);

//str2.equals(str1)
System.out.println( result );
result = equalsM.invoke(str2, “ABCDEF”); //str2.equals(“ABCDEF”);
System.out.println( result );
//5)反射 length()
Method lengthM = class1.getMethod(“length”, null);
result = lengthM.invoke(str1); //str1.length()
System.out.println( result );
result = lengthM.invoke(str2);

//str2.length()
System.out.println( result );
//6)反射substring( int from, int to)
Method substringM = class1.getMethod(“substring”, int.class , int.class);
result = substringM.invoke(str2, 0 , 4); // str2.substring(0,4)
System.out.println( result );

	//7) 反射靜態方法,  valueOf(int)
	Method valueOfM = class1.getMethod("valueOf", int.class);
	//在呼叫靜態方法時, invoke(例項, 方法的實參), 在例項位置傳遞null
	result = valueOfM.invoke(null, 456);
	System.out.println( result );
	
	//8)靜態欄位serialVersionUID
	Field field = class1.getDeclaredField("serialVersionUID");
	field.setAccessible(true);
	System.out.println( field.get(null) );
	
}
 

}

---

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/**

• 通過反射技術訪問例項的欄位值

•  field.get( 例項 )    返回例項對應的欄位值
  

•  field.set( 例項名, 欄位值)   設定例項的欄位值
  

•  field.setAccessible(true);   設定欄位的可訪問性
  

• @author Administrator

*/
public class Test05 {

public static void main(String[] args) throws Exception {
	// 1)建立Class物件
	Class<?> class1 = Computer.class;
	
	//2)建立例項
	//直接通過Class物件建立例項, 預設呼叫無參構造
	Object obj1 = class1.newInstance();
	System.out.println( obj1 ); 	//Computer [price=0, color=null, brand=null]

	//3)反射brand欄位
	Field brandF = class1.getField("brand");
	//4)返回欄位的值,brandF.get( 例項 ); 返回某個例項的欄位值
	Object value = brandF.get(obj1);
	System.out.println( value );
	//5)設定欄位的值,brandF.set( 例項名, 欄位值);
	brandF.set(obj1, "Lenovo");
	System.out.println( obj1 );
	
	//6)反射構造方法,建立例項
	Constructor<?> constructor = class1.getConstructor(int.class, String.class, String.class);
	Object obj2 = constructor.newInstance(6800, "black", "Dell");
	System.out.println( obj2 );  //Computer [price=6800, color=black, brand=Dell]
	//7)反射price私有欄位
	Field priceF = class1.getDeclaredField("price");
	//可以設定欄位的可訪問性
	priceF.setAccessible(true);
	System.out.println( priceF.get(obj2) );
	priceF.set(obj2, 2800);
	System.out.println( obj2 );
	
	//class1.getField()只能反射公共的欄位, color欄位是預設許可權 , 應該使用getDeclaredField()
	Field colorF = class1.getField("color");
	System.out.println( colorF.get(obj2));
}

}

---

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**

• 反射建立例項(instance)
• 1)直接通過Class物件建立例項, 會呼叫類的無參構造方法,如果類沒有無參構造產生異常
• 2)通過構造方法建立例項
• @author Administrator

*/
public class Test04 {

public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
	//1) 通過Class物件建立例項
	Class<?> class1 = String.class;
	//class1.newInstance()建立例項時,預設會呼叫String類的無參構造
	Object str1 = class1.newInstance(); 	//相當於建立了一個空的字串物件 new String()
	
	//Integer類沒有無參構造, 不能通過class物件建立例項, 會產生異常

// Class<?> class2 = Integer.class;
// Object ii = class2.newInstance();

	//2)通過構造方法建立例項
	//反射構造方法 : String( byte[] bytes )
	Constructor<?> constructor1 = class1.getConstructor( byte[].class );
	//建立例項: constructor1.newInstance( 構造方法的實參 )
	byte[] bytes = {65,66,67,68,69,70};
	Object str2 = constructor1.newInstance( bytes );   //new  String(bytes )
	System.out.println( str2 );
	
	//反射構造方法 :  String(byte[] bytes, int from, int len)
	Constructor<?> constructor2 = class1.getConstructor(byte[].class , int.class , int.class);
	Object str3 = constructor2.newInstance(bytes , 0 , 3);  //new String(bytes, 0 , 3)
	System.out.println( str3 );
	
}

}

---

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

/**

• 反射類的內容:
• 欄位, Field

•  class1.getDeclaredField(name)		反射指定名稱的欄位
  

•  class1.getField(name)				反射指定名稱的公共欄位
  

•  class1.getDeclaredFields()			反射所有的欄位
  

•  	field.getModifiers()			欄位的修飾符
  

•  	field.getType()					欄位型別
  

•  	field.getName()					欄位名稱
  

• 方法, Method

•  class1.getDeclaredMethod(name, parameterTypes)	反射指定簽名的方法
  

•  class1.getMethod(name, parameterTypes)			反射 指定簽名的公共方法
  

•  class1.getDeclaredMethods()			反射所有的方法
  

•  	method.getModifiers() 			方法修飾符
  

•  	method.getReturnType()			返回值型別
  

•  	method.getName()				方法名
  

•  	method.getParameterTypes()		方法引數型別陣列
  

• 構造方法, Constructor

•  class1.getDeclaredConstructor(parameterTypes)	反射指定引數列表的構造方法 
  

•  class1.getConstructor(parameterTypes)			反射指定引數列表的公共的構造方法	
  

•  class1.getDeclaredConstructors()		反射所有構造方法
  

•  	constructor.getModifiers()		修飾符
  

•  	constructor.getName()			方法名
  

•  	constructor.getParameterTypes()	引數型別陣列
  

• @author Administrator

*/
public class Test03 {

public static void main(String[] args) {
	// 1) 建立Class物件

// Class<?> class1 = String.class;
Class<?> class1 = Integer.class;

	StringBuilder sb = new StringBuilder();
	
	//2)反射欄位
	Field[] declaredFields = class1.getDeclaredFields();
	for (Field field : declaredFields) {
		//欄位修飾符
		int mod = field.getModifiers();
		sb.append(  Modifier.toString(mod) ) ;
		sb.append(" ");
		//型別
		sb.append( field.getType().getSimpleName() );
		sb.append(" ");
		//欄位名
		sb.append( field.getName() );
		sb.append(";\n"	);
	}
	
	//3)反射方法
	Method[] declaredMethods = class1.getDeclaredMethods();
	for (Method method : declaredMethods) {
		//方法修飾符
		sb.append( Modifier.toString( method.getModifiers() ));
		sb.append(" ");
		//方法返回值型別
		Class<?> returnType = method.getReturnType();
		sb.append( returnType.getSimpleName() );
		sb.append(" ");
		//方法名
		sb.append( method.getName() );
		//引數列表
		sb.append("(");
		Class<?>[] parameterTypes = method.getParameterTypes();
		for(int i = 0 ;  i<parameterTypes.length; i++){
			sb.append( parameterTypes[i].getSimpleName() );
			//引數之間使用逗號
			if ( i < parameterTypes.length - 1 ) {
				sb.append(",");
			}
		}
		sb.append(");\n");
	}
	//4) 構造方法 
	Constructor<?>[] declaredConstructors = class1.getDeclaredConstructors();
	for (Constructor<?> constructor : declaredConstructors) {
		//構造方法修飾符
		sb.append( Modifier.toString( constructor.getModifiers()));
		sb.append(" ");
		//構造方法名

// sb.append( constructor.getName() );
sb.append( class1.getSimpleName() ); //構造方法名和類名相同
//引數
sb.append("(");
Class<?>[] parameterTypes = constructor.getParameterTypes();
for(int i = 0 ; i<parameterTypes.length; i++){
sb.append( parameterTypes[i].getSimpleName() );
//引數之間使用逗號
if ( i < parameterTypes.length - 1 ) {
sb.append(",");
}
}
sb.append("); \n");
}

	System.out.println( sb );
}

}

---

import java.lang.reflect.Modifier;

/**

• 反射類的資訊
• 反射使用的相關類在java.lang.reflect包中
• class1.getModifiers() 反射類的修飾符
• class1.getName() 完整類名
• class1.getSimpleName() 簡易類名
• class1.getSuperclass() 父類, 返回值是Class物件
• class1.getInterfaces() 介面陣列
• java.lang.reflect.Modifier 關於修飾符的類,有靜態方法toString(mod)可以把整數轉換為字串
• @author Administrator

*/
public class Test02 {

public static void main(String[] args) {
	//1) 建立Class物件
	Class<?> class1 = String.class;

// Class<?> class1 = Integer.class;

	//2) 反射類的資訊
	//2.1 類的修飾符
	int mod = class1.getModifiers();
	String modifier = Modifier.toString(mod);
	System.out.print( modifier );
	
	//2.2類名
	System.out.print( " class ");

// System.out.print( class1.getName() ); //完整類名
System.out.print( class1.getSimpleName() ); //簡易類名
//2.3父類
Class<?> superclass = class1.getSuperclass();
if ( superclass != Object.class) {
System.out.print( " extends ");
System.out.print( superclass.getSimpleName() );
}

	//2.4 介面
	Class<?>[] interfaces = class1.getInterfaces();
	if ( interfaces.length > 0 ) {
		System.out.print(" implements ");
		//遍歷介面陣列
		for( int i = 0 ;  i< interfaces.length; i++){
			System.out.print( interfaces[i].getSimpleName() );
			//介面之間使用逗號分隔
			if (i < interfaces.length - 1 ) {
				System.out.print(",");
			}
		}
	}
	
}

}

---

/**

• 返回Class物件
• @author Administrator

*/
public class Test01 {

public static void main(String[] args) throws ClassNotFoundException {
	// 1) 每個類都有class屬性
	Class<?>  class1 = Computer.class;
	
	//2)每個物件都有getClass()方法
	Computer lenovo = new Computer();
	Class<?> class2 = lenovo.getClass();
	
	//3) Class.forName(完整類名)
	Class<?> class3 = Class.forName("com.baidu.demo04.Computer");
	
	System.out.println( class1 == class2 );
	System.out.println( class1 == class3 );
	
	//4)基本型別
	Class<?> class4 = int.class; 
	Class<?> class5 = Integer.TYPE;
	System.out.println( class4 == class5 );
	Class<?>class6 = Integer.class;
	System.out.println( class4 == class6 );  
	
	//5)Class.forName()方法會把類載入到記憶體中

// Class<?> class7 = Person.class;
//上一行執行後, 沒有執行Person類的靜態程式碼塊, 說明 Person類沒有載入記憶體

	Class<?> class8 = Class.forName("com.baidu.demo04.Person");
	//上行執行後, 會執行Person類的靜態程式碼塊, 說明Person類載入記憶體了
	
}

}

---

public class Person {

static{
	System.out.println("靜態程式碼塊, 類載入記憶體後,會執行靜態程式碼塊");
}

}

---

public class Computer {
private int price;
String color;
public String brand;

public Computer() {
}
public Computer(int price, String color, String brand) {
	super();
	this.price = price;
	this.color = color;
	this.brand = brand;
}
	
@Override
public String toString() {
	return "Computer [price=" + price + ", color=" + color + ", brand=" + brand + "]";
}

}