精华内容
下载资源
问答
  • 获取方法的某个参数的属性的(返回值类型不确定,需要的参数在对象中位置不确定) #2)举例         需求:记录操作日志,保存用户删除订单、购买物品等操作  &...

    1:作用

           1. 获取方法的某个参数的属性的值(返回值类型不确定,需要的参数在对象中位置不确定)

    2:举例

            需求:记录操作日志,保存用户删除订单、购买物品等操作

        2.1:注解

    /**
    * 保存记录开关
    * @Auther: ZhangSuchao
    * @Date: 2020/7/29 21:02
    */
    @Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface SaveLog {
    
      // 获取的订单(物品)的id集合
      String idsName() default "";
    
      // 操作类型
      int operatorKind() default 0;
    
      // 操作理由(可以记录一些删除原因,驳回原因)
      String remarkName() default "";
    }
    

        2.2:请求实体类

    import lombok.Data;
    
    /**
    * @Auther: ZhangSuchao
    * @Date: 2020/7/29 20:02
    */
    @Data
    public class OrderDTO {
    
       // 订单s
       private Integer ids;
    
       // 原因
       private String remark;
    }
    

        2.3:Service方法

        /**
         * 删除订单
         *
         * @param orderDTO
         */
        @SaveLog(idsName = "orderDTO-ids", remarkName = "orderDTO-remark", operatorKind = 1)
        public void delOrders(OrderDTO orderDTO) {
    
            // TODO: 2020/7/29 删除订单操作
        }
    
        /**
         * 购买物品
         *
         * @param orderId 订单id
         */
        @SaveLog(idsName = "orderId", operatorKind = 2)
        public void buyGoods(Integer orderId) {
            // TODO: 2020/7/29 购买物品
        }
    

        2.4:目的

    获取2.3中 delOrders 方法的 ids与 remark,也要获取 buyGoods 中的 orderId

    3: 切面

    /**
     * 日志切面
     *
     * @Auther: ZhangSuchao
     * @Date: 2020/7/29 19:38
     */
    @Aspect
    @Component
    public class LogAspect {
    
        @Pointcut(value = "@annotation(com.draymond.aop.annotation.SaveLog)")
        public void logPoint() {
    
        }
    
        @AfterReturning(value = "logPoint()")
        public void saveLog(JoinPoint joinPoint) {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            SaveLog saveLog = method.getAnnotation(SaveLog.class);
            if (saveLog == null) {
                return;
            }
            // 获取参数名称
            String[] paraNames = signature.getParameterNames();
            // 参数的值
            Object[] paraValues = joinPoint.getArgs();
    
            // 警告:idsName对应的值可能为Integer,也可能为List<Integer>
            String idsName = saveLog.idsName();
            int operatorKind = saveLog.operatorKind();
            String remarkName = saveLog.remarkName();
    
            // 获取到了Integer/List<Integer> 备注:如果 idsName 只表示一种类型,也可以用具体的类型接收(泛型的强大之处)
            Object object = ReflectUtils.getValueByParaName(idsName, paraNames, paraValues);
    
            // 获取到了String
            String remark = ReflectUtils.getValueByParaName(idsName, paraNames, paraValues);
    
    
            //  获取到了 对象中的集合
            List<Integer> idsList = ReflectUtils.parse2IntList(object);
            // todo 做一些保存操作的记录
        }
    }
    

    4:反射工具类

    此处用了泛型,接收参数的值是通用的
    package com.draymond.aop.spring.aspect;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 反射工具类
     *
     * @Auther: ZhangSuchao
     * @Date: 2020/7/29 20:18
     */
    public class ReflectUtils {
    
    
        /**
         * 根据 idsName 从 paraValues获取对应索引处的值
         *
         * @param paraName
         * @param paraNames
         * @param paraValues
         * @param <T>
         * @return
         */
        public static <T> T getValueByParaName(String paraName, String[] paraNames, Object[] paraValues) {
    
            String[] paraNameSplit = paraName.split("-");
            int paraNameLength = paraNameSplit.length;
            if (paraNameSplit.length == 0) {
                return null;
            }
    
            // 获取第一个的值(orderDTO-ids中获取orderDTO的值)
            int index = ReflectUtils.getIndex(paraNameSplit[0], paraNames);
    
            if (index < 0) {
                return null;
            }
            Object object = ReflectUtils.getValue(index, paraValues);
    
            Object tempObj = object;
    
            try {
    
    
                for (int i = 0; i < paraNameLength - 1; i++) {
    
                    Class<?> clz = object.getClass();
                    Field paraField = clz.getDeclaredField(paraNameSplit[i + 1]);
                    paraField.setAccessible(true);
    
                    // Integet String...非集合类型
                    if (Integer.class.isAssignableFrom(paraField.getType()) || String.class.isAssignableFrom(paraField.getType())) {
                        tempObj = paraField.get(object);
                    }
                    // 集合类型
                    else if (List.class.isAssignableFrom(paraField.getType())) {
                        tempObj = ReflectUtils.getList(paraField, tempObj);
    
                    }
    
                }
    
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
            return (T) tempObj;
        }
    
        /**
         * 反射获取list数据
         *
         * @param paraField 要获取值的属性名
         * @param tempObj   值源
         * @param <T>
         * @return
         */
        /**
         * 反射获取对象中的list数据
         *
         * @param object
         */
        public static <T> List<T> getList(Field field, Object object) {
            List<T> resultList = new ArrayList<>();
            if (object != null) {
                try {
                    Class clzz = field.get(object).getClass();
                    //反射调用获取到list的size方法来获取到集合的大小
                    Method sizeMethod = clzz.getDeclaredMethod("size");
                    if (!sizeMethod.isAccessible()) {
                        sizeMethod.setAccessible(true);
                    }
                    //集合长度
                    int size = (int) sizeMethod.invoke(field.get(object));
                    //循环遍历获取到数据
                    for (int i = 0; i < size; i++) {
                        //反射获取到list的get方法
                        Method getMethod = clzz.getDeclaredMethod("get", int.class);
                        //调用get方法获取数据
                        if (!getMethod.isAccessible()) {
                            getMethod.setAccessible(true);
                        }
    
                        Object invoke = getMethod.invoke(field.get(object), i);
                        T var1 = (T) invoke;
                        resultList.add(var1);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return resultList;
        }
    
        /**
         * 获取索引处的值
         *
         * @param index
         * @param paraValues
         * @return
         */
        private static Object getValue(int index, Object[] paraValues) {
            return (index >= 0 && paraValues.length > index) ? paraValues[index] : null;
        }
    
        /**
         * 获取 paraName 在 paraNames 中的索引位置
         *
         * @param paraName
         * @param paraNames
         * @return
         */
        private static int getIndex(String paraName, String[] paraNames) {
    
            for (int i = 0; i < paraNames.length; i++) {
                if (paraName.equals(paraNames[i])) {
                    return i;
                }
            }
            return -1;
    
        }
    
        /**
         * 将object转换成List<Integer>
         *
         * @param object
         * @return
         */
        public static List<Integer> parse2IntList(Object object) {
            List<Integer> list = new ArrayList<>();
    
            if (object instanceof Integer) {
                list.add((Integer) object);
            } else if (object instanceof List) {
                // 此处要确保 object 是List<Integer> 否则类型转换异常
                list = (List) object;
            }
            return list;
        }
    }
    

    #备注:

    优点
    1. 利用反射可以获取任何对象中的属性值,不论属性的位置多深(通过遍历获取的值:orderDTO-ids,获取ids的值)
    2. 使用泛型,获取值的结果类型可根据实际情况变化
      ######缺点:
      list之呢个在最后获取,如果list在中间层则需要进一步处理
    3.重点方法(都使用泛型)

    获取参数对应的值
    public static <T> T getValueByParaName(String paraName, String[] paraNames, Object[] paraValues)
    获取list
    public static <T> List<T> getList(Field field, Object object)

    展开全文
  • 一个简单类的例子在这个类中,有普通的String类型,有数组类型,有带泛型的List类型,有嵌套List类型,以及有多个泛型参数的简单类,这个类将作为我们后面的内容的基础。我们这一次博客解析如何使用反射获取到不同...

    一个简单类的例子

    在这个类中,有普通的String类型,有数组类型,有带泛型的List类型,有嵌套List类型,以及有多个泛型参数的简单类,这个类将作为我们后面的内容的基础。我们这一次博客解析如何使用反射获取到不同属性的类型值。

    public class Some{

    private String name;

    private Integer[] numbers;

    private List list;

    private List> matrix;

    private Map map;

    //ignore getter and setter

    }

    分析如何获取不同属性的类型

    1、普通类型

    普通类型的变量直接field.getType()即可以获取到他们的类型

    public void queryNameType() throws NoSuchFieldException {

    Field field = Some.class.getDeclaredField("name");

    Class> type = field.getType();

    assertEquals(type,String.class);

    }

    2、数组类型

    数组类型不像其他的类型可以通过isAssignableFrom()函数来进行判断,他需要使用isArray() 来判断该type是否是一个数组类型,然后使用getComponentType() 获取他的元素的类型

    public void queryArrayType() throws NoSuchFieldException {

    Field field = Some.class.getDeclaredField("numbers");

    Class> type = field.getType();

    //一般来说,判断是否是某种类型是可以使用isAssignableFrom

    // 判断是否是数组类型比较特殊,要使用isArray()这个函数

    if (type.isArray()){

    //获得数组的类型,使用getComponentType()这个方法

    Class> componentType = type.getComponentType();

    assertEquals(componentType,Integer.class);

    }

    else{

    throw new IllegalStateException();

    }

    }

    3、带泛型的类型

    带泛型的类型就是类似于List这样的类型,我们现在的任务就是获取到String这个类型。

    ParameterizedType表示参数化的类型,例如Collection这样的类型。我们可以通过getGenericType()方法获得该子类,当你的类型带有参数的时候就会返回ParameterizedType,否则会返回普通的类型(class)

    那么具体是怎么操作的呢?

    以获得List的类型为例子

    public void getListType() throws NoSuchFieldException {

    Field field = Some.class.getDeclaredField("list");

    //如果类似于List这样的类型就是一种GenericType

    //注意这是一种Type类型

    Type type = field.getGenericType();

    if (type instanceof ParameterizedType){

    //泛型参数类型

    ParameterizedType parameterizedType = (ParameterizedType)type;

    Type[] actualTypes = parameterizedType.getActualTypeArguments();

    //因为List获得第一个泛型参数,因为只有一个,我们取第一个

    //如果我们有多个泛型参数,我们可以根据顺序取不同的泛型参数

    assertEquals(actualTypes[0],String.class);

    //如果获得List这个原始类型呢?

    assertEquals(parameterizedType.getRawType(),List.class);

    }else{

    throw new IllegalStateException();

    }

    }

    4、复杂的嵌套类型

    假如是List> 如何获得最里面的类型呢?

    例子如下

    public void getSubListType() throws NoSuchFieldException {

    //思考一下,如果我们有一个嵌套List,我们想拿到嵌套在最里面的类型,那么我们可以这么做呢?

    //其实我们可以使用递归的思想去获得最里面的类型

    Field field = Some.class.getDeclaredField("matrix");

    assertEquals(getBaseType(field.getGenericType()),Double.class);

    }

    public static Type getBaseType(Type genericReturnType){

    Objects.requireNonNull(genericReturnType);

    if (genericReturnType instanceof ParameterizedType &&

    List.class.isAssignableFrom((Class)(((ParameterizedType) genericReturnType).getRawType()))){

    Type[] actualTypeArguments = ((ParameterizedType)genericReturnType).getActualTypeArguments();

    Type type = actualTypeArguments[0];

    return getBaseType(type);

    }else{

    return genericReturnType;

    }

    }

    5、多个泛型参数

    与第三个例子相似,只需要使用actualTypes数组按顺序取即可

    例子如下

    public void getMapType() throws NoSuchFieldException {

    Field field = Some.class.getDeclaredField("map");

    Type type = field.getGenericType();

    if (type instanceof ParameterizedType){

    ParameterizedType parameterizedType = (ParameterizedType)type;

    Type[] actualTypes = parameterizedType.getActualTypeArguments();

    assertEquals(actualTypes[0],String.class);

    assertEquals(actualTypes[1],Class.class);

    }else{

    throw new IllegalStateException();

    }

    }

    总结

    以上总结了几种常用的使用反射获取属性类型的例子,稍加改造就可以写自己的工具类了。希望对大家有帮助^_^

    展开全文
  • Java-使用反射获取类型信息

    千次阅读 2018-09-18 19:30:33
    Java中如何使用反射获取类型信息?Java中如何使用反射获取类型信息?一个简单类的例子分析如何获取不同属性的类型1、普通类型2、数组类型3、带...在这个类中,有普通的String类型,有数组类型,有带泛型的List类型...

    Java中如何使用反射获取类型信息?

    最近写了大量需要根据类属性的类型反射注入值的代码,总结了以下常用的反射技巧:

    一个简单类的例子

    在这个类中,有普通的String类型,有数组类型,有带泛型的List类型,有嵌套List类型,以及有多个泛型参数的简单类,这个类将作为我们后面的内容的基础。我们这一次博客解析如何使用反射获取到不同属性的类型值。

    public class Some{
        private String name;
        private Integer[] numbers;
        private List<String> list;
        private List<List<Double>> matrix;
        private Map<String,Class> map;
        
        //ignore getter and setter
    }
    

    分析如何获取不同属性的类型

    1、普通类型

    普通类型的变量直接field.getType()即可以获取到他们的类型

    public void queryNameType() throws NoSuchFieldException {
        Field field = Some.class.getDeclaredField("name");
        Class<?> type = field.getType();
        assertEquals(type,String.class);
    }
    

    2、数组类型

    数组类型不像其他的类型可以通过isAssignableFrom()函数来进行判断,他需要使用isArray() 来判断该type是否是一个数组类型,然后使用getComponentType() 获取他的元素的类型

    public void queryArrayType() throws NoSuchFieldException {
        Field field = Some.class.getDeclaredField("numbers");
        Class<?> type = field.getType();
        //一般来说,判断是否是某种类型是可以使用isAssignableFrom
        // 判断是否是数组类型比较特殊,要使用isArray()这个函数
        if (type.isArray()){
            //获得数组的类型,使用getComponentType()这个方法
            Class<?> componentType = type.getComponentType();
            assertEquals(componentType,Integer.class);
        }
        else{
            throw new IllegalStateException();
        }
    }
    

    3、带泛型的类型

    带泛型的类型就是类似于List<String>这样的类型,我们现在的任务就是获取到String这个类型。
    ParameterizedType表示参数化的类型,例如Collection这样的类型。我们可以通过getGenericType()方法获得该子类,当你的类型带有参数的时候就会返回ParameterizedType,否则会返回普通的类型(class)
    那么具体是怎么操作的呢?
    以获得List<T>的类型为例子

    public void getListType() throws NoSuchFieldException {
        Field field = Some.class.getDeclaredField("list");
        //如果类似于List<String>这样的类型就是一种GenericType
        //注意这是一种Type类型
        Type type = field.getGenericType();
        if (type instanceof ParameterizedType){
            //泛型参数类型
            ParameterizedType parameterizedType = (ParameterizedType)type;
            Type[] actualTypes = parameterizedType.getActualTypeArguments();
            //因为List<String>获得第一个泛型参数,因为只有一个,我们取第一个
            //如果我们有多个泛型参数,我们可以根据顺序取不同的泛型参数
            assertEquals(actualTypes[0],String.class);
            //如果获得List这个原始类型呢?
            assertEquals(parameterizedType.getRawType(),List.class);
        }else{
            throw new IllegalStateException();
        }
    }
    

    4、复杂的嵌套类型

    假如是List<List<String>> 如何获得最里面的类型呢?
    例子如下

    public void getSubListType() throws NoSuchFieldException {
    		//思考一下,如果我们有一个嵌套List,我们想拿到嵌套在最里面的类型,那么我们可以这么做呢?
    		//其实我们可以使用递归的思想去获得最里面的类型
    		Field field = Some.class.getDeclaredField("matrix");
    		assertEquals(getBaseType(field.getGenericType()),Double.class);
    	}
    
    	public static Type getBaseType(Type genericReturnType){
    		Objects.requireNonNull(genericReturnType);
    		if (genericReturnType instanceof ParameterizedType &&
    				List.class.isAssignableFrom((Class)(((ParameterizedType) genericReturnType).getRawType()))){
    			Type[] actualTypeArguments = ((ParameterizedType)genericReturnType).getActualTypeArguments();
    			Type type = actualTypeArguments[0];
    			return getBaseType(type);
    		}else{
    			return genericReturnType;
    		}
    	}
    
    

    5、多个泛型参数

    与第三个例子相似,只需要使用actualTypes数组按顺序取即可
    例子如下

    public void getMapType() throws NoSuchFieldException {
        Field field = Some.class.getDeclaredField("map");
        Type type = field.getGenericType();
        if (type instanceof ParameterizedType){
            ParameterizedType parameterizedType = (ParameterizedType)type;
            Type[] actualTypes = parameterizedType.getActualTypeArguments();
            assertEquals(actualTypes[0],String.class);
            assertEquals(actualTypes[1],Class.class);
        }else{
            throw new IllegalStateException();
        }
    }
    

    总结

    以上总结了几种常用的使用反射获取属性类型的例子,稍加改造就可以写自己的工具类了。希望对大家有帮助^_^

    展开全文
  • stream流使用filter可以做到过滤筛选作用,本测试基于现有的筛选功能做了点...遍历反射获取到的所有方法,如果传入了参数,通过get方法可以获取到一个非空的(查询参数对象queryParam里面的基本数据类型都需要转换...

    stream流使用filter可以做到过滤筛选作用,本测试基于现有的筛选功能做了点修改,根据传入的参数可以实现动态的过滤筛选。传入的查询参数对象和集合里的对象可以不一样,但字段需要一致。

    主要步骤:

    1.利用反射获取查询参数queryParam对象的说所有方法

    2.遍历反射获取到的所有方法,如果传入了参数,通过get方法可以获取到一个非空的值(查询参数对象queryParam里面的基本数据类型都需要转换为对应的封装类型,如int -> Integer,否则会有默认值为0,不好判断该值是否传入的值)

    3.通过Method的invoke执行对象的目标方法获取传入查询参数的值

    4.在stream().filter方法里面遍历每一条记录时,再调用Method的invoke方法获取每一条记录对应的值,然后比对外面获取到查询参数的对象与该对象是否相等

    具体实现:

    接口创建了4个Person对象

    @RequestMapping(value = "/auth/test/selectTest",method = {RequestMethod.GET, RequestMethod.POST})

    public Object selectTest(Person queryParam){

    List list = new ArrayList<>();

    Person person1 = new Person(1L,"路飞",20);

    Person person2 = new Person(2L,"路飞",21);

    Person person3 = new Person(3L,"索隆",20);

    Person person4 = new Person(4L,"娜美",20);

    list.add(person1);

    list.add(person2);

    list.add(person3);

    list.add(person4);

    long startTime = System.currentTimeMillis();

    try{

    list = screen(list,queryParam);

    }catch (Exception e){

    logger.info("处理异常");

    }

    long endTime = System.currentTimeMillis();

    Object obj= JSONObject.toJSON(list);

    logger.info("所需时间:{}",endTime-startTime);

    return obj;

    }

    /**

    * @param list 需要筛选的集合

    * @param queryParam 筛选参数

    * @return

    */

    public List screen(List list,Person queryParam) throws Exception {

    Method[] methods = queryParam.getClass().getMethods();

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

    String get = methods[i].getName();

    /**传入的参数可以通过get方法获取,过滤掉非get方法*/

    if(!get.startsWith("get")){

    continue;

    }

    Object obj2 = queryParam.getClass().getMethod(get).invoke(queryParam);

    /**过滤掉没有传入的查询参数*/

    if(ObjectUtil.isNull(obj2)){

    continue;

    }

    list = list.stream().filter(item -> {

    boolean check = false;

    try {

    Object obj1 = item.getClass().getMethod(get).invoke(item);

    /**查看返回的对象是否同一个*/

    check = ObjectUtil.equal(obj1,obj2);

    } catch (Exception e) {

    e.printStackTrace();

    }

    return check;

    }).collect(Collectors.toList());

    }

    return list;

    }

    Person对象

    package com.example.demo.entity;

    import java.io.Serializable;

    /**

    * @author 小豆芽

    * @version 1.0

    * @Date 2020-12-09 10:11

    */

    public class Person implements Serializable {

    private Long id;

    private String name;

    private Integer age;

    public Person() {}

    public Person(Long id, String name, Integer age) {

    this.id = id;

    this.name = name;

    this.age = age;

    }

    public Long getId() {

    return id;

    }

    public void setId(Long id) {

    this.id = id;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    public Integer getAge() {

    return age;

    }

    public void setAge(Integer age) {

    this.age = age;

    }

    }

    测试结果,传入name筛选出路飞

    cfafcdd151af3a665744a3b6e842feb8.png

    传入name和age,筛选出21岁的路飞

    05e79c5081af4888f891237f77ba82db.png

    上面的例子可以筛选了,接下来对接口数据做一下修改,测试耗时,创建20万条数据

    @RequestMapping(value = "/auth/test/selectTest",method = {RequestMethod.GET, RequestMethod.POST})

    public Object selectTest(Person queryParam){

    List list = new ArrayList<>();

    Person person1 = new Person(1L,"路飞",20);

    Person person2 = new Person(2L,"路飞",21);

    Person person3 = new Person(3L,"索隆",20);

    Person person4 = new Person(4L,"娜美",20);

    list.add(person1);

    list.add(person2);

    list.add(person3);

    list.add(person4);

    /**创建20万条数据*/

    for (int i = 5; i < 200000; i++) {

    Person person = new Person((long) i,"路飞",20);

    list.add(person);

    }

    long startTime = System.currentTimeMillis();

    try{

    list = screen(list,queryParam);

    }catch (Exception e){

    logger.info("处理异常");

    }

    long endTime = System.currentTimeMillis();

    Object obj= JSONObject.toJSON(list);

    logger.info("所需时间:{}",endTime-startTime);

    return obj;

    }

    测试结果,20万条数据处理结果大概250毫秒左右

    d69f2127a707a7c391d381bb144a3cb8.png

    测试200万条数据时需要2.5秒左右,当然如果数据量太大的话内存也是会溢出的。

    本测试用例只能做一个简单的动态筛选,还有很多场景还没考虑到,这里只做一个参考

    展开全文
  • 如上代码所示,我用反射跳过编译器,获取擦除参数类型后生成的 字节码中的方法add(Object o) 向Integer类型的ArrayList添加String类型是可行的。 疑问是,当我遍历get的时候,为什么取出添加的String不报类型...
  • // 反射获取对象成员的字段 tempStr = rs.getObject(field.getName()); } catch (SQLException e) { tempStr = ""; } // 置是否允许访问,而不是修改原来的访问权限修饰词 ...
  • 一、动态实例化类 使用反射机制动态实例化类。下面函数是获取参数,实例化之后储存在Map里 public static void dynamicConstruct(Map classList, Object targetClass, DataInput data){ ... //构造函数参数值
  • 关于Java泛型反射问题

    2015-09-03 01:12:22
    * 我们通过反射可以获取list的add方法给col2存储其他类型的数据。如这里就可以将“abc”存放到col2中 * 不明白这里为什么参数一定要是Object.class,不能改为String.class */ try { col2.getClass()....
  • Constructor constructor = clazz.getConstructor(Class 参数字节码)根据参数类型获取public修饰的指定的的构造方法 Constructor constructor = clazz.getDeclearConstructor(Class 参数字节码) 获取任意...
  • // 反射获取对象成员的字段 tempStr = rs.getObject(field.getName()); } catch (SQLException e) { tempStr = ""; } // 置是否允许访问,而不是修改原来的访问权限...
  • 一、参数为集合  Q:parameterType指的的类型是集合类型还是对象?  A:都可以,甚至不用在xml中指定也可以。...属性】 这样的格式,通过反射获取和注入属性,传入的参数为集合的时候,不管指定parameterType...
  • getAppSignatureSHA256 : 获取应用签名的的 SHA256 getAppSignatureMD5 : 获取应用签名的的 MD5 getAppInfo : 获取 App 信息 getAppsInfo : 获取所有已安装 App 信息 关于数组的各种排序算法 -> ...
  • C#本质论(第3版)

    2012-07-17 18:07:03
    5.6.8 属性和方法调用不允许作为ref或out参数值使用 5.7 构造器 5.7.1 构造器的声明 5.7.2 默认构造器 5.7.3 对象初始化器 5.7.4 构造器的重载 5.7.5 使用this调用另一个构造器 5.8 静态成员 5.8.1 静态...
  • 类型是有限制的,只能是以下几种: 8种基本数据类型 String Class Enum Annotation 以及他们的数组 多注释:每个之间用逗号隔开 四种元注释:java.lang....
  • 5.6.8 属性和方法调用不允许作为ref或out参数值使用 163 5.7 构造器 164 5.7.1 构造器的声明 164 5.7.2 默认构造器 165 5.7.3 对象初始化器 166 5.7.4 构造器的重载 167 5.7.5 构造器链:...
  • 由于工作时间比较紧张,所以source code只看了一点,还是有点疑惑,如果说是用的类反射机制,那么参数只需要用一个object参数就能知道该类是什么类型了么。 今天工作完了回家好好研究,也希望高手能给予指点,谢过...
  • 10.3.2 具体化类型参数 262 10.4 设定类型形参的上限 263 10.5 本章小结 264 第11章 注解 266 11.1 Kotlin注解入门 267 11.1.1 定义注解 267 11.1.2 注解的属性和构造器 268 11.2 元注解 270 11.2.1 使用@...
  • Java开发技术大全(500个源代码).

    热门讨论 2012-12-02 19:55:48
    listFields.java 利用反射机制获取成员属性列表 listMethods.java 利用反射机制获取成员方法列表 loadClass.java 动态装载一个类 Shape.java 一个用于测试的简单类 useArray1.java 用反射机制使用数组示例1 ...
  • 表2 nCtlColor的类型值与含义 作为一个简单的例子,观察以下的代码: BOOL CUi5Dlg::OnInitDialog() { //… //创建字体 //CFont CUi1View::m_Font1, CUi1View::m_Font2 m_Font1.CreatePointFont(120, "Impact...
  • 疯狂JAVA讲义

    2014-10-17 13:35:01
    学生提问:能不能只分配内存空间,不赋初始呢?89 4.5.4 使用数组 90 学生提问:为什么要我记住这些异常信息? 91 4.5.5 JDK1.5提供了foreach循环 91 4.6 深入数组 93 4.6.1 内存中的数组 93 学生提问:为...
  • //通过反射获取类 Class<?> clazz = Class.forName(objClass.getName()); //获取get方法 Method method = clazz.getMethod("get" + getMethodName(propertiesName)); //获取属性 Field...
  • 1.3.2 相异值类型和引用类型 1.3.3 强数据类型 1.3.4 通过异常处理错误 1.3.5 特性的使用 1.4 程序集 1.4.1 私有程序集 1.4.2 共享程序集 1.4.3 反射 1.5 .NET Framework类 1.6 命名空间 1.7 用C#创建.NET应用程序 ...
  • 1.3.2 相异值类型和引用类型 1.3.3 强数据类型 1.3.4 通过异常处理错误 1.3.5 特性的使用 1.4 程序集 1.4.1 私有程序集 1.4.2 共享程序集 1.4.3 反射 1.5 .NET Framework类 1.6 命名空间 1.7 用C#创建.NET应用程序 ...
  • 1.3.2 相异值类型和引用类型 1.3.3 强数据类型 1.3.4 通过异常处理错误 1.3.5 特性的使用 1.4 程序集 1.4.1 私有程序集 1.4.2 共享程序集 1.4.3 反射 1.5 .NET Framework类 1.6 命名空间 1.7 用C#创建.NET应用程序 ...
  • 1.3.2 相异值类型和引用类型 1.3.3 强数据类型 1.3.4 通过异常处理错误 1.3.5 特性的使用 1.4 程序集 1.4.1 私有程序集 1.4.2 共享程序集 1.4.3 反射 1.5 .NET Framework类 1.6 命名空间 1.7 用C#创建.NET应用程序 ...
  • 1.3.2 相异值类型和引用类型 1.3.3 强数据类型 1.3.4 通过异常处理错误 1.3.5 特性的使用 1.4 程序集 1.4.1 私有程序集 1.4.2 共享程序集 1.4.3 反射 1.5 .NET Framework类 1.6 命名空间 1.7 用C#创建.NET应用程序 ...
  • C#高级编程(第6版)

    2011-05-11 11:10:30
     1.3.2 相异值类型和引用类型  1.3.3 强数据类型  1.3.4 通过异常处理错误  1.3.5 特性的使用  1.4 程序集  1.4.1 私有程序集  1.4.2 共享程序集  1.4.3 反射  1.5 .NET Framework类  1.6 命名空间  1.7 ...
  • C#高级编程(第6版)

    2010-12-17 09:01:41
     1.3.2 相异值类型和引用类型  1.3.3 强数据类型  1.3.4 通过异常处理错误  1.3.5 特性的使用  1.4 程序集  1.4.1 私有程序集  1.4.2 共享程序集  1.4.3 反射  1.5 .NET Framework类  1.6 命名空间  1.7 ...

空空如也

空空如也

1 2 3 4
收藏数 66
精华内容 26
关键字:

反射获取list类型参数值