java reflect:反射机制

java reflect:反射机制

1. Class 类型:

java reflect的基础是Class 类,Class 类代表的是 java 源文件通过编译后得到的字节码;

获得 Class 类型 的几种方法:

1. 类名.class

2. 对象名.getClass()

3. Class.forName("类路径")

2. constructor reflect: 构造函数的反射

package cn.wzb.reflect;

import java.lang.reflect.Constructor;
import java.util.HashMap;

/**
 * Created by zhongbo.wzb on 16/7/23.
 */
public class ConstructorReflect {
    public static void main(String[] args) {
        try {

            //获取Integer的Class
            Class<?> clazz = Class.forName("java.lang.Integer");
            System.out.println(clazz.getClass());


            //使用类中参数为String类型的构造器
            Constructor<?> constructor = clazz.getConstructor(String.class);

            //使用构造器创建一个实例对象
            Object obj = constructor.newInstance("10");

            //打印结果
            System.out.println(obj);


            HashMap<String, Integer> a = new HashMap<String, Integer>();
            clazz = a.getClass();

            System.out.println(clazz.getName());
            System.out.println(clazz.getCanonicalName());
            System.out.println(clazz.toString());
            System.out.println(clazz.toGenericString());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. field reflect: 成员变量的反射

package cn.wzb.reflect;

import java.lang.reflect.Field;

/**
 * Created by zhongbo.wzb on 16/7/23.
 */
public class FieldReflect {

    public static void main(String[] args) {
        try {
            //创建一个Person实例对象
            Person person = new FieldReflect().new Person();

            //取得Class
           // Class<?> clazz = person.getClass();
            Class<?> clazz = Person.class;

            /******** 通过反射访问 public 权限的属性变量 ********/
            //取得字段的属性名
            Field age = clazz.getDeclaredField("age");
            //设置该属性的值
            age.set(person, 22);

            /******* 通过反射访问 protected 权限的属性变量 *******/
            Field mail = clazz.getDeclaredField("mail");
            mail.set(person, "wzb12008@sina.com");

            /******** 通过反射访问 private 权限的属性变量 ********/
            Field name = clazz.getDeclaredField("name");

            //private修饰的变量不能直接访问,
            //如需访问必须要将setAccessible的值设置成true,
            //也就是强制访问,或者说是暴力访问
            name.setAccessible(true);
            name.set(person, "zhongbo");

            System.out.println(person);

            Field[] fields = clazz.getFields();
            for (Field f : fields) {
                System.out.println(f.getName());
            }

            System.out.println();
            fields = clazz.getDeclaredFields();
            for (Field f : fields) {
                System.out.println(f.getName());
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }


    //内部类
    public class Person {

        public    int age;
        private   String name;
        protected String mail;

        public int getAge() {
            return age;
        }

        public String getName() {
            return name;
        }

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

        public void setName(String name) {
            this.name = name;
        }

        public String getMail() {
            return mail;
        }

        public void setMail(String mail) {
            this.mail = mail;
        }

        @Override
        public String toString() {

            return "Name is:" + name + ",\t Age is:" + age + ",\t Mail is:" + mail;
        }

    }



}

4. method reflect: 方法的反射

package cn.wzb.reflect;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;

/**
 * Created by zhongbo.wzb on 16/7/23.
 */
public class MethodReflect {
    public static void main(String[] args){

        try {
            //取得Class
            Class<?> clazz = Class.forName("cn.wzb.reflect.MethodReflect");

            MethodReflect instance = new MethodReflect();
            clazz = instance.getClass();

            clazz = MethodReflect.class;

            //取得方法
            Method m = clazz.getDeclaredMethod("print", String.class);

            //调用该方法
            m.invoke(clazz.newInstance(), "fancy");

            Method[] methods =  clazz.getMethods();

            for (Method method : methods) {
                System.out.print(Modifier.toString(method.getModifiers()));
                System.out.print(" ");
                System.out.print(method.getReturnType().getName());
                System.out.print(" ");
                System.out.println(method.getName());
                System.out.println(method.getParameterCount());

                for (Class<?> T: method.getParameterTypes()) {
                    System.out.println(T.getName());
                }

                for (Type T: method.getGenericParameterTypes()) {
                    System.out.println(T.getTypeName());
                }



                Annotation[] annotations = method.getDeclaredAnnotations();
                for (Annotation annotation : annotations) {
                    System.out.println(annotation.getClass().getName());
                }

                System.out.println();

            }



        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void print(int arg){
        System.out.println("Arg is int, value is " + arg);
    }

    public void print(String arg){
        System.out.println("Arg is String, value is " + arg);
    }

}

5. generic reflect:泛型类型的反射(运行时取消泛型)

package cn.wzb.reflect;

import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * Created by zhongbo.wzb on 16/7/23.
 */

/**
 * TOPIC:ArrayList<Integer> list = new ArrayList<Integer>();
 * 在这个泛型为Integer的ArrayList中存放一个String类型的对象。
 */

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

        /**
         * 泛型的类型检查只存在编译期间,运行期间并不存在泛型类型,可以用反射来实现题设要求
         */
        try {
            ArrayList<Integer> list = new ArrayList<Integer>();
            ArrayList<String> list1 = new ArrayList<String>();

            Method add = ArrayList.class.getDeclaredMethod("add", Object.class);
            add.invoke(list, "fancy");

            System.out.println(list.get(0));



            System.out.println(list.getClass().getName());
            System.out.println(list1.getClass().getName());
            System.out.println(list.getClass().equals(list1.getClass()));

            System.out.println(list instanceof ArrayList<?>);
            System.out.println(list1 instanceof ArrayList<?>);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值