精华内容
下载资源
问答
  • Java语言中,提供了获取类名的方法:getClass().getName(),开发人员可以调用这个方法获取类名。看下列程序:class A{}public class Test extends A{public void Test(){System.out.println (super.getClass()....

    Java语言中,提供了获取类名的方法:getClass().getName(),开发人员可以调用这个方法来获取类名。

    看下列程序:

    class A{}

    public class Test extends A{

    public void Test(){

    System.out.println (super.getClass().getName());

    }

    public static void main(String[] args){

    new Test().test();

    }

    }

    程序运行的结果为:Test

    主要原因在于Java语言中任何类都是继承自Object类,getClass()方法在Object类中被定义为final与native,子类不能覆盖该方法。因此this.getClass()和super.getClass()最终都调用的是Object中的getClass()方法。而Object的getClass()方法的释义是:返回此Object的运行时类。

    可以通过Java的反射机制,使用getClass().getSuperclass().getName()方法来实现

    class A{}

    public class Test extends A{

    public void test(){

    System.out.println(this.getClass().getSuperClass().getName());

    }

    public static void main(String[] args){

    new Test().test();

    }

    }

    程序的运行结果为:A

    展开全文
  • 问题在日常开发中,经常需要获取当前类和父类的所有属性,没办法只能查API了。getDeclaredFields VS getFields查阅API得知,class.getDeclaredFields()能获取所有属性(public、protected、default、private),但不...

    问题

    在日常开发中,经常需要获取当前类和父类的所有属性,没办法只能查API了。

    getDeclaredFields VS getFields

    查阅API得知,class.getDeclaredFields()能获取所有属性(public、protected、default、private),但不包括父类属性,相对的class.getFields() 获取类的属性(public),包括父类;

    显然以上二者都不能满足需求,这么常见的需求,肯定有开源包实现了,功夫不负有心人果然查到了。apache commons包下的FieldUtils.getAllFields()可以获取类和父类的所有(public、protected、default、private)属性。

    为了加深理解,看一下源码

    public static Field[] getAllFields(final Class> cls) {

    final List allFieldsList = getAllFieldsList(cls);

    return allFieldsList.toArray(new Field[allFieldsList.size()]);

    }

    public static List getAllFieldsList(final Class> cls) {

    Validate.isTrue(cls != null, "The class must not be null");

    final List allFields = new ArrayList();

    Class> currentClass = cls;

    while (currentClass != null) {

    final Field[] declaredFields = currentClass.getDeclaredFields();

    for (final Field field : declaredFields) {

    allFields.add(field);

    }

    currentClass = currentClass.getSuperclass();

    }

    return allFields;

    }

    通过class.getDeclaredFields()获取所有的属性,然后再获取类的父类,再获取所有属性,直到父类为null截止;

    获取类和父类的方法

    类似的,API中也有getDeclaredMethods()和getMethods()

    class.getDeclaredMethods() 获取类的所有方法(public、protected、default、private),但不包括继承的方法;

    class.getMethods() 获取当前类和父类的public方法。

    apache commons包提供了MethodUtils.getMethodsWithAnnotation(class,annotation),获取类及父类的注解为annotation的public方法;

    总结

    获取类的所有属性(public、protected、default、private),包括父类的属性,则使用FieldUtils.getAllFields()

    获取类标注某个注解的方法(包括类及父类),使用MethodUtils.getMethodsWithAnnotation(class,annotation)

    展开全文
  • 1. SuperClassReflectionUtils.javapackage zmx.reflect.test;import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;.../*** 获取父类中的所有属性和方法 工具类* @aut...

    1. SuperClassReflectionUtils.java

    package zmx.reflect.test;

    import java.lang.reflect.Field;

    import java.lang.reflect.InvocationTargetException;

    import java.lang.reflect.Method;

    /**

    * 获取父类中的所有属性和方法 工具类

    * @author zhangwenchao

    *

    */

    public class SuperClassReflectionUtils {

    /**

    * 循环向上转型, 获取对象的 DeclaredMethod

    * @param object : 子类对象

    * @param methodName : 父类中的方法名

    * @param parameterTypes : 父类中的方法参数类型

    * @return 父类中的方法对象

    */

    public static Method getDeclaredMethod(Object object, String methodName, Class> ... parameterTypes){

    Method method = null ;

    for(Class> clazz = object.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()) {

    try {

    method = clazz.getDeclaredMethod(methodName, parameterTypes) ;

    return method ;

    } catch (Exception e) {

    //这里甚么都不要做!并且这里的异常必须这样写,不能抛出去。

    //如果这里的异常打印或者往外抛,则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了

    }

    }

    return null;

    }

    /**

    * 直接调用对象方法, 而忽略修饰符(private, protected, default)

    * @param object : 子类对象

    * @param methodName : 父类中的方法名

    * @param parameterTypes : 父类中的方法参数类型

    * @param parameters : 父类中的方法参数

    * @return 父类中方法的执行结果

    */

    public static Object invokeMethod(Object object, String methodName, Class> [] parameterTypes,

    Object [] parameters) {

    //根据 对象、方法名和对应的方法参数 通过反射 调用上面的方法获取 Method 对象

    Method method = getDeclaredMethod(object, methodName, parameterTypes) ;

    //抑制Java对方法进行检查,主要是针对私有方法而言

    method.setAccessible(true) ;

    try {

    if(null != method) {

    //调用object 的 method 所代表的方法,其方法的参数是 parameters

    return method.invoke(object, parameters) ;

    }

    } catch (IllegalArgumentException e) {

    e.printStackTrace();

    } catch (IllegalAccessException e) {

    e.printStackTrace();

    } catch (InvocationTargetException e) {

    e.printStackTrace();

    }

    return null;

    }

    /**

    * 循环向上转型, 获取对象的 DeclaredField

    * @param object : 子类对象

    * @param fieldName : 父类中的属性名

    * @return 父类中的属性对象

    */

    public static Field getDeclaredField(Object object, String fieldName){

    Field field = null ;

    Class> clazz = object.getClass() ;

    for(; clazz != Object.class ; clazz = clazz.getSuperclass()) {

    try {

    field = clazz.getDeclaredField(fieldName) ;

    return field ;

    } catch (Exception e) {

    //这里甚么都不要做!并且这里的异常必须这样写,不能抛出去。

    //如果这里的异常打印或者往外抛,则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了

    }

    }

    return null;

    }

    /**

    * 直接设置对象属性值, 忽略 private/protected 修饰符, 也不经过 setter

    * @param object : 子类对象

    * @param fieldName : 父类中的属性名

    * @param value : 将要设置的值

    */

    public static void setFieldValue(Object object, String fieldName, Object value){

    //根据 对象和属性名通过反射 调用上面的方法获取 Field对象

    Field field = getDeclaredField(object, fieldName) ;

    //抑制Java对其的检查

    field.setAccessible(true) ;

    try {

    //将 object 中 field 所代表的值 设置为 value

    field.set(object, value) ;

    } catch (IllegalArgumentException e) {

    e.printStackTrace();

    } catch (IllegalAccessException e) {

    e.printStackTrace();

    }

    }

    /**

    * 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter

    * @param object : 子类对象

    * @param fieldName : 父类中的属性名

    * @return : 父类中的属性值

    */

    public static Object getFieldValue(Object object, String fieldName){

    //根据 对象和属性名通过反射 调用上面的方法获取 Field对象

    Field field = getDeclaredField(object, fieldName) ;

    //抑制Java对其的检查

    field.setAccessible(true) ;

    try {

    //获取 object 中 field 所代表的属性值

    return field.get(object) ;

    } catch(Exception e) {

    e.printStackTrace() ;

    }

    return null;

    }

    }

    2、测试:

    2.1 Parent.java

    package zmx.reflect.test;

    public class Parent {

    public String publicField = "1";

    String defaultField = "2";

    protected String protectedField = "3";

    private String privateField = "4" ;

    public void publicMethod() {

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

    }

    void defaultMethod() {

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

    }

    protected void protectedMethod() {

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

    }

    private void privateMethod() {

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

    }

    }

    2.2 Son.java

    package zmx.reflect.test;

    public class Son extends Parent{

    }

    2.3 ReflectionUtilsTest.java

    package zmx.reflect.test;

    import java.lang.reflect.Field;

    import java.lang.reflect.Method;

    import org.junit.Test;

    public class ReflectionUtilsTest {

    /**

    * 测试获取父类的各个方法对象

    */

    @Test

    public void testGetDeclaredMethod() {

    Object obj = new Son() ;

    //获取公共方法名

    Method publicMethod = SuperClassReflectionUtils.getDeclaredMethod(obj, "publicMethod") ;

    System.out.println(publicMethod.getName());

    //获取默认方法名

    Method defaultMethod = SuperClassReflectionUtils.getDeclaredMethod(obj, "defaultMethod") ;

    System.out.println(defaultMethod.getName());

    //获取被保护方法名

    Method protectedMethod = SuperClassReflectionUtils.getDeclaredMethod(obj, "protectedMethod") ;

    System.out.println(protectedMethod.getName());

    //获取私有方法名

    Method privateMethod = SuperClassReflectionUtils.getDeclaredMethod(obj, "privateMethod") ;

    System.out.println(privateMethod.getName());

    }

    /**

    * 测试调用父类的方法

    * @throws Exception

    */

    @Test

    public void testInvokeMethod() throws Exception {

    Object obj = new Son() ;

    //调用父类的公共方法

    SuperClassReflectionUtils.invokeMethod(obj, "publicMethod", null , null) ;

    //调用父类的默认方法

    SuperClassReflectionUtils.invokeMethod(obj, "defaultMethod", null , null) ;

    //调用父类的被保护方法

    SuperClassReflectionUtils.invokeMethod(obj, "protectedMethod", null , null) ;

    //调用父类的私有方法

    SuperClassReflectionUtils.invokeMethod(obj, "privateMethod", null , null) ;

    }

    /**

    * 测试获取父类的各个属性名

    */

    @Test

    public void testGetDeclaredField() {

    Object obj = new Son() ;

    //获取公共属性名

    Field publicField = SuperClassReflectionUtils.getDeclaredField(obj, "publicField") ;

    System.out.println(publicField.getName());

    //获取公共属性名

    Field defaultField = SuperClassReflectionUtils.getDeclaredField(obj, "defaultField") ;

    System.out.println(defaultField.getName());

    //获取公共属性名

    Field protectedField = SuperClassReflectionUtils.getDeclaredField(obj, "protectedField") ;

    System.out.println(protectedField.getName());

    //获取公共属性名

    Field privateField = SuperClassReflectionUtils.getDeclaredField(obj, "privateField") ;

    System.out.println(privateField.getName());

    }

    @Test

    public void testSetFieldValue() {

    Object obj = new Son() ;

    System.out.println("原来的各个属性的值: ");

    System.out.println("publicField = " + SuperClassReflectionUtils.getFieldValue(obj, "publicField"));

    System.out.println("defaultField = " + SuperClassReflectionUtils.getFieldValue(obj, "defaultField"));

    System.out.println("protectedField = " + SuperClassReflectionUtils.getFieldValue(obj, "protectedField"));

    System.out.println("privateField = " + SuperClassReflectionUtils.getFieldValue(obj, "privateField"));

    SuperClassReflectionUtils.setFieldValue(obj, "publicField", "a") ;

    SuperClassReflectionUtils.setFieldValue(obj, "defaultField", "b") ;

    SuperClassReflectionUtils.setFieldValue(obj, "protectedField", "c") ;

    SuperClassReflectionUtils.setFieldValue(obj, "privateField", "d") ;

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

    System.out.println("将属性值改变后的各个属性值: ");

    System.out.println("publicField = " + SuperClassReflectionUtils.getFieldValue(obj, "publicField"));

    System.out.println("defaultField = " + SuperClassReflectionUtils.getFieldValue(obj, "defaultField"));

    System.out.println("protectedField = " + SuperClassReflectionUtils.getFieldValue(obj, "protectedField"));

    System.out.println("privateField = " + SuperClassReflectionUtils.getFieldValue(obj, "privateField"));

    }

    }

    展开全文
  • 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。二、反射的作用Java程序可以加载一个运行时才得知名称的class,获悉其完整构造方法,并生成其对象实体、或对其fields设值、或调用其metho.....

    33227b6ead9824c003870089cf1ff384.png

    3c453da026ad7288403dc6c9aa1b18e6.png

    bb55e5b99e1ffe1ec0a8803aec8b77cd.png

    反射

    第一次课  

    一、 什么是反射

    JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

    二、 反射的作用

    Java程序可以加载一个运行时才得知名称的class,获悉其完整构造方法,并生成其对象实体、或对其fields设值、或调用其methods

    反射是Java中的高级特性,在各种Java框架中都需要使用反射。

    三、 反射中的对象

    lClass:类的反射对象

    每个.java源文件都会编译变为.class字节码,.class文件在使用时会被加载到JVM,

    这个被加载的.class文件存在内存中,Class对象就代表内存中运行的.class文件

    通过ClSS对象获取类中的构造方法、成员变量、方法,拿到后对外提供都是对象

    * Constructor:构造器反射对象;

    l* Field:属性反射对象;

    l* Method:方法反射对象;

    lClassConstrucatorFieldMethod、:统称为“反射对象”。

    四、 反射都是在操作Class类对象

    注意:

    1、 反射从Class类开始

    要想使用反射,首先你需要得到Class对象,

    然后才能通过Class对象获取ConstructorFieldMethod等对象。

    1、 获得Class对象

    (1)、 通过对象获取Class对象:

    String str = new String("");

    Class c1 = 对象.getClass();

    (1)、 通过类名.class获得Class对象

    Class c2 = String.class;

    (2)、 通过Class的静态方法:Class.forName("完整类名");

    Class c3 = Class.forName("java.lang.String");

    System.out.println(c1 == c2);

    System.out.println(c2 == c3);

    (3)、 代码示例

    /**

     * 获得最大的Class对象

     * @throws ClassNotFoundException

     */

    @Test

    public void test1() throws ClassNotFoundException{

    //1、通过已有的对象来创建

    User user = new User();

    Class clz1 = user.getClass();

    System.out.println("完整的类名:"+clz1.getName());

    System.out.println("类的简写:"+clz1.getSimpleName());

    System.out.println("父类:"+clz1.getSuperclass().getName());

    //2、通过类名.clss

    Class clz2 = User.class;

    //普通数据类型也有class

    //Class clzInt = int.class;

    //System.out.println("int的类名:"+clzInt.getName());

    //3、通过Class里面的静态方法 Class.forName("完整的类名");

    Class clz3 = Class.forName("com.tl.entity.User");

    //比较他们,在内存中是否为同一个地址

    System.out.println(clz1==clz2);

    System.out.println(clz2==clz3);

    }

      上面代码输出的都是true,这是因为一个.class文件,硬盘区中只对应一个Class对象。

    2、 Class类简单方法

    l* String getName():返回类名;

    l* String getSimpleName():返回简单类名,不包含包名

    l* Class getSuperClass():获取父类,Object.class.getSupperClass()返回null

    * T newInstance():使用本类无参构造器来创建本类对象

    五、 通过Class类获得构造函数

    1、 通过指定的参数类型获取公有构造器反射对象

    getConstructor(Class... parameterTypes)

    3、 获取所有构造器对象,包含私有构造器

    Constructor getDeclaredConstructor(Class ... parameterTypes)

    4、 通过构造器反射对象调用构造器

    T newInstance(Object... initargs)

    5、 代码示例

    /**

     * 获得构造器反射对象

     * @throws ClassNotFoundException

     */

    @Test

    public void test2() throws Exception{

    Class clz = Class.forName("com.tl.entity.User");

    //获得构造器反射对象

    Constructor c = clz.getConstructor(int.class);

    //使用构造器反射对象实例化出来

    User user = (User) c.newInstance(100);

    System.out.println("user id:"+user.getId());

    }

    六、 通过Class类获得Field

    1、 通过名字获取公有属性反射对象,包含父类中声明的公有属性

    Field getField(String name)

    6、 通过名字获取本类中某个属性,包含本类的private属性,但父类中声明的任何属性都不包含

    Field getDeclaredField(String name)

    7、 获取所有公有属性反射对象,包含父类中声明的公有属性

    Field[] getFields()

    8、 获取本类中声明的所有属性,包含private属性,但不包含父类中声明的任何属性

    Field[] getDeclaredFields()

    9、 setAccessible(true)之后可以改变私有属性的值

    10、 代码示例

    (1)、 parentUser.java

    package com.tl.entity;

    public class ParentUser {

    private String parentName1;//私有的

    public String parentName2;//公有的

    public String getParentName1() {

    return parentName1;

    }

    public void setParentName1(String parentName1) {

    this.parentName1 = parentName1;

    }

    public String getParentName2() {

    return parentName2;

    }

    public void setParentName2(String parentName2) {

    this.parentName2 = parentName2;

    }

    }

    (4)、 User.java

    /**

     * 实体类

     * Oracl数据库,建议属性名全部小写

     * @author Administrator

     *

     */

    public class User extends ParentUser {

    private int id;

    private String userName;//用户名

    private String password;//密码

    private String role;//角色

    public String test;//测试公有字段

    public User(){}

    public User(int id){

    this.id = id;

    }

    public User(int id, String userName, String password, String role) {

    this.id = id;

    this.userName = userName;

    this.password = password;

    this.role = role;

    }

    public int getId() {

    return id;

    }

    public void setId(int id) {

    this.id = id;

    }

    public String getUserName() {

    return userName;

    }

    public void setUserName(String userName) {

    this.userName = userName;

    }

    //测试私有方法

    private String getPassword() {

    return password;

    }

    //测试私有方法

    private void setPassword(String password) {

    this.password = password;

    }

    public String getRole() {

    return role;

    }

    public void setRole(String role) {

    this.role = role;

    }

    }

    (5)、 测试方法

    /**

     * 获得属性反射对象

     * @throws Exception

     */

    @Test

    public void test3() throws Exception{

    Class clz = Class.forName("com.tl.entity.User");

    //getDeclaredField获得自己本身声明的字段,包含私有

    Field userName = clz.getDeclaredField("userName");

    //clz.getField(name)获得自己或者父类,或者接口中所有的公有字段

    //通过类的newInstance会去自动调用无参的构造方法,来实例化一个对象

    User user = (User) clz.newInstance();

    //设置可以改变私有变量的值

    userName.setAccessible(true);

    userName.set(user, "浩浩,面对疾风吧");

    //通过getUserName方法获得刚刚改变的私有变量的值

    System.out.println("userName:"+user.getUserName());

    Field[] fs1 = clz.getDeclaredFields();

    System.out.println("获取本类中所有属性(公有私有都包含),但父类中声明的任何属性都不包含");

    for(Field f:fs1){

    System.out.println("字段名:"+f.getName());

    System.out.println("---字段类型:"+f.getType().getName());

    }

    System.out.println("\n获取本类中所有的公有属性,包含父类中的公有属性");

    Field[] fs2 = clz.getFields();

    for(Field f:fs2){

    System.out.println("字段名:"+f.getName());

    System.out.println("---字段类型:"+f.getType().getName());

    }

    }

    七、 通过Class类获得Method

    1、 通过方法名和方法参数类型获取方法反射对象,包含父类中声明的公有方法,但不包含所有私有方法

    Method getMethod(String name, Class... parameterTypes)

    11、 通过方法名和方法参数类型获取本类中声明的方法的反射对象,包含本类中的私有方法,但不包含父类中的任何方法

    Method getDeclaredMethod(String name, Class... parameterTypes)

    12、 获取所有公有方法,包含父类中的公有方法,但不包含任何私有方法

    Method[] getMethods()

    13、 获取本类中所有方法,包含本类中的私有方法,但不包含父类中的任何方法

    Method[] getDeclaredMethods()

    14、 代码示例

    @Test

    /**

     * 获得方法反射对象,动态调用方法

     * @throws Exception

     */

    public void test4() throws Exception{

    //获得Class对象

    Class clz = User.class;

    //获得里面所有的公有的方法

    Method[] ms1 = clz.getMethods();

    System.out.println("获得本类中所有的公有方法,包括父类的");

    for(Method m:ms1){

    System.out.println("方法名:"+m.getName());

    }

    //获得本类中的所有方法

    Method[] ms2 = clz.getDeclaredMethods();

    System.out.println("获得本类中所有的公有、私有方法方法,不包括父类的");

    for(Method m:ms2){

    System.out.println("方法名:"+m.getName());

    }

    //通过Class中的newInstance调用无参构造方法实例化对象

    User user = (User) clz.newInstance();

    //通过方法名和方法参数类型获取要调用的方法

    Method m = clz.getMethod("setRole", String.class);

    //动态调用方法

    m.invoke(user, "超级管理员");

    //输出

    System.out.println("user role:"+user.getRole());

    }

    八、 通用的查询方法

    使用反射动态获得对象,动态调用对象里对应的set方法给实体类对象设值

    1、 获得查询结果集的列名,查询出的列名(别名)必须和实体类字段名一致

    ResultSetMetaData rsmd = rs.getMetaData();

    int count = rsmd.getColumnCount();

    String columnNames[] = new String[count];

    for(int i=0;i

    columnNames[i] = rsmd.getColumnLabel(i+1);

    System.out.println("查询出的列名:"+columnNames[i]);

    }

    15、 循环结果集时循环所有的列,根据查询出的列名组装需要调用的set方法名

    for(int i=0;i

    String cname = columnNames[i];

    Field f = clz.getDeclaredField(cname);

    Class type = f.getType();

    String methodName = "set"+cname.substring(0,1).toUpperCase()+cname.substring(1);

    System.out.println("方法名:"+methodName);

    Method m = clz.getDeclaredMethod(methodName, type);

    m.invoke(obj, rs.getObject(cname));

    }

    16、 代码示例

    (1)、 详细的请参照项目里的BaseDAO.java

    /**

     * 根据SQL和集合里封装的Class类型,通用的查询方法

     * @param sql

     * @param clz

     * @return

     */

    public List executeQuery(String sql, Class clz) {

    // select id as id1,userName name form users

    Connection conn = null;

    PreparedStatement pstm = null;

    ResultSet rs = null;

    List list = new ArrayList();

    try {

    // 获得连接

    conn = this.getConn();

    // 获得预处理对象

    pstm = conn.prepareStatement(sql);

    // 获得结果集

    rs = pstm.executeQuery();

    // 问题:如何获得结果集中有多少列,列的名字,通过ResultSetMetaData来获取

    ResultSetMetaData rsmd = rs.getMetaData();

    // 获得有多少列,就知道查询语句中查询了几个字段

    int count = rsmd.getColumnCount();

    // 获得列名,用数组存起来

    // 这里的列名要求和实体类的字段名一致

    // 注意,oracle数据库,查询出来的都是大写

    String columnNames[] = new String[count];

    for (int i = 0; i < count; i++) {

    // 获得查询语句中,查询的结果集字段名(有别名的是别名)

    columnNames[i] = rsmd.getColumnLabel(i + 1).toLowerCase();

    System.out.println("列名:" + columnNames[i]);

    }

    while (rs.next()) {

    // 通过反射来获得Class对象,Class对象已经传过来了

    // 通过反射调用无参的默认构造方法,动态构建一个对象

    Object obj = clz.newInstance();

    // 每读一行,rs指向一行,循环这一行里面所有的字段(列)

    for (String cname : columnNames) {

    // 列名拼装以下,set + 首字母大写 + 后面的字母,变为实体类中setXxx方法

    String methodName = "set"

    + cname.substring(0, 1).toUpperCase()

    + cname.substring(1);

    System.out.println("methodName:" + methodName);

    // 根据列名(列名和属性名一致)获得属性

    Field f = clz.getDeclaredField(cname);

    // 根据属性的类型,来设置方法的参数类型

    Method m = clz.getMethod(methodName, f.getType());

    // 动态调用方法 rs.getObject方法,当oracl数据库的序列产生的number类型数据时,无效

    // oracl数据库的处理以下

    if (f.getType().getName().equals("int")|| f.getType().getName().equals("java.lang.Integer")) {

    m.invoke(obj, rs.getInt(cname));

    } else

    m.invoke(obj, rs.getObject(cname));

    }

    // 将对象添加到集合

    list.add(obj);

    }

    } catch (Exception e) {

    e.printStackTrace();

    }

    return list;

    }

    (6)、 测试

    @Test

    public void testExecuteQuery(){

    BaseDAO dao = new BaseDAO();

    List list = dao.executeQuery("select * from users", Users.class);

    for(int i=0;i

    Users user = (Users) list.get(i);

    System.out.println("---name:"+user.getName());

    }

    }

    ed5f35aa523259dbb84496b3b42f7b8d.png

    请支付10元

    加微信好友

    weixinghao:

    d555888088

    获得下载链接

    展开全文
  • 先看下反射机制是如何获取类的方法的:Class clazz = object.getClass();clazz.getDeclaredFields();clazz.getFields()​ 通过getClass()方法获取类的定义信息,通过定义信息再调用getFields()方法获取类的所有...
  • 我们知道,可以通过getDeclaredField和getField方法可以反射获取class中的元素,他们的区别在于getField只能访问公有变量,而getDeclaredField则可以访问定义的所有变量,包括protected修饰和private修饰的变量。...
  • 要求:获取父类的私有id的属性值(传进来的是一个泛型T)反射流程,是先获取到class对象,然后通过Field来获取对象的属性方法常用的方法是:getFields 可以获取自身和继承公共的属性getDeclaredFields 可以获取公共和...
  • 在该类包外的子类中能“看到“的只是子类自己继承来的protected 方法和属性,它是不能“看到“它的父类对象的protected方法和属性的。 也就是说你可以new 子类然后子类对象.protected属性..但是这样实际上访问的是...
  • 但是,对于获取父类的泛型类型,还是会有办法的。在Class类中,有这样一个方法:/*** Returns the {@code Type} representing the direct superclass of* the entity (class, interface, primitive type or void) ...
  • * 获取属性 * @param clazz * @param fieldName * @return */ public static Field getDeclaredField(Class clazz, String fieldName) { if (Strings.isNullOrEmpty(fieldName)) { return null; } whi...
  • package .../*** 父类* @author syh**/public class Parent {public String publicField = "1";String defaultField = "2";protected String protectedField = "3";private String privat...
  • 1 INFO ReflectClassesDemo:28 - 通过class.getPackage()获得类的包名:packagepers.hanchao.reflect.common2 INFO ReflectClassesDemo:31 -通过class.getDeclaredAnnotation(name)获取指定的注解:@pers.hanchao....
  • 小编典典如果您只是在寻找针对已定义子类的方法链,那么以下方法应该有效:public class Parent {public T example() {System.out.println(this.getClass().getCanonicalName());return (T)this;}}如果愿意,可以是...
  • 这是因为子类继承了父类获取到了父类的类容(属性),所以在使用父类内容之前,要先看父类中是如何对自己的内容进行初始化的。如果父类中没有调用空参数构造函数,那么子类的构造函数必须用super明确要调用父类中...
  • java反射 获取父类中的所有属性和方法工具类
  • Java泛型父类取得子类的泛型参数T的Class类型2019-03-19 19:56|来源: 网路Java泛型父类取得子类的泛型参数T的Class类型,主要使用Class类的getGenericSuperclass方法获取getActualTypeArguments[0]import java....
  • super用来继承父类方法和参数。继承就是子类继承父类的特征和行为,使得子类具有父类相同的行为。注意事项:1、当一个类没有继承任何一个类时,系统默认继承Object。2、父类又被称为基类、超类、super类,子类又被...
  • 其中有反射的一个坑,工具类某方法反射获取传入Model的属性值.但是当我把公共属性抽出来做基类的时候,发现获取不到基类的属性值了.原因是使用了getDeclaredFields();分析方法功能getFields()获取所有public字段,包...
  • Java 通过反射获取父类字段的方法

    千次阅读 2018-04-24 17:00:16
    public static < T > T convertJsonRequestToVo...1、java反射以获取父类属性的值 https://blog.csdn.net/Mingyueyixi/article/details/51164061 2、 Java-Reflection反射-获取包括父类在内的所有字段 ...
  • 要求:获取父类的私有id的属性值(传进来的是一个泛型T) 反射流程,是先获取到class对象,然后通过Field来获取对象的属性方法 常用的方法是: getFields 可以获取自身和继承公共的属性 getDeclaredFields 可以...
  • 获取类的属性有getFields和getDeclaredFields两个方法,简要说下两者区别:getFields 可以获取当前类及父类的所有public 属性,protect和private无法获取getDeclaredFields 可以获取到当前类所有的public、protect、...
  • 其中有反射的一个坑,工具类某方法反射获取传入Model的属性值.但是当我把公共属性抽出来做基类的时候,发现获取不到基类的属性值了.原因是使用了getDeclaredFields();分析方法功能getFields()获取所有public字段,包...
  • 现有每多个javabean,但是每个bean中都有不同的属性,并且都是通过get和set方法来修改和获取值。如果调试一步一步去猜内部结构,想用一个方法可以获取不同对像中各个属性的值,怎么办呢?可以利用JAVA的反射机制。1....
  • 获取父类方法及属性前言1、 clazz.getFields()获取成员变量2、 clazz.getDeclaredFields()获取当前类的所有属性3、 clazz.getMethods()获取当前对象及父类对象的所有公共方法4、 clazz.getDeclaredMethods()获取...
  • java反射机制获取父类属性

    万次阅读 2019-01-10 10:41:27
    首先查看反射机制如何获取类的方法的: Class clazz = object.getClasss(); clazz.getDeclareFields(); Calzz.getFields(); 通过getClass()方法获取类的定义信息,通过定义信息再调用getFields()方法获取类的...
  • 其中有反射的一个坑,工具类某方法反射获取传入Model的属性值.但是当我把公共属性抽出来做基类的时候,发现获取不到基类的属性值了.原因是使用了getDeclaredFields();分析方法功能getFields()获取所有public和pro...
  • 对于继承的父类的字段无效getFields方法只能获取类及其父类的公共字段获取父类的私有字段需要先使用getSuperClass获取父类Class,然后通过父类Class的getDeclaredFields方法获取父类的所有字段下面我们举个简单的...
  • Java反射获取父类中的元素

    千次阅读 2017-01-06 19:08:45
    我们知道,可以通过getDeclaredField和getField方法可以反射获取class中的元素,他们的区别在于getField只能访问公有变量,而getDeclaredField则可以访问定义的所有变量,包括protected修饰和private修饰的变量。...
  • Java中继承是单继承,只有一个父类,可以有多个子类。 子类在继承父类的属性和方法的时候可以扩展自己的属性和方法。 继承父类的时候,父类必须有一个无参构造。 子类构造的时候会默认通过super()来调用父类的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,795
精华内容 718
关键字:

java获取父类方法

java 订阅