反射(二)

通過慄子來更好的理解反射，以及對反射技術進行應用。

首先，整兩個model——car.java和Benz.java

public class Car {
    public String type;
    private String color;


    public static void drive(){
        System.out.println("The car is driving");
    }


}

public class Benz extends Car {
    public String brand;
    private String model;
    private int sale;

    public static String text;

    public Benz() {
    }

    private Benz(String brand) {
        this.brand = brand;
    }

    public Benz(String brand, String model) {
        this.brand = brand;
        this.model = model;
    }

    public int getSale() {
        return sale;
    }

    public String getBrand() {
        return brand;
    }

    public static void desc(){
        System.out.println("這是一輛黑色的賓士車");
    }

    public void getModel(String model){
        System.out.println("這輛賓士車的型號是:"+model);
    }
    private void getColor(){
        System.out.println("這輛車的顏色是黑色");
    }
}

獲取反射類的幾種方法

//1.獲取class對象實例
        //1.1 類名.class
        Class clazz=Car.class;
        //1.2 new一個實體，通過getClass()方法
        Class clazz2=new Car().getClass();
        //1.3 Class.forname()類名全路徑
        try {
            Class clazz3=Class.forName("com.qingmu.reflect.Demo1.Car");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //1.4 通過ClassLoader獲取
        try {
            Class clazz4= Main.class.getClassLoader().loadClass("com.qingmu.reflect.Demo1.Car");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

反射——類的操作

public static void classOpt(){
        Class clazz=Car.class;
        //獲取類的修飾符
        int modifers=clazz.getModifiers();
        System.out.println("類的修飾符："+modifers);
        //獲取類的包名
        Package packag=clazz.getPackage();
        System.out.println("包名:"+packag);
        //獲取類的全路徑名
        String name = clazz.getName();
        System.out.println(name);
        //獲取類名
        String simpleName = clazz.getSimpleName();
        System.out.println(simpleName);
        //獲取類的載入器
        ClassLoader classLoader = clazz.getClassLoader();
        System.out.println(classLoader);
        //獲取類的實現的介面列表
        Class[] interfaces = clazz.getInterfaces();
        System.out.println(interfaces.length);
        //獲取類的父類
        Class superclass = clazz.getSuperclass();
        System.out.println(superclass);
        //獲取類的註解列表
        Annotation[] annotation = clazz.getAnnotations();
        System.out.println(annotation.length);
    }

反射——方法操作

//反射欄位的基本操作
    public static void filedOpt(){
        Class clazz=new Benz().getClass();
        //獲取類中所有的公有欄位 包含繼承
        Field[] fields = clazz.getFields();
        for (Field filed: fields) {
            System.out.println(filed);
        }
        //獲取指定名稱的欄位
        try {
            Field brandField=clazz.getField("brand");   //公有欄位
            System.out.println(brandField.getName());
            Field sale = clazz.getDeclaredField("sale");    //所有類型欄位
            System.out.println(sale.getName());
            int modifiers = brandField.getModifiers();      //獲取欄位的修飾
            System.out.println(modifiers);
            System.out.println(sale.getModifiers());
            //強制訪問私有欄位
            sale.setAccessible(true);
            //成員欄位賦值
            Benz benz= (Benz) clazz.newInstance();
            sale.set(benz,5000000);
            System.out.println(benz.getSale());
            //靜態欄位賦值
            Field textField=clazz.getField("text");
            textField.set(null,"這是一個靜態欄位");
            System.out.println(Benz.text);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        //獲取類中定義的所有欄位 內部
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field filed:declaredFields) {
            System.out.println(filed);
        }
    }

反射——構造器操作

public static void constructorOpt() throws Exception{
        Class clazz=Benz.class;
        Benz benz= (Benz) clazz.newInstance();

        //獲取類中所有的公有構造器
        Constructor[] constructors =clazz.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        //獲取類中所有的構造器
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }

        //獲取類中無參構造器及修飾符
        Constructor declaredConstructor = clazz.getDeclaredConstructor();
        System.out.println(declaredConstructor+"--"+declaredConstructor.getModifiers());

        //獲取類中有參構造器
        Constructor declaredConstructor1 = clazz.getDeclaredConstructor(String.class);
        System.out.println(declaredConstructor1);

        declaredConstructor1.setAccessible(true);
        Benz benz1 = (Benz) declaredConstructor1.newInstance("benz");  //構造器實例對象
        System.out.println(benz1.brand);
    }

最後，要寫一個main方法，調用以上幾個方法，感受一下效果