java筆記

java反射

java反射機制是在運作狀态中，對于任意一個類，都能夠知道這個類的所有屬性和方法，

對于任意一個對象，都能夠條用她的任意一個方法和屬性，

這種動态的擷取資訊以及動态調用對象的方法的功能成為java的發射機制

package demo.reflect;

import java.lang.reflect.*;

public class ReflectDemo {

    /**

     * 為了看清楚Java反射部分代碼，所有異常我都最後抛出來給虛拟機處理

     */

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException, NoSuchMethodException {

        System.out.println("demo1：通過Java反射機制得到類的包名和類名");

        demo1();

        System.out.println("");

        System.out.println("demo2：驗證所有的類都是Class類的執行個體對象");

        demo2();

        System.out.println("demo3：通過Java反射機制，用 Class 建立類對象，這也就是反射存在的意義所在");

        demo3();

        System.out.println("demo4：通過Java反射機制得到一個類的構造函數，并實作建立帶參執行個體對象");

        demo4();

        System.out.println("demo5：通過Java反射機制操作成員變量, set 和 get");

        demo5();

        System.out.println("demo6：通過Java反射機制得到類的一些屬性：繼承的接口、父類、函數資訊、成員資訊、類型等");

        demo6();

        System.out.println("demo7：通過Java反射機制調用類方法");

        demo7();

        System.out.println("demo8：通過Java反射機制得到類加載器資訊");

        demo8();

    }

     * demo1：通過Java反射機制得到類的包名和類名

    public static void demo1() {

        Person person = new Person();

        System.out.println("包名：" + person.getClass().getPackage().getName());

        System.out.println("完整類名：" + person.getClass().getName());

     * demo2：驗證所有的類都是Class類的執行個體對象

    public static void demo2() throws ClassNotFoundException {

        //定義兩個類型都未知的Class，設定初值為null，看看如何給它們指派成Person類

        Class<?> class1 = null;

        Class<?> class2 = null;

        //寫法1，可能抛出 ClassNotFoundException 異常，多用這個寫法

        class1 = Class.forName("demo.reflect.Person");

        System.out.println("寫法1，包名：" + class1.getPackage().getName() + " , 完整類名：" + class1.getName());

        //寫法2

        class2 = Person.class;

        System.out.println("寫法2，包名：" + class2.getPackage().getName() + " , 完整類名：" + class2.getName());

     * demo3：通過Java反射機制，用 Class 建立類對象，這也就是反射存在的意義所在

    public static void demo3() throws ClassNotFoundException, InstantiationException, IllegalAccessException {

        //由于這裡不能帶參數，是以你要執行個體化的這個類Person，一定要有無參構造函數

        Person person = (Person) class1.newInstance();

        person.setName("xiaoming");

        person.setAge(20);

        System.out.println(person.getName() + " , " + person.getAge());

     * demo4：通過Java反射機制得到一個類的構造函數，并實作建立帶參執行個體對象

    public static void demo4() throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

        Person person1 = null;

        Person person2 = null;

        Constructor<?>[] constructors = class1.getConstructors();

        person1 = (Person) constructors[0].newInstance();

        person1.setName("xiaoming");

        person1.setAge(20);

        System.out.println(person1.getName() + " , " + person1.getAge());

        person2 = (Person) constructors[1].newInstance(21, "xiaohong");

        System.out.println(person2.getName() + " , " + person2.getAge());

     * demo5：通過Java反射機制操作成員變量, set 和 get

    public static void demo5() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException, SecurityException {

        Class<?> class1 = Class.forName("demo.reflect.Person");

        Object obj = class1.newInstance();

        Field personNameField = class1.getDeclaredField("name");

        personNameField.setAccessible(true); //取消通路檢查

        personNameField.set(obj, "小虎");

        System.out.println("修改屬性之後得到屬性變量的值：" + personNameField.get(obj));

     * demo6：通過Java反射機制得到類的一些屬性：繼承的接口、父類、函數資訊、成員資訊、類型等

    public static void demo6() throws ClassNotFoundException {

        Class<?> class1 = Class.forName("demo.reflect.SuperMan");

        //取得父類名稱

        Class<?> superclass = class1.getSuperclass();

        System.out.println("SuperMan類的父類名：" + superclass.getName());

        Field[] fields = class1.getDeclaredFields();

        for (int i = 0; i < fields.length; i++) {

            System.out.println("類中的成員" + i + "： " + fields[i]);

        }

        //取得類方法

        Method[] methods = class1.getDeclaredMethods();

        for (int i = 0; i < methods.length; i++) {

            System.out.println("取得SuperMan類的方法" + i + "：");

            System.out.println("函數名：" + methods[i].getName());

            System.out.println("函數傳回類型：" + methods[i].getReturnType());

            System.out.println("函數通路修飾符：" + Modifier.toString(methods[i].getModifiers()));

            System.out.println("函數代碼寫法： " + methods[i]);

        //取得類實作的接口，因為接口類也屬于Class，是以得到接口中的方法也是一樣的方法得到哈

        Class<?> interfaces[] = class1.getInterfaces();

        for (int i = 0; i < interfaces.length; i++) {

            System.out.println("實作的接口類名： " + interfaces[i].getName());

     * demo7：通過Java反射機制調用類方法

    public static void demo7() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {

        System.out.println("調用無參方法fly()：");

        Method method = class1.getMethod("fly");

        method.invoke(class1.newInstance());

        System.out.println("調用有參方法walk(int m)：");

        method = class1.getMethod("walk", int.class);

        method.invoke(class1.newInstance(), 100);

     * demo8：通過Java反射機制得到類加載器資訊

     * 在java中有三種類類加載器

     * 1）Bootstrap ClassLoader 此加載器采用c++編寫，一般開發中很少見。

     * 2）Extension ClassLoader 用來進行擴充類的加載，一般對應的是jre\lib\ext目錄中的類

     * 3）AppClassLoader 加載classpath指定的類，是最常用的加載器，同時也是java中預設的加載器。

    public static void demo8() throws ClassNotFoundException {

        String name = class1.getClassLoader().getClass().getName();

        System.out.println("類加載器類名：" + name);

}

class Person {

    private int age;

    private String name;

    public Person() {

    public Person(int age, String name) {

        this.age = age;

        this.name = name;

    public int getAge() {

        return age;

    public void setAge(int age) {

    public String getName() {

        return name;

    public void setName(String name) {

interface ActionInterface {

    public void walk(int m);

class SuperMan extends Person implements ActionInterface {

    private boolean blueBriefs;

    public void fly() {

        System.out.println("超人會飛耶～～");

    public boolean isBlueBriefs() {

        return blueBriefs;

    public void setBlueBriefs(boolean blueBriefs) {

        this.blueBriefs = blueBriefs;

    @Override

    public void walk(int m) {

        System.out.println("超人會走耶～～走了" + m + "米就走不動了！");