Java反射获取类所有方法、属性

已于 2023-07-28 11:38:53 修改
阅读量727 收藏
点赞数
分类专栏： # java基础 文章标签： java python 开发语言
于 2023-07-25 16:10:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FLGBgo/article/details/131920329
版权

1、非泛型类、无泛型方法

输出java.lang.Double类所有方法、属性

package com.lf.java.basic.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;

public class ReflectionTest {
    public static void main(String[] args) throws ClassNotFoundException {

        String name;
        if (args.length > 0) {
            name = args[0];
        }

        Scanner in = new Scanner(System.in);
        System.out.println("Enter class name (e.g. java.util.Date): ");
        name = in.next();

        try { // print class name and superclass name (if != Object)
            Class cl = Class.forName(name);
            Class supercl = cl.getSuperclass();
            Class[] interfaces = cl.getInterfaces();
            String modifiers = Modifier.toString(cl.getModifiers());
            if (modifiers.length() > 0) {
                System.out.print(modifiers + " ");
            }
            System.out.print("class " + name);
            if (supercl != null && supercl != Object.class) {
                System.out.print(" extends " + supercl.getName());
            }
            if (interfaces.length > 0) {
                System.out.print(" implements ");
            }
            for (int i = 0; i < interfaces.length; i++) {
                if (i > 0) {
                    System.out.print(", ");
                }
                System.out.print(interfaces[i].getName());
            }
            System.out.print("\n{\n");
            printConstructors(cl);
            System.out.println();
            printMethods(cl);
            System.out.println();
            printFields(cl);
            System.out.println("}");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.exit(0);
    }

    public static void printConstructors(Class cl) {
        {
            Constructor[] constructors = cl.getDeclaredConstructors();

            for (Constructor c : constructors) {
//                 获取当前属性获得的对象
//                Class declaringClass = c.getDeclaringClass();
//                System.out.println(declaringClass.getName());

                String name = c.getName();
                System.out.print(" ");
                String modifiers = Modifier.toString(c.getModifiers());

                if (modifiers.length() > 0) {
                    System.out.print(modifiers + " ");
                }
                System.out.print(name + "(");
                // print parameter types
                Class[] paramTypes = c.getParameterTypes();
                for (int j = 0; j < paramTypes.length; j++) {
                    if (j > 0) {
                        System.out.print(", ");
                    }
                    System.out.print(paramTypes[j].getName());
                }
                System.out.println(") ;");

            }
        }
    }

    public static void printMethods(Class cl) {
        Method[] methods = cl.getDeclaredMethods();
        for (Method m : methods) {
            Class retType = m.getReturnType();
            String name = m.getName();
            System.out.print(" ");
            String modifiers = Modifier.toString(m.getModifiers());
            if (modifiers.length() > 0) {
                System.out.print(modifiers + " ");
            }
            System.out.print(retType.getName() + " " + name + "(");
            Class[] paramTypes = m.getParameterTypes();
            for (int j = 0; j < paramTypes.length; j++) {
                if (j > 0) {
                    System.out.print(",");
                }
                System.out.print(paramTypes[j].getName());
            }
            System.out.println(");");
        }
    }

    public static void printFields(Class cl) {
        Field[] fields = cl.getDeclaredFields();
        for (Field f : fields) {
            Class type = f.getType();
            String name = f.getName();
            System.out.print(" ");
            String modifiers = Modifier.toString(f.getModifiers());
            if (modifiers.length() > 0) {
                System.out.print(modifiers + " ");
                System.out.println(type.getName() + " " + name + ";");
            }
        }
    }

}

运行结果：


Enter class name (e.g. java.util.Date): 
java.lang.Double
public final class java.lang.Double extends java.lang.Number implements java.lang.Comparable
{
 public java.lang.Double(double) ;
 public java.lang.Double(java.lang.String) ;

 public boolean equals(java.lang.Object);
 public static java.lang.String toString(double);
 public java.lang.String toString();
 public int hashCode();
 public static int hashCode(double);
 public static double min(double,double);
 public static double max(double,double);
 public static native long doubleToRawLongBits(double);
 public static long doubleToLongBits(double);
 public static native double longBitsToDouble(long);
 public volatile int compareTo(java.lang.Object);
 public int compareTo(java.lang.Double);
 public byte byteValue();
 public short shortValue();
 public int intValue();
 public long longValue();
 public float floatValue();
 public double doubleValue();
 public static java.lang.Double valueOf(java.lang.String);
 public static java.lang.Double valueOf(double);
 public static java.lang.String toHexString(double);
 public static int compare(double,double);
 public static boolean isNaN(double);
 public boolean isNaN();
 public static boolean isInfinite(double);
 public boolean isInfinite();
 public static boolean isFinite(double);
 public static double sum(double,double);
 public static double parseDouble(java.lang.String);

