反射

反射機(jī)制有什么用的榛？
通過(guò)java語(yǔ)言中的反射機(jī)制可以操作字節(jié)碼文件租悄。
有點(diǎn)類(lèi)似于黑客谨究。（可以讀和修改字節(jié)碼文件）
通過(guò)反射機(jī)制可以操作代碼片段。（class文件泣棋。）

反射機(jī)制的相關(guān)類(lèi)在哪個(gè)包下胶哲？
java.lang.reflect.*;

反射機(jī)制相關(guān)的重要的類(lèi)有哪些？
java.lang.Class：代表整個(gè)字節(jié)碼潭辈，代表一個(gè)類(lèi)型
java.lang.reflect.Method：代表字節(jié)碼中的方法字節(jié)碼
java.lang.reflect.Constructor：代表字節(jié)碼中的構(gòu)造方法字節(jié)碼
java.lang.reflect.Field：代表字節(jié)碼中的屬性字節(jié)碼鸯屿。代表類(lèi)中的成員變量（靜態(tài)變量+實(shí)例變量）

舉例說(shuō)明.png

獲取class的三種方式

要操作一個(gè)類(lèi)的字節(jié)碼澈吨，需要首先獲取到這個(gè)類(lèi)的字節(jié)碼，怎么獲取java.lang.Class實(shí)例寄摆？
三種方式
第一種：Class c = Class.forName("完整類(lèi)名帶包名");
Class.forName()
1谅辣、靜態(tài)方法
2、方法的參數(shù)是一個(gè)字符串婶恼。
3屈藐、字符串需要的是一個(gè)完整類(lèi)名。
4熙尉、完整類(lèi)名必須帶有包名联逻。java.lang包也不能省略
第二種：Class c = 對(duì)象.getClass();
第三種：Class c = 任何類(lèi)型.class;

