反射文章的代码

reflection代码

package reflection;

//正常的类加载机制
//引入需要的“包类”名称 》 通过new实例化 》 取得实例化对象
//
//反射的方式
//实例化对象 》 getclass（）方法 》 得到完整的“包类”名称


//优点：可以实现动态创建对象和编译，体现出很大的灵活性
//缺点：对性能有影响，使用反射基本上是一种解释操作，我们可以告诉jvm，我们希望做什么且满足我们的要求，这类操作总是慢于我们直接执行。
public class reflection_1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //方式一：通过反射获取类的class对象
        Class c1 = Class.forName("reflection.user");
        System.out.println(c1);
        Class c2 = Class.forName("reflection.user");
        Class c3 = Class.forName("reflection.user");
        Class c4 = Class.forName("reflection.user");
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());//一个类在内存中只有一个class对象
        //一个类被加载后，类的整个结构都会被封装在class对象中


//       方式2： 类加载的另一种机制
        Class clazz = user.class;

        //方式3：
        Class c5 = c1.getClass();

        //方式4：基本类型的包装类都有一个包装类
        Class c6 = Integer.TYPE;


        //获取父类类型
        Class c7 = c1.getSuperclass();
        System.out.println(c7);
    }
}

class people{
    String single;
    int age;

    public people() {
    }

    public String getSingle() {
        return single;
    }

    public void setSingle(String single) {
        this.single = single;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public people(String single, int age) {
        this.single = single;
        this.age = age;
    }
}

class user extends people{
    private int id;
    private String username;
    private boolean vip;

    public user(int id, String username, boolean vip) {
        this.id = id;
        this.username = username;
        this.vip = vip;
    }

    public user() {
    }

    public int getId() {
        return id;
    }

    public String getUsername() {
        return username;
    }

    public boolean isVip() {
        return vip;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setVip(boolean vip) {
        this.vip = vip;
    }

    @Override
    public String toString() {
        return "user{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", vip=" + vip +
                '}';
    }
}

package reflection;

import java.lang.Class;
import java.lang.annotation.ElementType;
//那些类型可以有class对象
//class：外部类、成员（成员内部类、静态内部类）、局部内部类、匿名内部类
//interface：接口
//【】：数组
//enum：枚举
//annotation:注解@interface
//primitive type：基本数据类型
//void



public class reflection_2 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Object.class;
        Class c2 = Comparable.class;//接口
        Class c3 = String[].class;
        Class c4 = int[][].class;
        Class c5 = Override.class;
        Class c6 = ElementType.class;
        Class c7 = Integer.class;
        Class c8 = void.class;
        Class c9 = Class.class;

        user u1 = new user();
        user u2 = new user();
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

    }
}

package reflection;

/*
反射获取类中的构造方法和方法和属性

 */

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class reflection_3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {

        Class c1 = Class.forName("reflection.user");

        //获取类名
        System.out.println(c1.getName());
        System.out.println(c1.getSimpleName());
        System.out.println("************************************************");

        //获取属性
        Field[] fields = c1.getFields();//只能找到public属性
        for (Field field : fields) {
            System.out.println(field);
        }

        fields = c1.getDeclaredFields();//能获取所有属性名
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("************************************************");

        Field id = c1.getDeclaredField("id");//获取特定属性
        System.out.println(id);
        System.out.println("************************************************");

        //获取构造方法
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        constructors = c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("=====================");
        //获取方法
        Method[] methods = c1.getMethods();//获取所有父类方法和本类的public方法
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("************************************************");
        methods = c1.getDeclaredMethods();//获取本类方法
        for (Method method : methods) {
            System.out.println(method);
        }

        System.out.println("************************************************");

        Method declaredMethod = c1.getDeclaredMethod("getUsername",null);
        System.out.println(declaredMethod);

        Method setUsername = c1.getMethod("setUsername", String.class);//参数是必要的因为重载会导致方法名相同
    }

}

package reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/*
泛型实例化对象执行方法
 */
public class reflection_6 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class c1 = Class.forName("reflection.user");


        //构造方法
//        user u = (user)c1.newInstance();

        //通过构造器创建对象
        Constructor constructor = c1.getConstructor(int.class,String.class,boolean.class);
        user u1 = (user) constructor.newInstance(1,"a",true);
        System.out.println(u1);

        //通过反射获取方法
        Method setId = c1.getDeclaredMethod("setId", int.class);

        //invoke方法激活的意思
        //（对象，方法的值）
        user u = (user)c1.newInstance();
        setId.invoke(u,33);
        System.out.println(u.getId());


        //通过反射操作属性
        user u2 = (user) c1.newInstance();
        Field name = c1.getDeclaredField("username");
        name.setAccessible(true);
        name.set(u2,"hh");
        System.out.println(u2.getUsername());
    }
}