1.類的加載概述：當程序要使用某個類時，如果該類還沒有被加載到內存中，則系統會通過加載,連接,初始化三步來實現對這個類進行初始化
(1)加載:就是指將class文件讀入內存，併爲之創建一個class對象。任何類被使用時系統都會建立一個class對象
(2)連接:分爲驗證(是否有正確的內部結構,並和其他類協調一致),準備(負責爲類的靜態成員分配內存,並設置默認初始化值)， 解析(將類的二進制數據中的符號引用替換爲直接引用)三步。
(3)初始化:字節碼對象加載，默認初始化等等
2.加載時機
(1)創建類的實例
(2)訪問類的靜態變量，或者爲靜態變量賦值
(3)調用類的靜態方法
(4)使用反射方式來強制創建某個類或接口對應的java.lang.Class對象
(5)初始化某個類的子類
(6)直接使用java.exe命令來運行某個主類
3.類加載器的概述：負責將.class文件加載到內存中，併爲之生成對應Class對象。
Bootstrap ClassLoader 根類加載器：也被稱爲引導類加載器，負責Java核心類的加載
Extension ClassLoader 擴展類加載器：負責JRE的擴展目錄中jar包的加載
System ClassLoader 系統類加載器：負責再JVM啓動時加載來自java命令的class文件，以及classpath環境變量所指定的 jar包和類路徑
4.反射：
(1)Java反射機制實在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法
(2)對於任意一個對象，都能夠調用它的任意一個方法和屬性
(3)這種動態獲取的信息以及動態調用對象的方法的功能稱爲java語言的反射機制
(4)要想解剖一個類，必須先要獲取到該類的字節碼文件對象
(5)而解剖使用的就是Class類中的方法，所以先要獲取到每一個字節碼文件對應的Class類型的對象
5.反射的三種方式:通過三種方式獲取字節碼對象
(1)Object類的getClass()方法，判斷兩個對象是否是同一個字節碼文件
(2)靜態屬性class，鎖對象
(3)Class類中靜態方法forName()，讀取配置文件
6.通過反射獲取帶參構造方法並使用
Class類的newInstance()方法是使用該類無參的構造函數創建對象，如果一個類沒有無參的構造函數，就不能這樣創建，但 是可以調用Class類的getConstructor(String.class,int.class)方法獲取一個指定的構造函數然後再調用Constructor類的 newInstance("aa",11)方法創建對象
7.通過反射獲取成員變量並使用
Class.getField(String)方法可以獲取類中的指定字段(可見的),如果是私有的可以用getDeclaredField("name")方法獲取，通過 set(obj,"bb")方法可以設置指定對象上該字段的值，如果是私有的需要先調setAccessible(true)設置訪問權限，用獲取的指定 的字段調get(obj)可以獲取指定對象中該字段的值
8.通過反射獲取方法並使用
Class.getMethod(String,Class...)和Class.getDeclaredMethod(String,Class...)方法可以獲取類中的指定方法，
調用invoke(Object,Object)可以調用該方法，Class.getMethod("eat") invoke(obj) Class.getMethod("eat",int.class)
invoke(obj,10)
9.通過反射越過泛型檢查
ArrayList<Integer>的一個對象，在這個集合中添加一個字符串數據
10.通過反射寫一個通用的設置某個對象的某個屬性值爲指定的值
public void setProperty(Object obj,String propertyName,Object value){},此方法可將obj對象中名爲propertyName的屬性的值 設置爲value
package pra_25;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import pra_01.j_07;
public class J_47 {
/**
* @param args
* @throws ClassNotFoundException
* @throws IOException
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static void main(String[] args) throws Exception {
Class c1=Class.forName("pra_01.j_07");
Class c2=j_07.class;
j_07 j07=new j_07();
Class c3=j07.getClass();
System.out.println(c1==c2); //true
System.out.println(c2==c3); //true
Qe q=new Qe();
q.eat(new A());
q.eat(new B());
//Class.forName()讀取配置文件
BufferedReader br=new BufferedReader(new FileReader("config1.properties"));
Class c4=Class.forName(br.readLine());
All a1=(All) c4.newInstance(); //父類引用指向子類對象
Qe q3=new Qe();
q3.eat(a1);
//6.通過反射獲取帶參構造方法並使用
Class c5=Class.forName("pra_25.People");
Constructor cs=c5.getConstructor(String.class,int.class); //獲取有參構造
People p=(People) cs.newInstance("aa",11); //通過有參構造創建對象
System.out.println(p);
//7.通過反射獲取成員變量並使用
Class c6=Class.forName("pra_25.People");
Constructor cs2=c6.getConstructor(String.class,int.class); //獲取有參構造
People p2=(People) cs2.newInstance("bb",22); //通過有參構造創建對象
/* //因爲變量私有，所以不行
Field f=c6.getField("name"); //獲取姓名字段
f.set(p2, "cc"); //修改姓名的值
*/
Field f=c6.getDeclaredField("name"); //暴力反射獲取字段
f.setAccessible(true); //去除私有權限
f.set(p2, "cc");
System.out.println(p2);
//8.通過反射獲取方法並使用
Class c7=Class.forName("pra_25.People");
Constructor cs3=c6.getConstructor(String.class,int.class);
People p3=(People) cs3.newInstance("bb",22);
Method me=c7.getMethod("eat"); //獲取eat方法
me.invoke(p3); //運行eat方法
Method me2=c7.getMethod("eat", int.class); //獲取有參的eat方法
me2.invoke(p3, 10);
//9.通過反射越過泛型檢查,泛型只有在編譯期才做語法檢查,在運行期會被擦除掉
ArrayList<Integer> list=new ArrayList<Integer>();
list.add(111);
Class c8=Class.forName("java.util.ArrayList"); //獲取字節碼對象
Method me3=c8.getMethod("add", Object.class); //獲取add方法
me3.invoke(list, "abc");
System.out.println(list); //[111, abc]
//10.通過反射寫一個通用的設置某個對象的某個屬性值爲指定的值
Person pe=new Person("qq",22);
System.out.println(pe); //Person [name=qq, age=22]
Tool t=new Tool();
t.setProperty(pe, "name", "www");
System.out.println(pe); //Person [name=www, age=22]
}
}
interface All{
public void eat();
}
class A implements All{
public void eat(){
System.out.println("a");
}
}
class B implements All{
public void eat(){
System.out.println("b");
}
}
class Qe{
public void eat(All one){
one.eat();
}
}
class Person{
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
以下是舉例是用到的兩個類
People.java
package pra_25;
public class People{
private String name;
private int age;
/*
public People() {
super();
}
*/
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public People(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
People other = (People) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "People [name=" + name + ", age=" + age + "]";
}
public void eat(){
System.out.println("i like it!");
}
public void eat(int num){
System.out.println("i like it!+"+num);
}
}
Tool.java
package pra_25;
import java.lang.reflect.Field;
public class Tool {
//此方法可將obj對象中名爲propertyName的屬性的值設置爲value
public void setProperty(Object obj,String propertyName,Object value) throws Exception{
Class c=obj.getClass(); //獲取字節碼對象
Field f=c.getDeclaredField(propertyName); //暴力反射獲取字段
f.setAccessible(true); //去除權限
f.set(obj, value);
}
}