 public static final double POSITIVE_INFINITY;
 public static final double NEGATIVE_INFINITY;
 public static final double NaN;
 public static final double MAX_VALUE;
 public static final double MIN_NORMAL;
 public static final double MIN_VALUE;
 public static final int MAX_EXPONENT;
 public static final int MIN_EXPONENT;
 public static final int SIZE;
 public static final int BYTES;
 public static final java.lang.Class TYPE;
 private final double value;
 private static final long serialVersionUID;
}

2、泛型类和泛型方法

示例类

package com.lf.java.basic.generic;

import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * 定义泛型类
 *
 * @param <T>
 * @param <U>
 */
@AllArgsConstructor
@NoArgsConstructor
public class Pair<T, U> {
    private T first;
    private U second;

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public U getSecond() {
        return second;
    }

    public void setSecond(U second) {
        this.second = second;
    }

    @Override
    public String toString() {
        return first +":"+ second;
    }

    public static <T> T getFirstPlus(T... a){
        return a[2];
    }

    public static <T> Pair<T,T> getMiddle(T... a) {
        return new Pair<>(a[0],a[1]);
    }

    /**
     * 泛型通配符 子类
     * @param p
     */
    public static void printBuddies(Pair<? extends Comparable,? extends Comparable> p){

    }

    /**
     * 泛型通配符 超类 Object
     */
    public static <T extends Comparable<? super T>> T mini(T[] a){
        return a[0];
    }
    /**
     * 泛型限定,限定具有compareTo的方法的类
     * @param a
     * @param <T>
     * @return
     */
    public static <T extends Comparable & Serializable> T min(T[] a) // almost correct
    { if (a == null || a.length == 0) return null;
        T smallest = a[0];
        for (int i = 1; i < a.length; i++){
            if (smallest.compareTo(a[i]) > 0) smallest = a[i];
        }
        return smallest;
    }

    public static <T> Pair<T, T> makePair(Class<T> cl) {
        try {

            return new Pair<>(cl.newInstance(),cl.newInstance());
        } catch (Exception e) {
            return null;
        }
    }


//    注意Class类本身是泛型。例如，String.daSS是一个Class<String> 的实例
//            (事实上它是唯一的实例 。) 因此，makePair 方法能够推断出 pair 的类型。

    public static void main(String[] args) {
        Pair<String, Integer> p = new Pair();
        p.setFirst("1");
        p.setSecond(2);
        System.out.println(p.toString());

        String [] s ={"s","ss","sss","ssss","sssss"};
        System.out.println(Pair.getFirstPlus(s));
        //泛型向上推断，找出共同超类型为Number类型
        Number firstPlus = Pair.getFirstPlus(3.14, 1729, 0);
        System.out.println(firstPlus);

        Serializable hello = Pair.getFirstPlus("Hello", 0, null);
        System.out.println(hello);

        Integer[] integers = {9,1,2,4,5,7};
        System.out.println(Pair.min(integers));

        //instanceof 和 getClass 只会指向原始类型Pair
//        if (a instanceof Pair<String>) // Error
//        Pair <String> stringPair = . .
//        Pai <Employee> employeePair = . .
//        if (stringPair.getClass() == employeePair.getClass()) // they are equal


//        使用会报错Pair<String>[] table = (Pair<String>[]) new Pair<?>[10];
//        可以使用ArrayList:ArrayList<Pair<String>>

        //这个方法可以按照下列方式调用,获取pair对象:
        Pair<String,String> pair = Pair.makePair(String.class);
        System.out.println(pair.toString());
    }

}

反射类

package com.lf.java.basic.reflect;

import java.lang.reflect.*;
import java.util.Arrays;
import java.util.Scanner;

public class GenericReflectionTest {

