Java編程基礎28——反射&JDK新特性

1_類的加載概述和加載時機

• A:類的加載概述

  • 當程序要使用某個類時，若是該類還未被加載到內存中，則系統會經過加載，鏈接，初始化三步來實現對這個類進行初始化。
  • 加載：就是指將class文件讀入內存，併爲之建立一個Class對象。任何類被使用時系統都會創建一個Class對象。

  • 鏈接

    • 驗證 是否有正確的內部結構，並和其餘類協調一致
    • 準備 負責爲類的靜態成員分配內存，並設置默認初始化值
    • 解析 將類的二進制數據中的符號引用替換爲直接引用
  • 初始化：就是咱們之前講過的初始化步驟

• B:加載時機

  • 建立類的實例
  • 訪問類的靜態變量，或者爲靜態變量賦值
  • 調用類的靜態方法
  • 使用反射方式來強制建立某個類或接口對應的java.lang.Class對象
  • 初始化某個類的子類
  • 直接使用java.exe命令來運行某個主類

2_類加載器的概述和分類

• A:類加載器的概述

  • 負責將.class文件加載到內存中，併爲之生成對應的Class對象。雖然咱們不須要關心類加載機制，可是瞭解這個機制咱們就能更好的理解程序的運行。

• B:類加載器的分類

  • Bootstrap ClassLoader 根類加載器
  • Extension ClassLoader 擴展類加載器
  • System ClassLoader 系統類加載器

• C:類加載器的做用

  • Bootstrap ClassLoader 根類加載器

    • 也被稱爲引導類加載器，負責Java核心類的加載
    • 好比System,String等。在JDK中JRE的lib目錄下rt.jar文件中

  • Extension ClassLoader 擴展類加載器

    • 負責JRE的擴展目錄中jar包的加載。
    • 在JDK中JRE的lib目錄下ext目錄

  • System ClassLoader 系統類加載器

    • 負責在JVM啓動時加載來自java命令的class文件，以及classpath環境變量所指定的jar包和類路徑

3_反射概述

• A:反射概述

  • JAVA反射機制是在運行狀態中，對於任意一個類，都可以知道這個類的全部屬性和方法；
  • 對於任意一個對象，都可以調用它的任意一個方法和屬性；
  • 這種動態獲取的信息以及動態調用對象的方法的功能稱爲java語言的反射機制。
  • 要想解剖一個類,必須先要獲取到該類的字節碼文件對象。
  • 而解剖使用的就是Class類中的方法，因此先要獲取到每個字節碼文件對應的Class類型的對象。

• B:三種方式

  • a:Object類的getClass()方法,判斷兩個對象是不是同一個字節碼文件
  • b:靜態屬性class,鎖對象
  • c:Class類中靜態方法forName(),讀取配置文件

• C:案例演示

  • 獲取class文件對象的三種方式

import net.allidea.bean.Person;
public class Demo1_Reflect {
    public static void main(String[] args) throws ClassNotFoundException {
        Class clazz1 = Class.forName("net.allidea.bean.Person");
        Class clazz2 = Person.class;
        
        Person p = new Person();
        Class clazz3 = p.getClass();
        
        System.out.println(clazz1 == clazz2);
        System.out.println(clazz2 == clazz3);
    }
}

//Person類
public class Person {
    private String name;
    private int age;
...corh

4_Class.forName()讀取配置文件舉例

• 榨汁機(Juicer)榨汁的案例
• 分別有水果(Fruit)蘋果(Apple)香蕉(Banana)桔子(Orange)榨汁(squeeze)

import java.io.BufferedReader;
import java.io.FileReader;

public class Demo2_Reflect {
    public static void main(String[] args) throws Exception {
        //沒有用反射，只在說多態
        /*Juicer j = new Juicer();                    //購買榨汁機
        j.run(new Apple());                            //向榨汁機中放入蘋果
        //j.run(new Orange());                        //Apple a = new Orange();類型不匹配
        
        //在榨汁機中添加run方法能夠接受橘子
        j.run(new Orange());                        //Fruit f = new Orange();*/    
        
        //用反射和配置
        //建立輸入流，關聯配置文件
        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(Apple a) {
        a.squeeze();
    }
    public void run(Orange o) {
        o.squeeze();
    }*/
    
    //改進後代碼以下
    public void run(Fruit f    ) {
        f.squeeze();
    }
}

//config.properties文件
net.allidea.reflect.Apple

5_經過反射獲取帶參構造方法並使用

• Constructor

  • Class類的newInstance()方法是使用該類無參的構造函數建立對象, 若是一個類沒有無參的構造函數,
  • 就不能這樣建立了,能夠調用Class類的getConstructor(String.class,int.class)方法獲取一個指定的構造函數
  • 而後再調用Constructor類的newInstance("張三",20)方法建立對象

6_經過反射獲取成員變量並使用

• Field

  • Class.getField(String)方法能夠獲取類中的指定字段(可見的),
  • 若是是私有的能夠用getDeclaedField("name")方法獲取,經過set(obj, "李四")方法能夠設置指定對象上該字段的值,
  • 若是是私有的須要先調用setAccessible(true)設置訪問權限,用獲取的指定的字段調用get(obj)能夠獲取指定對象中該字段的值

7_經過反射獲取方法並使用

• Method