public class ReflectTest01 {
    public static void main(String[] args) {
        /*
        Class.forName()
            1、靜態(tài)方法
            2检痰、方法的參數(shù)是一個(gè)字符串包归。
            3、字符串需要的是一個(gè)完整類(lèi)名铅歼。
            4公壤、完整類(lèi)名必須帶有包名。java.lang包也不能省略椎椰。
         */
        Class c1 = null;
        Class c2 = null;
        try {
            c1 = Class.forName("java.lang.String"); // c1代表String.class文件厦幅，或者說(shuō)c1代表String類(lèi)型。
            c2 = Class.forName("java.util.Date"); // c2代表Date類(lèi)型
            Class c3 = Class.forName("java.lang.Integer"); // c3代表Integer類(lèi)型
            Class c4 = Class.forName("java.lang.System"); // c4代表System類(lèi)型
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        // java中任何一個(gè)對(duì)象都有一個(gè)方法：getClass()
        String s = "abc";
        Class x = s.getClass(); // x代表String.class字節(jié)碼文件慨飘，x代表String類(lèi)型确憨。
        System.out.println(c1 == x); // true（==判斷的是對(duì)象的內(nèi)存地址。）

        Date time = new Date();
        Class y = time.getClass();
        System.out.println(c2 == y); // true (c2和y兩個(gè)變量中保存的內(nèi)存地址都是一樣的瓤的，都指向方法區(qū)中的字節(jié)碼文件休弃。)

        // 第三種方式，java語(yǔ)言中任何一種類(lèi)型圈膏，包括基本數(shù)據(jù)類(lèi)型塔猾，它都有.class屬性。
        Class z = String.class; // z代表String類(lèi)型
        Class k = Date.class; // k代表Date類(lèi)型
        Class f = int.class; // f代表int類(lèi)型
        Class e = double.class; // e代表double類(lèi)型

        System.out.println(x == z); // true

    }
}

第二種獲取方式的原理.png

獲取到Class稽坤，能干什么丈甸？

通過(guò)Class的newInstance()方法來(lái)實(shí)例化對(duì)象。
注意：newInstance()方法內(nèi)部實(shí)際上調(diào)用了無(wú)參數(shù)構(gòu)造方法尿褪，必須保證無(wú)參構(gòu)造存在才可以睦擂。

public class ReflectTest02 {
    public static void main(String[] args) {

        // 這是不使用反射機(jī)制，創(chuàng)建對(duì)象
        User user = new User();
        System.out.println(user);

        // 下面這段代碼是以反射機(jī)制的方式創(chuàng)建對(duì)象茫多。
        try {
            // 通過(guò)反射機(jī)制祈匙，獲取Class，通過(guò)Class來(lái)實(shí)例化對(duì)象
            Class c = Class.forName("User"); // c代表User類(lèi)型。

            // newInstance() 這個(gè)方法會(huì)調(diào)用User這個(gè)類(lèi)的無(wú)參數(shù)構(gòu)造方法夺欲，完成對(duì)象的創(chuàng)建跪帝。
            // 重點(diǎn)是：newInstance()調(diào)用的是無(wú)參構(gòu)造，必須保證無(wú)參構(gòu)造是存在的些阅！
            Object obj = c.newInstance();

            System.out.println(obj); // com.bjpowernode.java.bean.User@10f87f48
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

public class User {
    public User(){
        System.out.println("無(wú)參數(shù)構(gòu)造方法伞剑！");
    }

    // 定義了有參數(shù)的構(gòu)造方法，無(wú)參數(shù)構(gòu)造方法就沒(méi)了市埋。
    public User(String s){

    }
}

直接new對(duì)象沒(méi)有反射機(jī)制靈活黎泣。反射機(jī)制更加靈活。

java代碼寫(xiě)一遍缤谎，再不改變java源代碼的基礎(chǔ)之上抒倚，可以做到不同對(duì)象的實(shí)例化。
非常之靈活坷澡。（符合OCP開(kāi)閉原則：對(duì)擴(kuò)展開(kāi)放托呕，對(duì)修改關(guān)閉。）

后期要學(xué)習(xí)的是高級(jí)框架频敛，而工作過(guò)程中项郊，也都是使用高級(jí)框架，
包括： ssh ssm
Spring SpringMVC MyBatis
Spring Struts Hibernate
...
這些高級(jí)框架底層實(shí)現(xiàn)原理：都采用了反射機(jī)制斟赚。所以反射機(jī)制還是重要的着降。
學(xué)會(huì)了反射機(jī)制有利于你理解剖析框架底層的源代碼。

public class ReflectTest03 {
    public static void main(String[] args) throws Exception{

        // 這種方式代碼就寫(xiě)死了拗军。只能創(chuàng)建一個(gè)User類(lèi)型的對(duì)象
        //User user = new User();

        // 以下代碼是靈活的任洞，代碼不需要改動(dòng)，可以修改配置文件食绿，配置文件修改之后侈咕，可以創(chuàng)建出不同的實(shí)例對(duì)象。
        // 通過(guò)IO流讀取classinfo.properties文件
        FileReader reader = new FileReader("classinfo2.properties");
        // 創(chuàng)建屬性類(lèi)對(duì)象Map
        Properties pro = new Properties(); // key value都是String
        // 加載
        pro.load(reader);
        // 關(guān)閉流
        reader.close();

        // 通過(guò)key獲取value
        String className = pro.getProperty("className");
        //System.out.println(className);

        // 通過(guò)反射機(jī)制實(shí)例化對(duì)象
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        System.out.println(obj);
    }
}

classinfo2.properties文件

className=User

Class.forName()發(fā)生了什么器紧？

重點(diǎn)：如果你只希望一個(gè)類(lèi)的靜態(tài)代碼塊執(zhí)行，其他代碼一律不執(zhí)行楼眷，你可以使用：
Class.forName("完整類(lèi)名");
這個(gè)方法的執(zhí)行會(huì)導(dǎo)致類(lèi)加載铲汪，類(lèi)加載時(shí)，靜態(tài)代碼塊執(zhí)行罐柳。

提示：后期學(xué)習(xí)JDBC的時(shí)候我們還要用掌腰。

public class ReflectTest04 {
    public static void main(String[] args) {
        try {
            // Class.forName()這個(gè)方法的執(zhí)行會(huì)導(dǎo)致：類(lèi)加載。
            Class.forName("MyClass");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class MyClass {

    // 靜態(tài)代碼塊在類(lèi)加載時(shí)執(zhí)行张吉，并且只執(zhí)行一次齿梁。
    static {
        System.out.println("MyClass類(lèi)的靜態(tài)代碼塊執(zhí)行了！");
    }
}

關(guān)于路徑的問(wèn)題

FileReader reader = new FileReader("classinfo2.properties");
這種方式的路徑缺點(diǎn)是：移植性差，在IDEA中默認(rèn)的當(dāng)前路徑是project的跟勺择。
這個(gè)代碼假設(shè)離開(kāi)了IDEA创南，換到了其他位置，可能當(dāng)前路徑就不是project的根了省核，這時(shí)這個(gè)路徑就無(wú)效了稿辙。

/*
研究一下文件路徑的問(wèn)題。
怎么獲取一個(gè)文件的絕對(duì)路徑气忠。以下講解的這種方式是通用的邻储。但前提是：文件需要在類(lèi)路徑下。才能用這種方式旧噪。
 */
public class AboutPath {
    public static void main(String[] args) throws Exception{
        // 這種方式的路徑缺點(diǎn)是：移植性差吨娜，在IDEA中默認(rèn)的當(dāng)前路徑是project的根。
        // 這個(gè)代碼假設(shè)離開(kāi)了IDEA淘钟，換到了其它位置萌壳，可能當(dāng)前路徑就不是project的根了，這時(shí)這個(gè)路徑就無(wú)效了日月。
        //FileReader reader = new FileReader("chapter25/classinfo2.properties");

        // 接下來(lái)說(shuō)一種比較通用的一種路徑袱瓮。即使代碼換位置了，這樣編寫(xiě)仍然是通用的爱咬。
        // 注意：使用以下通用方式的前提是：這個(gè)文件必須在類(lèi)路徑下尺借。
        // 什么類(lèi)路徑下？凡是在src下的都是類(lèi)路徑下精拟×钦叮【記住它】
        // src是類(lèi)的根路徑。
        /*
        解釋?zhuān)?            Thread.currentThread() 當(dāng)前線程對(duì)象
            getContextClassLoader() 是線程對(duì)象的方法蜂绎，可以獲取到當(dāng)前線程的類(lèi)加載器對(duì)象栅表。
            getResource() 【獲取資源】這是類(lèi)加載器對(duì)象的方法，當(dāng)前線程的類(lèi)加載器默認(rèn)從類(lèi)的根路徑下加載資源师枣。
         */
        String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo2.properties").getPath(); // 這種方式獲取文件絕對(duì)路徑是通用的怪瓶。

        // 采用以上的代碼可以拿到一個(gè)文件的絕對(duì)路徑。
        // /C:/Users/Administrator/IdeaProjects/javase/out/production/chapter25/classinfo2.properties
        System.out.println(path);

        // 獲取db.properties文件的絕對(duì)路徑（從類(lèi)的根路徑下作為起點(diǎn)開(kāi)始）
        String path2 = Thread.currentThread().getContextClassLoader()
                .getResource("db.properties").getPath();
        System.out.println(path2);
    }
}

以IO流的方式返回

import java.io.FileReader;
import java.io.InputStream;
import java.util.Properties;

public class IoPropertiesTest {
    public static void main(String[] args) throws Exception{

        // 獲取一個(gè)文件的絕對(duì)路徑了＜馈Ｏ捶　！Ｔ沙敛滋！
        /*String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo.properties").getPath();
        FileReader reader = new FileReader(path);*/

        // 直接以流的形式返回。
        InputStream reader = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("classinfo2.properties");

        Properties pro = new Properties();
        pro.load(reader);
        reader.close();
        // 通過(guò)key獲取value
        String className = pro.getProperty("className");
        System.out.println(className);
    }
}

資源綁定器

java.util包下提供了一個(gè)資源綁定器兴革，便于獲取屬性配置文件中的內(nèi)容绎晃。
使用以下這種方式的時(shí)候蜜唾，屬性配置文件xxx.properties必須放到類(lèi)路徑下。

import java.util.ResourceBundle;

public class ResourceBundleTest {
    public static void main(String[] args) {

        // 資源綁定器庶艾，只能綁定xxx.properties文件袁余。并且這個(gè)文件必須在類(lèi)路徑下。文件擴(kuò)展名也必須是properties
        // 并且在寫(xiě)路徑的時(shí)候落竹，路徑后面的擴(kuò)展名不能寫(xiě)泌霍。
        ResourceBundle bundle = ResourceBundle.getBundle("classinfo");

      //  ResourceBundle bundle = ResourceBundle.getBundle("com/bjpowernode/java/bean/db");

        String className = bundle.getString("className");
        System.out.println(className);

    }
}

類(lèi)加載器（了解）

什么是類(lèi)加載器？
專(zhuān)門(mén)負(fù)責(zé)加載類(lèi)的命令/工具述召。
ClassLoader

JDK中自帶了3個(gè)類(lèi)加載器
啟動(dòng)類(lèi)加載器：rt.jar
擴(kuò)展類(lèi)加載器：ext/*.jar
應(yīng)用類(lèi)加載器：classpath

假設(shè)有這樣一段代碼：
String s = "abc";
代碼在開(kāi)始執(zhí)行之前朱转，會(huì)將所需要的類(lèi)全部加載到JVM當(dāng)中。
通過(guò)類(lèi)加載器加載积暖，看到以上代碼類(lèi)加載器會(huì)找String.class文件藤为，找到就加載，那么是怎么進(jìn)行加載的呢夺刑？

首先通過(guò)“啟動(dòng)類(lèi)加載器”加載
注意：?jiǎn)?dòng)類(lèi)加載器專(zhuān)門(mén)加載：jre\lib\rt.jar
rt.jar中都是JDK最核心的類(lèi)庫(kù)缅疟。

如果通過(guò)”啟動(dòng)類(lèi)加載器“加載不到的時(shí)候，會(huì)通過(guò)”擴(kuò)展類(lèi)加載器“加載遍愿。
注意：擴(kuò)展類(lèi)加載器專(zhuān)門(mén)加載：jre\lib\ext*.jar

如果“擴(kuò)展類(lèi)加載器”沒(méi)有加載到存淫，那么會(huì)通過(guò)“應(yīng)用類(lèi)加載器”加載。
注意：應(yīng)用類(lèi)加載器專(zhuān)門(mén)加載：classpath中的jar包（class文件）

雙親委派機(jī)制（了解）

java中為了保證類(lèi)加載的安全沼填，使用了雙親委派機(jī)制桅咆。
優(yōu)先從啟動(dòng)類(lèi)加載器中加載，這個(gè)稱(chēng)為“父”坞笙，“父”無(wú)法加載到岩饼，再?gòu)臄U(kuò)展類(lèi)加載器中加載，這個(gè)稱(chēng)為“母”薛夜，雙親委派籍茧。如果都加載不到，才會(huì)考慮從應(yīng)用類(lèi)加載器中加載梯澜。直到加載到為止寞冯。

獲取Field

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

/*
反射Student類(lèi)當(dāng)中所有的Field（了解一下）
 */
public class ReflectTest05 {
    public static void main(String[] args) throws Exception{

        // 獲取整個(gè)類(lèi)
        Class studentClass = Class.forName("Student");

        //com.bjpowernode.java.bean.Student
        String className = studentClass.getName();
        System.out.println("完整類(lèi)名：" + className);

        String simpleName = studentClass.getSimpleName();
        System.out.println("簡(jiǎn)類(lèi)名：" + simpleName);

        // 獲取類(lèi)中所有的public修飾的Field
        Field[] fields = studentClass.getFields();
        System.out.println(fields.length); // 測(cè)試數(shù)組中只有1個(gè)元素
        // 取出這個(gè)Field
        Field f = fields[0];
        // 取出這個(gè)Field它的名字
        String fieldName = f.getName();
        System.out.println(fieldName);

        // 獲取所有的Field
        Field[] fs = studentClass.getDeclaredFields();
        System.out.println(fs.length); // 4

        System.out.println("==================================");
        // 遍歷
        for(Field field : fs){
            // 獲取屬性的修飾符列表
            int i = field.getModifiers(); // 返回的修飾符是一個(gè)數(shù)字，每個(gè)數(shù)字是修飾符的代號(hào)＠搬恪＜蚴！
            System.out.println(i);
            // 可以將這個(gè)“代號(hào)”數(shù)字轉(zhuǎn)換成“字符串”嗎撬腾？
            String modifierString = Modifier.toString(i);
            System.out.println(modifierString);
            // 獲取屬性的類(lèi)型
            Class fieldType = field.getType();
            //String fName = fieldType.getName();
            String fName = fieldType.getSimpleName();
            System.out.println(fName);
            // 獲取屬性的名字
            System.out.println(field.getName());
        }
    }
}

// 反射屬性Field
public class Student {

    // Field翻譯為字段，其實(shí)就是屬性/成員
    // 4個(gè)Field恢恼，分別采用了不同的訪問(wèn)控制權(quán)限修飾符
    private String name; // Field對(duì)象
    protected int age; // Field對(duì)象
    boolean sex;
    public int no;
    public static final double MATH_PI = 3.1415926;
}

反編譯Filed

拿到字節(jié)碼文件后民傻，對(duì)其進(jìn)行反編譯Filed，取出

//通過(guò)反射機(jī)制，反編譯一個(gè)類(lèi)的屬性Field（了解一下）

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

public class ReflectTest06 {
    public static void main(String[] args) throws Exception{

        // 創(chuàng)建這個(gè)是為了拼接字符串漓踢。
        StringBuilder s = new StringBuilder();

        //Class studentClass = Class.forName("com.bjpowernode.java.bean.Student");
        Class studentClass = Class.forName("java.lang.Thread");

        s.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName() + " {\n");

        Field[] fields = studentClass.getDeclaredFields();
        for(Field field : fields){
            s.append("\t");
            s.append(Modifier.toString(field.getModifiers()));
            s.append(" ");
            s.append(field.getType().getSimpleName());
            s.append(" ");
            s.append(field.getName());
            s.append(";\n");
        }

        s.append("}");
        System.out.println(s);

    }
}

反射Field(重點(diǎn))

怎么通過(guò)反射機(jī)制訪問(wèn)一個(gè)java對(duì)象的屬性

import java.lang.reflect.Field;

/*
必須掌握：
    怎么通過(guò)反射機(jī)制訪問(wèn)一個(gè)java對(duì)象的屬性牵署？
        給屬性賦值set
        獲取屬性的值get
 */
public class ReflectTest07 {
    public static void main(String[] args) throws Exception{

        // 我們不使用反射機(jī)制，怎么去訪問(wèn)一個(gè)對(duì)象的屬性呢喧半？
        Student s = new Student();

        // 給屬性賦值
        s.no = 1111; //三要素：給s對(duì)象的no屬性賦值1111
                    //要素1：對(duì)象s
                    //要素2：no屬性
                    //要素3：1111

        // 讀屬性值
        // 兩個(gè)要素：獲取s對(duì)象的no屬性的值奴迅。
        System.out.println(s.no);

        // 使用反射機(jī)制，怎么去訪問(wèn)一個(gè)對(duì)象的屬性挺据。（set get）
        Class studentClass = Class.forName("com.bjpowernode.java.bean.Student");
        Object obj = studentClass.newInstance(); // obj就是Student對(duì)象取具。（底層調(diào)用無(wú)參數(shù)構(gòu)造方法）

        // 獲取no屬性（根據(jù)屬性的名稱(chēng)來(lái)獲取Field）
        Field noFiled = studentClass.getDeclaredField("no");

        // 給obj對(duì)象(Student對(duì)象)的no屬性賦值
        /*
        雖然使用了反射機(jī)制，但是三要素還是缺一不可：
            要素1：obj對(duì)象
            要素2：no屬性
            要素3：2222值
        注意：反射機(jī)制讓代碼復(fù)雜了扁耐，但是為了一個(gè)“靈活”暇检，這也是值得的。
         */
        noFiled.set(obj, 22222); // 給obj對(duì)象的no屬性賦值2222

        // 讀取屬性的值
        // 兩個(gè)要素：獲取obj對(duì)象的no屬性的值婉称。
        System.out.println(noFiled.get(obj));

        // 可以訪問(wèn)私有的屬性嗎块仆？
        Field nameField = studentClass.getDeclaredField("name");

        // 打破封裝（反射機(jī)制的缺點(diǎn)：打破封裝，可能會(huì)給不法分子留下機(jī)會(huì)Ｍ醢怠；诰荨！）
        // 這樣設(shè)置完之后俗壹，在外部也是可以訪問(wèn)private的科汗。
        nameField.setAccessible(true);

        // 給name屬性賦值
        nameField.set(obj, "jackson");
        // 獲取name屬性的值
        System.out.println(nameField.get(obj));
    }
}

可變長(zhǎng)度參數(shù)

int... args 這就是可變長(zhǎng)度參數(shù)
語(yǔ)法是：類(lèi)型...  （注意：一定是3個(gè)點(diǎn)。）

1策肝、可變長(zhǎng)度參數(shù)要求的參數(shù)個(gè)數(shù)是：0~N個(gè)肛捍。
2、可變長(zhǎng)度參數(shù)在參數(shù)列表中必須在最后一個(gè)位置上之众，而且可變長(zhǎng)度參數(shù)只能有1個(gè)拙毫。
3、可變長(zhǎng)度參數(shù)可以當(dāng)做一個(gè)數(shù)組來(lái)看待

public class ArgsTest {
    public static void main(String[] args) {
        m();
        m(10);
        m(10, 20);

        // 編譯報(bào)錯(cuò)
        //m("abc");

        m2(100);
        m2(200, "abc");
        m2(200, "abc", "def");
        m2(200, "abc", "def", "xyz");

        m3("ab", "de", "kk", "ff");

        String[] strs = {"a","b","c"};
        // 也可以傳1個(gè)數(shù)組
        m3(strs);

        // 直接傳1個(gè)數(shù)組
        m3(new String[]{"我","是","中","國(guó)", "人"}); //沒(méi)必要

        m3("我","是","中","國(guó)", "人");
    }

    public static void m(int... args){
        System.out.println("m方法執(zhí)行了棺禾！");
    }

    //public static void m2(int... args2, String... args1){}

    // 必須在最后缀蹄，只能有1個(gè)。
    public static void m2(int a, String... args1){

    }

    public static void m3(String... args){
        //args有l(wèi)ength屬性膘婶，說(shuō)明args是一個(gè)數(shù)組缺前！
        // 可以將可變長(zhǎng)度參數(shù)當(dāng)做一個(gè)數(shù)組來(lái)看。
        for(int i = 0; i < args.length; i++){
            System.out.println(args[i]);
        }
    }

}

反射Method

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

/*
作為了解內(nèi)容（不需要掌握）：
    反射Method
 */
public class ReflectTest08 {
    public static void main(String[] args) throws Exception{

        // 獲取類(lèi)了
        Class userServiceClass = Class.forName("UserService");

        // 獲取所有的Method（包括私有的Ｐ蟆）
        Method[] methods = userServiceClass.getDeclaredMethods();
        //System.out.println(methods.length); // 2

        // 遍歷Method
        for(Method method : methods){
            // 獲取修飾符列表
            System.out.println(Modifier.toString(method.getModifiers()));
            // 獲取方法的返回值類(lèi)型
            System.out.println(method.getReturnType().getSimpleName());
            // 獲取方法名
            System.out.println(method.getName());
            // 方法的修飾符列表（一個(gè)方法的參數(shù)可能會(huì)有多個(gè)衅码。）
            Class[] parameterTypes = method.getParameterTypes();
            for(Class parameterType : parameterTypes){
                System.out.println(parameterType.getSimpleName());
            }
        }
    }
}

/**
 * 用戶(hù)業(yè)務(wù)類(lèi)
 */
public class UserService {

    /**
     * 登錄方法
     * @param name 用戶(hù)名
     * @param password 密碼
     * @return true表示登錄成功，false表示登錄失敿乖馈逝段！
     */
    public boolean login(String name,String password){
        if("admin".equals(name) && "123".equals(password)){
            return true;
        }
        return false;
    }

    // 可能還有一個(gè)同名login方法
    // java中怎么區(qū)分一個(gè)方法垛玻，依靠方法名和參數(shù)列表。
    public void login(int i){

    }

    /**
     * 退出系統(tǒng)的方法
     */
    public void logout(){
        System.out.println("系統(tǒng)已經(jīng)安全退出奶躯！");
    }
}

反編譯Method

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

/*
了解一下帚桩，不需要掌握（反編譯一個(gè)類(lèi)的方法。）
 */
public class ReflectTest09 {
    public static void main(String[] args) throws Exception{
        StringBuilder s = new StringBuilder();
        //Class userServiceClass = Class.forName("UserService");
        Class userServiceClass = Class.forName("java.lang.String");
        s.append(Modifier.toString(userServiceClass.getModifiers()) + " class "+userServiceClass.getSimpleName()+" {\n");

        Method[] methods = userServiceClass.getDeclaredMethods();
        for(Method method : methods){
            //public boolean login(String name,String password){}
            s.append("\t");
            s.append(Modifier.toString(method.getModifiers()));
            s.append(" ");
            s.append(method.getReturnType().getSimpleName());
            s.append(" ");
            s.append(method.getName());
            s.append("(");
            // 參數(shù)列表
            Class[] parameterTypes = method.getParameterTypes();
            for(Class parameterType : parameterTypes){
                s.append(parameterType.getSimpleName());
                s.append(",");
            }
            // 刪除指定下標(biāo)位置上的字符
            s.deleteCharAt(s.length() - 1);
            s.append("){}\n");
        }

        s.append("}");
        System.out.println(s);
    }
}

通過(guò)反射機(jī)制調(diào)用方法（重點(diǎn)）

重點(diǎn)：必須掌握嘹黔，通過(guò)反射機(jī)制怎么調(diào)用一個(gè)對(duì)象的方法账嚎？
五顆星*****

反射機(jī)制，讓代碼很具有通用性儡蔓，可變化的內(nèi)容都是寫(xiě)到配置文件當(dāng)中郭蕉，
將來(lái)修改配置文件之后，創(chuàng)建的對(duì)象不一樣了浙值，調(diào)用的方法也不同了恳不，
但是java代碼不需要做任何改動(dòng)。這就是反射機(jī)制的魅力开呐。

import java.lang.reflect.Method;

public class ReflectTest10 {
    public static void main(String[] args) throws Exception{
        // 不使用反射機(jī)制烟勋，怎么調(diào)用方法
        // 創(chuàng)建對(duì)象
        UserService userService = new UserService();
        // 調(diào)用方法
        /*
        要素分析：
            要素1：對(duì)象userService
            要素2：login方法名
            要素3：實(shí)參列表
            要素4：返回值
         */
        boolean loginSuccess = userService.login("admin","123");
        //System.out.println(loginSuccess);
        System.out.println(loginSuccess ? "登錄成功" : "登錄失敗");

        // 使用反射機(jī)制來(lái)調(diào)用一個(gè)對(duì)象的方法該怎么做？
        Class userServiceClass = Class.forName("UserService");
        // 創(chuàng)建對(duì)象
        Object obj = userServiceClass.newInstance();
        // 獲取Method
        Method loginMethod = userServiceClass.getDeclaredMethod("login", String.class, String.class);
        //Method loginMethod = userServiceClass.getDeclaredMethod("login", int.class);
        // 調(diào)用方法
        // 調(diào)用方法有幾個(gè)要素筐付？ 也需要4要素卵惦。
        // 反射機(jī)制中最最最最最重要的一個(gè)方法，必須記住瓦戚。
        /*
        四要素：
        loginMethod方法
        obj對(duì)象
        "admin","123" 實(shí)參
        retValue 返回值
         */
        Object retValue = loginMethod.invoke(obj, "admin","123123");
        System.out.println(retValue);
    }
}

反射Constructor

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

/*
反編譯一個(gè)類(lèi)的Constructor構(gòu)造方法沮尿。
 */
public class ReflectTest11 {
    public static void main(String[] args) throws Exception{
        StringBuilder s = new StringBuilder();
        Class vipClass = Class.forName("java.lang.String");
        s.append(Modifier.toString(vipClass.getModifiers()));
        s.append(" class ");
        s.append(vipClass.getSimpleName());
        s.append("{\n");

        // 拼接構(gòu)造方法
        Constructor[] constructors = vipClass.getDeclaredConstructors();
        for(Constructor constructor : constructors){
            //public Vip(int no, String name, String birth, boolean sex) {
            s.append("\t");
            s.append(Modifier.toString(constructor.getModifiers()));
            s.append(" ");
            s.append(vipClass.getSimpleName());
            s.append("(");
            // 拼接參數(shù)
            Class[] parameterTypes = constructor.getParameterTypes();
            for(Class parameterType : parameterTypes){
                s.append(parameterType.getSimpleName());
                s.append(",");
            }
            // 刪除最后下標(biāo)位置上的字符
            if(parameterTypes.length > 0){
                s.deleteCharAt(s.length() - 1);
            }
            s.append("){}\n");
        }

        s.append("}");
        System.out.println(s);
    }
}

public class Vip {
    int no;
    String name;
    String birth;
    boolean sex;

    public Vip() {
    }

    public Vip(int no) {
        this.no = no;
    }

    public Vip(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public Vip(int no, String name, String birth) {
        this.no = no;
        this.name = name;
        this.birth = birth;
    }

    public Vip(int no, String name, String birth, boolean sex) {
        this.no = no;
        this.name = name;
        this.birth = birth;
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Vip{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", birth='" + birth + '\'' +
                ", sex=" + sex +
                '}';
    }
}

反射機(jī)制調(diào)用構(gòu)造方法

import java.lang.reflect.Constructor;

/*
比上一個(gè)例子(ReflectTest11)重要一些！＝辖狻畜疾！

通過(guò)反射機(jī)制調(diào)用構(gòu)造方法實(shí)例化java對(duì)象。（這個(gè)不是重點(diǎn)）
 */
public class ReflectTest12 {
    public static void main(String[] args) throws Exception{
        // 不使用反射機(jī)制怎么創(chuàng)建對(duì)象
        Vip v1 = new Vip();
        Vip v2 = new Vip(110, "zhangsan", "2001-10-11", true);

        // 使用反射機(jī)制怎么創(chuàng)建對(duì)象呢印衔？
        Class c = Class.forName("Vip");
        // 調(diào)用無(wú)參數(shù)構(gòu)造方法
        Object obj = c.newInstance();
        System.out.println(obj);

        // 調(diào)用有參數(shù)的構(gòu)造方法怎么辦啡捶？
        // 第一步：先獲取到這個(gè)有參數(shù)的構(gòu)造方法
        Constructor con = c.getDeclaredConstructor(int.class, String.class, String.class,boolean.class);
        // 第二步：調(diào)用構(gòu)造方法new對(duì)象
        Object newObj = con.newInstance(110, "jackson", "1990-10-11", true);
        System.out.println(newObj);

        // 獲取無(wú)參數(shù)構(gòu)造方法
        Constructor con2 = c.getDeclaredConstructor();
        Object newObj2 = con2.newInstance();
        System.out.println(newObj2);
    }
}

獲取父類(lèi)和父接口

/*
重點(diǎn)：給你一個(gè)類(lèi)，怎么獲取這個(gè)類(lèi)的父類(lèi)奸焙，已經(jīng)實(shí)現(xiàn)了哪些接口瞎暑？
 */
public class ReflectTest13 {
    public static void main(String[] args) throws Exception{

        // String舉例
        Class stringClass = Class.forName("java.lang.String");

        // 獲取String的父類(lèi)
        Class superClass = stringClass.getSuperclass();
        System.out.println(superClass.getName());

        // 獲取String類(lèi)實(shí)現(xiàn)的所有接口（一個(gè)類(lèi)可以實(shí)現(xiàn)多個(gè)接口。）
        Class[] interfaces = stringClass.getInterfaces();
        for(Class in : interfaces){
            System.out.println(in.getName());
        }
    }
}

注解

注解与帆，或者叫做注釋類(lèi)型了赌，英文單詞是：Annotation

注解Annotation是一種引用數(shù)據(jù)類(lèi)型。編譯之后也是生成xxx.class文件玄糟。

怎么自定義注解呢勿她？語(yǔ)法格式？
[修飾符列表] @interface 注解類(lèi)型名{

}

注解怎么使用阵翎，用在什么地方嫂拴？
第一：注解使用時(shí)的語(yǔ)法格式是：
@注解類(lèi)型名

第二：注解可以出現(xiàn)在類(lèi)上播揪、屬性上贮喧、方法上筒狠、變量上等...
注解還可以出現(xiàn)在注解類(lèi)型上。

默認(rèn)情況下箱沦，注解可以出現(xiàn)在任意位置

JDK中內(nèi)置了哪些注解呢辩恼？
java.lang包下的注釋類(lèi)型：
掌握：
Deprecated 用@Deprecated 注釋的程序元素，不鼓勵(lì)程序員使用這樣的元素谓形，通常是因?yàn)樗芪ｋU(xiǎn)或存在更好的選擇灶伊。
掌握：
Override 表示一個(gè)方法聲明打算重寫(xiě)超類(lèi)中的另一個(gè)方法聲明。
不用掌握：
SuppressWarnings 指示應(yīng)該在注釋元素（以及包含在該注釋元素中的所有程序元素）中取消顯示指定的編譯器警告寒跳。

Override注解

源代碼：
public @interface Override {
}

標(biāo)識(shí)性注解聘萨，給編譯器做參考的。
編譯器看到方法上有這個(gè)注解的時(shí)候童太，編譯器會(huì)自動(dòng)檢查該方法是否重寫(xiě)了父類(lèi)的方法米辐。如果沒(méi)有重寫(xiě)，報(bào)錯(cuò)书释。

@Override 這個(gè)注解只能注解方法翘贮。
@Override 這個(gè)注解是給編譯器參考的，和運(yùn)行階段沒(méi)有關(guān)系爆惧。
凡是java中的方法帶有這個(gè)注解的狸页，編譯器都會(huì)進(jìn)行編譯檢查，如果這個(gè)方法不是重寫(xiě)父類(lèi)的方法扯再，編譯器報(bào)錯(cuò)芍耘。

元注解

什么是元注解？
用來(lái)標(biāo)注“注解類(lèi)型”的“注解”熄阻，稱(chēng)為元注解斋竞。

常見(jiàn)的元注解有哪些？
Target
Retention

關(guān)于Target注解：
這是一個(gè)元注解饺律，用來(lái)標(biāo)注“注解類(lèi)型”的“注解”窃页。
這個(gè)Target注解用來(lái)標(biāo)注“被標(biāo)注的注解”可以出現(xiàn)在哪些位置上。
@Target (ElementType.METHOD)：表示“被標(biāo)注的注解”只能出現(xiàn)在方法上复濒。

關(guān)于Retention注解：
這是一個(gè)元注解脖卖，用來(lái)標(biāo)注“注解類(lèi)型”的“注解”。
這個(gè)Retention注解用來(lái)標(biāo)注“被標(biāo)注的注解”最終保存在哪里巧颈。
@Retention (RetentionPolicy.SOURCE)：表示該注解只被保留在java源文件中畦木。
@Retention (RetentionPolicy.CLASS)：表示該注解被保留在class文件中。
@Retention (RetentionPolicy.RUNTIME)：表示該注解被保留在class文件中,并且可以被反射機(jī)制所讀取砸泛。

Deprecated注解

Deprecated這個(gè)注解標(biāo)注的元素已過(guò)時(shí)十籍。
這個(gè)注解主要是向其它程序員傳達(dá)一個(gè)信息蛆封，告知已過(guò)時(shí)，有更好的解決方案存在勾栗。

注解中定義屬性

public @interface MyAnnotation {

    /**
     * 我們通常在注解當(dāng)中可以定義屬性惨篱，以下這個(gè)是MyAnnotation的name屬性。
     * 看著像1個(gè)方法围俘，但實(shí)際上我們稱(chēng)之為屬性name砸讳。
     * @return
     */
    String name();

    /*
    顏色屬性
     */
    String color();

    /*
    年齡屬性
     */
    int age() default 25; //屬性指定默認(rèn)值

}

public class MyAnnotationTest {

    // 報(bào)錯(cuò)的原因：如果一個(gè)注解當(dāng)中有屬性，那么必須給屬性賦值界牡。（除非該屬性使用default指定了默認(rèn)值簿寂。）
    /*@MyAnnotation
    public void doSome(){

    }*/

    //@MyAnnotation(屬性名=屬性值,屬性名=屬性值,屬性名=屬性值)
    //指定name屬性的值就好了。
    @MyAnnotation(name = "zhangsan", color = "紅色")
    public void doSome(){

    }

}

如果一個(gè)注解的屬性的名字是value并且只有一個(gè)屬性的話宿亡，在使用的時(shí)候常遂，該屬性名可以省略。

public @interface MyAnnotation {

    /*
    指定一個(gè)value屬性挽荠。
     */
    String value();

    //String email();
}

/*
如果一個(gè)注解的屬性的名字是value克胳，并且只有一個(gè)屬性的話，在使用的時(shí)候坤按，該屬性名可以省略毯欣。
 */
public class MyAnnotationTest {

    // 報(bào)錯(cuò)原因：沒(méi)有指定屬性的值。
    /*@MyAnnotation
    public void doSome(){

    }*/

    @MyAnnotation(value = "hehe")
    public void doSome(){

    }

    @MyAnnotation("haha")
    public void doOther(){

    }
}

注解當(dāng)中的屬性

注解當(dāng)中的屬性可以是什么類(lèi)型臭脓？
屬性的類(lèi)型可以是：byte short int long float double boolean char String Class 枚舉類(lèi)型（enum）
以及以上每一種的數(shù)組形式酗钞。

public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER
}

public @interface OtherAnnotation {
    /*
    年齡屬性
     */
    int age();

    /*
    郵箱地址屬性，支持多個(gè)
     */
    String[] email();

    /**
     * 季節(jié)數(shù)組来累，Season是枚舉類(lèi)型
     * @return
     */
    Season[] seasonArray();
}

public class OtherAnnotationTest {

    // 數(shù)組是大括號(hào)
    @OtherAnnotation(age = 25, email = {"zhangsan@123.com", "zhangsan@sohu.com"}, seasonArray = Season.WINTER)
    public void doSome(){

    }

    // 如果數(shù)組中只有1個(gè)元素：大括號(hào)可以省略砚作。
    @OtherAnnotation(age = 25, email = "zhangsan@123.com", seasonArray = {Season.SPRING, Season.SUMMER})
    public void doOther(){

    }

}

反射注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//只允許該注解可以標(biāo)注類(lèi)、方法
@Target({ElementType.TYPE, ElementType.METHOD})
// 希望這個(gè)注解可以被反射
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

    /*
    value屬性嘹锁。
     */
    String value() default "北京大興區(qū)";
}

@MyAnnotation("上海浦東區(qū)")
public class MyAnnotationTest {

    //@MyAnnotation
    int i;

    //@MyAnnotation
    public MyAnnotationTest(){

    }

    @MyAnnotation
    public void doSome(){

        //@MyAnnotation
        int i;
    }

}

public class ReflectAnnotationTest {
    public static void main(String[] args) throws Exception{
        // 獲取這個(gè)類(lèi)
        Class c = Class.forName("MyAnnotationTest");
        // 判斷類(lèi)上面是否有@MyAnnotation
        //System.out.println(c.isAnnotationPresent(MyAnnotation.class)); // true
        if(c.isAnnotationPresent(MyAnnotation.class)){
            // 獲取該注解對(duì)象
            MyAnnotation myAnnotation = (MyAnnotation)c.getAnnotation(MyAnnotation.class);
            //System.out.println("類(lèi)上面的注解對(duì)象" + myAnnotation); 
            // 獲取注解對(duì)象的屬性怎么辦葫录？和調(diào)接口沒(méi)區(qū)別。
            String value = myAnnotation.value();
            System.out.println(value);
        }

        // 判斷String類(lèi)上面是否存在這個(gè)注解
        Class stringClass = Class.forName("java.lang.String");
        System.out.println(stringClass.isAnnotationPresent(MyAnnotation.class)); // false
    }
}

通過(guò)反射獲取注解對(duì)象的屬性的值

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {

    /*
    username屬性
     */
    String username();

    /*
    password屬性
     */
    String password();
}

import java.lang.reflect.Method;

public class MyAnnotationTest {

    @MyAnnotation(username = "admin", password = "456456")
    public void doSome(){

    }

    public static void main(String[] args) throws Exception{
        // 獲取MyAnnotationTest的doSome()方法上面的注解信息领猾。
        Class c = Class.forName("com.bjpowernode.java.annotation6.MyAnnotationTest");
        // 獲取doSome()方法
        Method doSomeMethod = c.getDeclaredMethod("doSome");
        // 判斷該方法上是否存在這個(gè)注解
        if(doSomeMethod.isAnnotationPresent(MyAnnotation.class)) {
            MyAnnotation myAnnotation = doSomeMethod.getAnnotation(MyAnnotation.class);
            System.out.println(myAnnotation.username());
            System.out.println(myAnnotation.password());
        }
    }

}

注解在開(kāi)發(fā)中有什么用米同？

注解在程序當(dāng)中等同于一種標(biāo)記。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 表示這個(gè)注解只能出現(xiàn)在類(lèi)上面
@Target(ElementType.TYPE)
// 該注解可以被反射機(jī)制讀取到
@Retention(RetentionPolicy.RUNTIME)
public @interface MustHasIdPropertyAnnotation {

}

// 這個(gè)注解@Id用來(lái)標(biāo)注類(lèi)摔竿，被標(biāo)注的類(lèi)中必須有一個(gè)int類(lèi)型的id屬性面粮，沒(méi)有就報(bào)異常。

@MustHasIdPropertyAnnotation
public class User {
    int id;
    String name;
    String password;
}

/*
自定義異常
 */
public class HasNotIdPropertyException extends RuntimeException {
    public HasNotIdPropertyException(){

    }
    public HasNotIdPropertyException(String s){
        super(s);
    }
}

import java.lang.reflect.Field;

public class Test {
    public static void main(String[] args) throws Exception{
        // 獲取類(lèi)
        Class userClass = Class.forName("com.bjpowernode.java.annotation7.User");
        // 判斷類(lèi)上是否存在Id注解
        if(userClass.isAnnotationPresent(MustHasIdPropertyAnnotation.class)){
            // 當(dāng)一個(gè)類(lèi)上面有@MustHasIdPropertyAnnotation注解的時(shí)候继低，要求類(lèi)中必須存在int類(lèi)型的id屬性
            // 如果沒(méi)有int類(lèi)型的id屬性則報(bào)異常熬苍。
            // 獲取類(lèi)的屬性
            Field[] fields = userClass.getDeclaredFields();
            boolean isOk = false; // 給一個(gè)默認(rèn)的標(biāo)記
            for(Field field : fields){
                if("id".equals(field.getName()) && "int".equals(field.getType().getSimpleName())){
                    // 表示這個(gè)類(lèi)是合法的類(lèi)。有@Id注解，則這個(gè)類(lèi)中必須有int類(lèi)型的id
                    isOk = true; // 表示合法
                    break;
                }
            }

            // 判斷是否合法
            if(!isOk){
                throw new HasNotIdPropertyException("被@MustHasIdPropertyAnnotation注解標(biāo)注的類(lèi)中必須要有一個(gè)int類(lèi)型的id屬性柴底！");
            }

        }
    }
}