反射(二)

通过栗子来更好的理解反射，以及对反射技术进行应用。

首先，整两个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方法，调用以上几个方法，感受一下效果