  • Class.getMethod(String, Class...) 和 Class.getDeclaredMethod(String, Class...)方法能夠獲取類中的指定方法,
  • 調用invoke(Object, Object...) 能夠調用該方法,
  • Class.getMethod("eat") invoke(obj)
  • Class.getMethod("eat",int.class) invoke(obj,10)

8_經過反射越過泛型檢查

• A:案例演示

  • ArrayList<Integer>的一個對象，在這個集合中添加一個字符串數據，如何實現呢？

public static void main(String[] args) throws Exception {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(111);
        list.add(222);
//        list.add("abc");
        
        
        Class clazz = Class.forName("java.util.ArrayList");//獲取字節碼對象
        Method m = clazz.getMethod("add", Object.class);    //獲取add方法
        m.invoke(list, "abc");        
        System.out.println(list);
}

9_經過反射寫一個通用的設置某個對象的某個屬性爲指定的值

• A:案例演示

  • public void setProperty(Object obj, String propertyName, Object value){}
  • 此方法可將obj對象中名爲propertyName的屬性的值設置爲value。

10_反射(練習)

• 已知一個類，定義以下：

package com.zuikc.test;
               public class DemoClass {
                public void run() {
                    System.out.println("welcome to myClass!");
                }
            }

* (1) 寫一個Properties格式的配置文件，配置類的完整名稱。 
 * (2) 寫一個程序，讀取這個Properties配置文件，得到類的完整名稱並加載這個類，用反射的方式運行run方法。

11_反射(小結)

• 把反射的知識點總結一下。

12_設計模式

1,裝飾
2,單例
3,簡單工廠
4,工廠方法
5,適配器
6,模版

13_JDK5新特性(本身實現枚舉類)

• A:枚舉概述

  • 是指將變量的值一一列出來,變量的值只限於列舉出來的值的範圍內。舉例：一週只有7天，一年只有12個月等。

• B:回想單例設計模式：單例類是一個類只有一個實例

  • 那麼多例類就是一個類有多個實例，但不是無限個數的實例，而是有限個數的實例。這才能是枚舉類。

• C:案例演示

  • 本身實現枚舉類

1,自動拆裝箱
2,泛型
3,可變參數
4,靜態導入
5,加強for循環
6,互斥鎖
7,switch語句中能夠接 枚舉

14_JDK5新特性(經過enum實現枚舉類)

• A:案例演示

  • 經過enum實現枚舉類

15_JDK5新特性(枚舉的注意事項)

• A:案例演示

  • 定義枚舉類要用關鍵字enum
  • 全部枚舉類都是Enum的子類
  • 枚舉類的第一行上必須是枚舉項，最後一個枚舉項後的分號是能夠省略的，可是若是枚舉類有其餘的東西，這個分號就不能省略。建議不要省略
  • 枚舉類能夠有構造器，但必須是private的，它默認的也是private的。
  • 枚舉類也能夠有抽象方法，可是枚舉項必須重寫該方法
  • 枚舉在switch語句中的使用

16_JDK5新特性(枚舉類的常見方法)

• A:枚舉類的常見方法

  • int ordinal()
  • int compareTo(E o)
  • String name()
  • String toString()
  • values()
  • 此方法雖然在JDK文檔中查找不到，但每一個枚舉類都具備該方法，它遍歷枚舉類的全部枚舉值很是方便

• B:案例演示

  • 枚舉類的常見方法

17_JDK7新特性(JDK7的六個新特性回顧和講解)

• A:二進制字面量
• B:數字字面量能夠出現下劃線
• C:switch 語句能夠用字符串
• D:泛型簡化,菱形泛型
• E:異常的多個catch合併,每一個異經常使用或|
• F:try-with-resources 語句(1.7版本標準的異常處理代碼)

18_JDK8新特性(JDK8的新特性)

• 接口中能夠定義有方法體的方法,若是是非靜態,必須用default修飾(不加default,它會認爲你是抽象的方法)
• 若是是靜態的就不用了
• 1.8版本前局部內部類在訪問他所在方法中的局部變量必須用final修飾
• 1.8版本中局部內部類在訪問他所在方法中的局部變量時,final能夠省略;

class Test {
            public void run() {
                final int x = 10;
                class Inner {
                    public void method() {
                        System.out.println(x);
                    }
                }
        
                Inner i = new Inner();
                i.method();
            }
            
        }

• 1.7版本:局部內部類在訪問他所在方法中的局部變量必須用final修飾,爲何?

  • 由於當調用這個方法時,局部變量若是沒有用final修飾,他的生命週期和方法的生命週期是同樣的,當方法彈棧,這個局部變量也會消失,
  • 那麼若是局部內部類對象尚未立刻消失想用這個局部變量,就沒有了,若是用final修飾會在類加載的時候進入常量池,即便方法彈棧,常量池的常量還在,也能夠繼續使用

interface Inter {
            public default void print() {
                System.out.println("hello world");
            }
            
            public static void method() {
                System.out.println("static method");
            }
        }
        
        class Demo implements Inter {
            public void run() {
                /*final*/ int num = 10;
                class Inner {
                    public void fun() {
                        //num = 20;
                        System.out.println(num);
                    }
                }
                
                Inner i = new Inner();
                i.fun();
            }
        }