    public static void main(String[] args) {

        // read class name from command line args or user input
        String name;
        if (args.length > 0) name = args[0];
        else {
            try (Scanner in = new Scanner(System.in)) {
                System.out.println("Enter class name (e.g. java.util .Collections): ");
                name = in.next();
            }
        }
        try {
            Class<?> cl = Class.forName(name);
            printClass(cl);
            for (Method m : cl.getDeclaredMethods()) {
                printMethod(m);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }


    }

    public static void printClass(Class<?> cl) {
        System.out.print(Modifier.toString(cl.getModifiers())+" "+cl);
        printTypes(cl.getTypeParameters(), "<", ", ", ">", true);
        Type sc = cl.getGenericSuperclass();
        if (sc != null) {
            System.out.print(" extends ");
            printType(sc, false);
        }
        printTypes(cl.getGenericInterfaces(), " implements ", ", ", "", false);
        System.out.println();
    }

    public static void printMethod(Method m) {
        String name = m.getName();
        System.out.print(Modifier.toString(m.getModifiers()));
        System.out.print(" ");
        printTypes(m.getTypeParameters(), "<", ", ", ">", true);
        printType(m.getGenericReturnType(), false);
        System.out.print(" ");
        System.out.print(name);
        System.out.print(" (");
        printTypes(m.getGenericParameterTypes(), "", ", ", "", false);
        System.out.println(")");
    }

    public static void printTypes(Type[] types, String pre, String sep, String suf,
                                  boolean isDefinition) {
        if (pre.equals(" extends ") && Arrays.equals(types, new Type[]{Object.class})) return;
        if (types.length > 0) System.out.print(pre);
        for (int i = 0; i < types.length; i++) {
            if (i > 0) System.out.print(sep);
            printType(types[i], isDefinition);
        }
        if (types.length > 0) System.out.print(suf);
    }

    public static void printType(Type type, boolean isDefinition) {

        if (type instanceof Class) {
            Class<?> t = (Class<?>) type;
            System.out.print(t.getName());
        } else if (type instanceof TypeVariable) {

            TypeVariable<?> t = (TypeVariable<?>) type;
            System.out.print(t.getName());
            if (isDefinition) {
                printTypes(t.getBounds(), " extends ", " & ", "", false);
            }
        } else if (type instanceof WildcardType) {
            WildcardType t = (WildcardType) type;
            System.out.print("?");
            printTypes(t.getUpperBounds(), " extends ", " & ", "", false);
            printTypes(t.getLowerBounds(), " super ", " & ", "", false);
        } else if (type instanceof ParameterizedType) {
            ParameterizedType t = (ParameterizedType) type;
            Type owner = t.getOwnerType();
            if (owner != null) {
                printType(owner, false);
                System.out.println(".");
            }
            printType(t.getRawType(), false);
            printTypes(t.getActualTypeArguments(), "<", ", ", ">", false);
        } else if (type instanceof GenericArrayType) {
            GenericArrayType t = (GenericArrayType) type;
            System.out.print("");
            printType(t.getGenericComponentType(), isDefinition);
            System.out.print("[]");
        }

    }

}

运行结果

Enter class name (e.g. java.util .Collections): 
com.lf.java.basic.generic.Pair
public class com.lf.java.basic.generic.Pair<T, U> extends java.lang.Object
public void setFirst (T)
public static transient <T>T getFirstPlus (T[])
public static transient <T>com.lf.java.basic.generic.Pair<T, T> getMiddle (T[])
public static void printBuddies (com.lf.java.basic.generic.Pair<? extends java.lang.Comparable, ? extends java.lang.Comparable>)
public static <T extends java.lang.Comparable<? super T>>T mini (T[])
public void setSecond (U)
public static <T>com.lf.java.basic.generic.Pair<T, T> makePair (java.lang.Class<T>)
public static void main ([Ljava.lang.String;)
public java.lang.String toString ()
public static <T extends java.lang.Comparable & java.io.Serializable>T min (T[])
public T getFirst ()
public U getSecond ()
FLGB
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
反射获取或修改对象属性的值
weixin_41987908的博客
05-23 657
反射操作
通过反射获取类的属性与方法【Java】
qq_56402474的博客
04-17 8712
通过反射来获取属性与方法
Java通过反射机制获取数据类对象的属性及方法
qwerasdctds的博客
05-19 1万+
2.获取属性的get、set方法。1.遍历类对象的所有属性。
Java反射获取字段属性
热门推荐
nbzhaomao的博客
06-26 1万+
反射getFields与getDeclaredFields区别，getFields(), getDeclaredFields()
反射获取类或对象属性和值
zhang_jiayuan的博客
05-08 1万+
最近在开发过程中，由于部分常量配置在接口而非枚举中，当我们需要通过属性名去获取具体接口中常量对应的值时，或是要获取该接口中所有常量名和对应值的键值对集合，显得有些麻烦或是无从下手，故这里封装一个通用的工具类来满足此类需求（扩展到类和对象中），做以下总结。 大致思路：定义 ReflectObjectUtil 工具类，通过反射获取类或对象信息，并将对应信息组装，按照要求的格...
Java反射获取标准JavaBean属性
star时光的博客
10-20 1314
import java.lang.reflect.Method; public class BeanUtil { /** * 根据标准javaBean对象的属性名获取其属性值 * * @param obj * @param propertyName * @return */ public static Object getValueByPropertyName(Ob
Java反射：获取属性以及属性值
d932385747的博客
02-05 340
需要注意的是，反射机制可能会影响性能，因此在必要时使用，避免过度使用。此外，由于反射操作可能会在编译时无法检测到的问题，因此需要小心处理异常。在Java中，反射机制允许你在运行时获取类的信息并执行操作，包括获取属性及其值。上述示例演示了如何通过反射获取类的所有字段，然后通过字段对象获取属性名和属性值。是设置字段为可访问的重要一步，以便可以获取私有字段的值。
java反射，获取所有属性、方法以及List集合类
10-10
本篇文章将深入探讨如何使用Java反射来获取一个类的所有属性、方法，并处理List集合类。 首先，让我们了解Java反射的基础概念。在Java中，`java.lang.Class`类代表运行时的类信息。我们可以使用`Class.forName()`...
java反射遍历实体类属性和类型,并赋值和获取值的简单方法
08-30
这里我们将深入探讨如何使用Java反射遍历实体类的属性和类型，并进行赋值和获取值的操作。 首先，我们需要理解Java反射的基本概念。`java.lang.reflect`包提供了几个核心类和接口，如`Class`、`Field`、`Method`和`...
Java反射获取私有构造函数、属性、方法
08-10
Java 反射机制获取私有构造函数、属性、方法的原理和应用 Java 反射机制是 Java 语言中最强大和最灵活的机制之一，它允许开发者在运行时动态地获取和操作类的成员变量和方法。其中，获取私有构造函数、属性、方法是...
java反射获取一个object属性值代码解析
08-28
java反射获取一个object属性值代码解析 java反射获取一个object属性值代码解析是java编程中一个非常重要的知识点，通过反射机制，可以动态地获取一个object的属性值，无需提前知道该对象的类型。下面将详细介绍java...
Java通过反射获取类的构造方法、属性、成员方法
最新发布
feng_ling_01的博客
02-29 331
【代码】Java通过反射获取类的构造方法。
java 获取类的所有属性_Java中用反射的方式获取类中的所有属性和方法，以及获取属性的默认值，设置属性的默认值 | 学步园...
weixin_32049849的博客
02-21 547
代码如下：package com.syh.jdbc.reflection_super;/*** 父类* @author syh**/public class Parent {public String publicField = "1";String defaultField = "2";protected String protectedField = "3";private String p...
2020-08-29笔记
wangjunjie_123的博客
08-29 412
第一个：Field Field是一个类,位于java.lang.reflect包下。在Java反射中Field类描述的是类的属性信息，功能包括： 获取当前对象的成员变量的类型 对成员变量重新设值 如何获取Field类对象 一共有4种方法: Class.getFields(): 获取类中public类型的属性，返回一个包含某些 Field 对象的数组，该数组包含此 Class 对象所表示的类或接口的所有可访问公共字段 getDeclaredFields(): 获取类中所有的属性(public、protect
通过java反射机制获取该类的所有属性类型、值
juce的专栏
04-11 602
方法使用了这俩个包下的 field 和method import java.lang.reflect.Field; import java.lang.reflect.Method; public static void getObjectValue(Object object) throws Exception { //我们项目的所有实体类都继承BaseDomain （
java 反射获取对象属性值_Java如何基于反射获取对象属性信息
weixin_42305634的博客
02-12 551
Java如何基于反射获取对象属性信息,属性,对象,四种,建立一个,创建一个Java如何基于反射获取对象属性信息易采站长站，站长之家为您整理了Java如何基于反射获取对象属性信息的相关内容。先建立一个类，有四种属性：private int id;private String name;private byte by;private short st;以下方法，创建一个对象，然后打印该对象的属性名字，...
java获取类中所有属性和值_java 反射，根据类获取 属性名字和值
weixin_33595018的博客
02-26 748
/*** @Author MWZHYF* @Description // 产生对象字段* @Date 15:33 2019/4/25* @Param [obj]* @return java.lang.String[]**/public static String[] generateObjAttr(Object obj) {Class classObj = (Class)obj.getClass(...
通过反射获取属性
rolic_的博客
06-25 1340
/* java.lang.reflect.Field;类中的属性 通过反射获取类中的属性*/import java.lang.reflect.*;public class fuck6{ public static void main(String[] args) throws Exception{ //1.获取整个类 Class c=Class.forName("java.lang.Integ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值