一、類的加載
1.類的加載概述
當程序要使用某個類時，如果該類還未被加載到內存中，則系統會通過加載，連接，初始化三步來實現對這個類進行初始化。
加載：就是指將class文件讀入內存，併爲之創建一個Class對象。任何類被使用時系統都會建立一個Class對象。
連接：
驗證:：否有正確的內部結構，並和其他類協調一致
準備：負責爲類的靜態成員分配內存，並設置默認初始化值
解析：將類的二進制數據中的符號引用替換爲直接引用
初始化：
2.加載時機
創建類的實例
訪問類的靜態變量，或者爲靜態變量賦值
調用類的靜態方法
使用反射方式來強制創建某個類或接口對應的java.lang.Class對象
初始化某個類的子類
直接使用java.exe命令來運行某個主類
二、類加載器的概述和分類
1.類加載器的概述
負責將.class文件加載到內存中，併爲之生成對應的Class對象。雖然我們不需要關心類加載機制，但是瞭解這個機制我們就能更好的理解程序的運行。
2.類加載器的分類
Bootstrap ClassLoader 根類加載器
Extension ClassLoader 擴展類加載器
Sysetm ClassLoader 系統類加載器
3.類加載器的作用
Bootstrap ClassLoader根類加載器，也被稱爲引導類加載器，負責Java核心類的加載，比如System，String等。在JDK中JRE的lib目錄下rt.jar文件中。
Extension ClassLoader擴展類加載器，負責JRE的擴展目錄中jar包的加載。在JDK中JRE的lib目錄下ext目錄。
Sysetm ClassLoader系統類加載器，負責在JVM啓動時加載來自java命令的class文件，以及classpath環境變量所指定的jar包和類路徑。
三、反射概述
1.反射概述
JAVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱爲java語言的反射機制。
要想解剖一個類，必須先要獲取到該類的字節碼文件對象。而解剖使用的就是Class類中的方法，所以先要獲取到每一個字節碼文件對應的Class類型的對象。
Class clazz1 = Class.forName("com.it.refection.Person");
Class clazz2 = Person.class;
Class clazz3 = new Person().getClass();
這三種方式得到的字節碼對象是一致的。
2.Class.forName()
榨汁機(Juicer)榨汁的案例：分別有水果(Fruit)蘋果(Apple)香蕉(Banana)桔子(Orange)榨汁(squeeze)
public class Demo2_Reflect {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new FileReader("config.properties"));
//創建輸入流對象，關聯配置文件
Class<?> clazz = Class.forName(br.readLine()); //讀取配置文件一行內容，獲取該類的字節碼對象
Fruit f = (Fruit) clazz.newInstance(); //通過字節碼對象創建實例對象
Juicer j = new Juicer();
j.run(f);
}
}
interface Fruit {
public void squeeze();
}
class Apple implements Fruit {
public void squeeze() {
System.out.println("榨出一杯蘋果汁兒");
}
}
class Orange implements Fruit {
public void squeeze() {
System.out.println("榨出一杯桔子汁兒");
}
}
class Juicer {
public void run(Fruit f) {
f.squeeze();
}
}
3.獲取帶參構造方法並使用
Constructor
Class類的newInstance()方法是使用該類無參的構造函數創建對象， 如果一個類沒有無參的構造函數， 就不能這樣創建了，可以調用Class類的getConstructor(String.class，int.class)方法獲取一個指定的構造函數然後再調用Constructor類的newInstance("張三"，20)方法創建對象。
Constructor c = clazz1.getConstructor(String.class,int.class);
Person p = (Person) c.newInstance("dante",26);
System.out.println(p.getAge());
4.獲取成員變量並使用
Field
Class.getField(String)方法可以獲取類中的指定字段(可見的)，如果是私有的可以用getDeclaedField("name")方法獲取，通過set(obj, "李四")方法可以設置指定對象上該字段的值，如果是私有的需要先調用setAccessible(true)設置訪問權限，用獲取的指定的字段調用get(obj)可以獲取指定對象中該字段的值。
Field f = clazz1.getDeclaredField("name");
f.setAccessible(true);
f.set(p, "vigir");
5.獲取方法並使用
Method
Class.getMethod(String, Class...) 和 Class.getDeclaredMethod(String,Class...)方法可以獲取類中的指定方法，調用invoke(Object, Object...)可以調用該方法.
Class.getMethod("eat") ;
invoke(p) ;
Class.getMethod("eat",int.class);
invoke(p，10);
6.越過泛型檢查
ArrayList的一個對象，在這個集合中添加一個字符串數據，如何實現呢？
ArrayList<Integer> arr = new ArrayList<>();
arr.add(1);
Class clazz = Class.forName("java.util.ArrayList");
Method m = clazz.getMethod("add",Object.class);
m.invoke(arr, "123");
System.out.println(arr);
7.設置某個對象某屬性的方法
public void setProperty(Object obj， String propertyName， Object value){}，此方法可將obj對象中名爲propertyName的屬性的值設置爲value。
public void setProperty(Object obj, String propertyName, Object value) throws Exception{
Class clazz = obj.getClass(); //獲取字節碼對象
Field f = clazz.getDeclaredField(propertyName); //暴力反射獲取字段
f.setAccessible(true); //去除權限
f.set(obj, value);
}
8.動態代理的概述和實現
A:動態代理概述
在Java中java.lang.reflect包下提供了一個Proxy類和一個InvocationHandler接口，通過使用這個類和接口就可以生成動態代理對象。JDK提供的代理只能針對接口做代理。我們有更強大的代理cglib。
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("權限校驗");
method.invoke(target, args); //執行被代理target對象的方法
System.out.println("日誌記錄");
return null;
}
}
之後再main方法中使用。
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
StudentImp si = new StudentImp();
si.login();
si.submit();
System.out.println("-------------------------------");
MyInvocationHandler m = new MyInvocationHandler(si);
/*
* public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,
* InvocationHandler h)
*/
Student s = (Student)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), m);
s.login();
s.submit();
}
}
四、枚舉
1.枚舉實現
public enum Week3 { #枚舉可以簡單理解爲類中創建了枚舉的對象
MON("星期一"){
public void show() {
System.out.println("星期一");
}
},TUE("星期二"){
public void show() {
System.out.println("星期二");
}
},WED("星期三"){
public void show() {
System.out.println("星期三");
}
};
private String name;
private Week3(String name) {
this.name = name;
}
public String getName() {
return name;
}
public abstract void show();
}
2.枚舉的注意事項
定義枚舉類要用關鍵字enum，所有枚舉類都是Enum的子類。
枚舉類的第一行上必須是枚舉項，最後一個枚舉項後的分號是可以省略的，但是如果枚舉類有其他的東西，這個分號就不能省略，建議不要省略。
枚舉類可以有構造器，但必須是private的，它默認的也是private的。
枚舉類也可以有抽象方法，但是枚舉項必須重寫該方法。
枚舉在switch語句中的使用，即case MON(MON是枚舉類對象)。
3.枚舉類的常見方法
int ordinal()，確定是第幾個枚舉項
int compareTo(E o)，比較兩個枚舉項的編碼
String name()，獲取實例的名稱
String toString()，調用重寫之後的tostring方法
T valueOf(Class type，String name)，通過字節碼文件獲取對象
values() 此方法雖然在JDK文檔中查找不到，但每個枚舉類都具有該方法，它遍歷枚舉類的所有枚舉值非常方便
public static void main(String[] args) {
demo1();
Week2 mon = Week2.valueOf(Week2.class, "MON"); //通過字節碼對象獲取枚舉項
System.out.println(mon);
Week2[] arr = Week2.values(); //用於遍歷枚舉項
for (Week2 week2 : arr) {
System.out.println(week2);
}
}
public static void demo1() {
Week2 mon = Week2.MON;
Week2 tue = Week2.TUE;
Week2 wed = Week2.WED;
/*System.out.println(mon.ordinal()); //枚舉項都是有編號的
System.out.println(tue.ordinal());
System.out.println(wed.ordinal());
System.out.println(mon.compareTo(tue)); //比較的是編號
System.out.println(mon.compareTo(wed));*/
System.out.println(mon.name()); //獲取實例名稱
System.out.println(mon.toString()); //調用重寫之後的toString方法
}