反射访问类的私有属性对象的私有方法

最新推荐文章于 2022-01-19 08:00:00 发布
最新推荐文章于 2022-01-19 08:00:00 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： android知识点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hard_working1/article/details/78505139
版权
一、什么是反射机制 
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
JAVA反射（放射）机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为 动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。但是JAVA有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。
二、反射机制的优点与缺点  
    静态编译：在编译时确定类型，绑定对象,即通过。 
    动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多 态的应用，有以降低类之间的藕合性。一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功能。 
     缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。

三、利用反射机制能获得什么信息 
         一句话，类中有什么信息，它就可以获得什么信息，不过前提是得知道类的名字，要不就没有后文了 
    首先得根据传入的类的全名来创建Class对象。 
    Class c=Class.forName("className");注明：className必须为全名，也就是得包含包名，比如，cn.netjava.pojo.UserInfo; 
    Object obj=c.newInstance();//创建对象的实例 。OK，有了对象就什么都好办了，想要什么信息就有什么信息了。   
    获得构造函数的方法 
    Constructor getConstructor(Class[] params)//根据指定参数获得public构造器

    Constructor[] getConstructors()//获得public的所有构造器

    Constructor getDeclaredConstructor(Class[] params)//根据指定参数获得public和非public的构造器

    Constructor[] getDeclaredConstructors()//获得public的所有构造器 

    获得类方法的方法 
    Method getMethod(String name, Class[] params),根据方法名，参数类型获得方法

    Method[] getMethods()//获得所有的public方法

    Method getDeclaredMethod(String name, Class[] params)//根据方法名和参数类型，获得public和非public的方法

    Method[] getDeclaredMethods()//获得所以的public和非public方法 
    获得类中属性的方法 
    Field getField(String name)//根据变量名得到相应的public变量

    Field[] getFields()//获得类中所以public的方法

    Field getDeclaredField(String name)//根据方法名获得public和非public变量

    Field[] getDeclaredFields()//获得类中所有的public和非public方法 

四、用反射机制反射访问类的私有属性对象的私有方法
public class Student {
    private String name;
    private int age;
    private String address;
    public Student() {
        this("张三", 21, "湖北随州");
    }
    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    private String getStudentInfo() {
        return "studentInfo: {name:" + name + 
        ", age:" + age + 
        ", address:" + address + "}";
    }
    private void setName(String name) {
        this.name = name;
    }
}
测试代码：
public class ReflectionDemo {
    private Student student;
    public ReflectionDemo() {
        student = new Student();
    }
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.lenovo.dovext.ReflectionDemo");
            // 根据属性名称获取属性的类对象
            Field field = clazz.getDeclaredField("student"); 
            field.setAccessible(true);
            ReflectionDemo reflaction = (ReflectionDemo) clazz.newInstance();
            // 返回reflaction对象上此 Field 表示的字段的值
            Student student = (Student) field.get(reflaction);
            clazz = student.getClass();
            // 根据指定类中的方法名称获取方法的类对象
            Method getMethod = clazz.getDeclaredMethod("getStudentInfo", null);
            getMethod.setAccessible(true);
            // 调用指定对象上此 Method 表示的方法
            String result = (String) getMethod.invoke(student, null);
            System.out.println(result);

            Method setMethod = clazz.getDeclaredMethod("setName", new Class[]{String.class});
            setMethod.setAccessible(true);
            // 调用指定对象上此 Method 对象表示的方法
            setMethod.invoke(student, "联想利泰");

            result = (String) getMethod.invoke(student, null);
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
五、用反射机制实现对数据库数据的增、查例子 

基本原理；保存数据时，把需要保存的对象的属性值全部取出来再拼凑sql语句 
                 查询时，将查询到的数据全部包装成一个java对象。 
    游戏规则：俗话说的好，无规矩不成方圆，特别是程序来说，它只能做有规则的事情，没有规则的它干不了，好，那就 
              先定规则 
              1）数据库的每一个表对象一个pojo类，表中的每一个字段对应pojo类的中的一个属性。 
                 并且pojo类的名字和表的名字相同，属性名和字段名相同，大小写没有关系，因为数据库一般不区分大小写  
              2）为pojo类中的每一个属性添加标准的set和get方法。 
    有了游戏规则，那么开始游戏吧。

1、首先数据库的有一个表，假设数据库名称为：blogsystem,里面的一个表名userinfo。如图：

2、创建对应的pojo类：

package cn.netjava.pojo;
 
public class  UserInfo {
private int  id ;
private String name;
private String pwd;
private int  age;
 
@Override
public String toString() {
     return  "UserInfo [id="  +  id  +  ", name="  +  name +  ", pwd="  +  pwd +  ", age="
             +  age +  "]" ;
}
public int  getId() {
     return  id ;
}
public void setId( int  id ) {
    this. id  =  id ;
}
public String getName() {
     return  name;
}
public void setName(String name) {
    this.name =  name;
}
public String getPwd() {
     return  pwd;
}
public void setPwd(String pwd) {
    this.pwd =  pwd;
}
public int  getAge() {
     return  age;
}
public void setAge( int  age) {
    this.age =  age;
}
 
}

2、编写获得数据库连接的工厂类：
public class  Connect2DBFactory {
    public static Connection getDBConnection() {
        Connection conn =  null;
         try  {
            Class.forName( "com.mysql.jdbc.Driver" );
            String url =  "jdbc: mysql://localhost:3306/blogsystem" ;
            String user =  "root" ;
            String password =  "netjava" ;
            conn =  DriverManager.getConnection(url, user, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
 
         return  conn;
    }
} 

3、好戏开始啦，编写操作数据库的dao类

public class  NetJavaSession {
     /**
      *  解析出保存对象的sql语句
      *
      *  @param object ：需要保存的对象
      *  @ return ：保存对象的sql语句
      */
    public static String getSaveObjectSql( Object  object ) {
         //  定义一个sql字符串
        String sql =  "insert into " ;
         //  得到对象的类
        Class c =  object .getClass();
         //  得到对象中所有的方法
        Method[] methods =  c.getMethods();
         //  得到对象中所有的属性
        Field[] fields =  c.getFields();
         //  得到对象类的名字
        String cName =  c.getName();
         //  从类的名字中解析出表名
        String tableName =  cName.substring(cName.lastIndexOf( "." ) +  1 ,
                cName.length());
        sql +=  tableName +  "(" ;
         List <String> mList =  new ArrayList<String>();
         List  vList =  new ArrayList();
         for  (Method method : methods) {
            String mName =  method.getName();
             if  (mName.startsWith( "get" ) && !mName.startsWith( "getClass" )) {
                String fieldName =  mName.substring( 3 , mName.length());
                mList.add(fieldName);
                System.out.println( "字段名字----->"  +  fieldName);
                 try  {
                     Object  value =  method.invoke( object , null);
                    System.out.println( "执行方法返回的值："  +  value);
                     if  (value instanceof String) {
                        vList.add( "\""  +  value +  "\"" );
                        System.out.println( "字段值------>"  +  value);
                    } else  {
                        vList.add(value);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
         for  ( int  i =  0 ; i < mList.size(); i ++ ) {
             if  (i < mList.size() -  1 ) {
                sql +=  mList.get(i) +  "," ;
            } else  {
                sql +=  mList.get(i) +  ") values(" ;
            }
        }
         for  ( int  i =  0 ; i < vList.size(); i ++ ) {
             if  (i < vList.size() -  1 ) {
                sql +=  vList.get(i) +  "," ;
            } else  {
                sql +=  vList.get(i) +  ")" ;
            }
        }
 
         return  sql;
    }
 
    public static List  getDatasFromDB(String tableName, int  Id ) {
 
         return  null;
    }
 
     /**
      *  将对象保存到数据库中
      *
      *  @param object：需要保存的对象
      *  @ return ：方法执行的结果; 1 :表示成功， 0 :表示失败
      */
    public int  saveObject( Object  object ) {
        Connection con =  Connect2DBFactory.getDBConnection();
        String sql =  getSaveObjectSql( object );
         try  {
             //  Statement statement = (Statement) con.createStatement();
            PreparedStatement psmt =  con.prepareStatement(sql);
            psmt.executeUpdate();
             return  1 ;
        } catch (SQLException e) {
            e.printStackTrace();
             return  0 ;
        }
    }
 
     /**
      *  从数据库中取得对象
      *
      *  @param arg0：对象所属的类
      *  @param id ：对象的 id
      *  @ return :需要查找的对象
      */
    public Object  getObject(String className, int  Id ) {
         //  得到表名字
        String tableName =  className.substring(className.lastIndexOf( "." ) +  1 ,
                className.length());
         //  根据类名来创建Class对象
        Class c =  null;
         try  {
            c =  Class.forName(className);
 
        } catch (ClassNotFoundException e1) {
 
            e1.printStackTrace();
        }
         //  拼凑查询sql语句
        String sql =  "select * from "  +  tableName +  " where Id="  +  Id ;
        System.out.println( "查找sql语句："  +  sql);
         //  获得数据库链接
        Connection con =  Connect2DBFactory.getDBConnection();
         //  创建类的实例
         Object  obj =  null;
         try  {
 
            Statement stm =  con.createStatement();
             //  得到执行查寻语句返回的结果集
            ResultSet set  =  stm.executeQuery(sql);
             //  得到对象的方法数组
            Method[] methods =  c.getMethods();
             //  遍历结果集
             while  ( set . next ()) {
                obj =  c.newInstance();
                 //  遍历对象的方法
                 for  (Method method : methods) {
                    String methodName =  method.getName();
                     //  如果对象的方法以 set 开头
                     if  (methodName.startsWith( "set" )) {
                         //  根据方法名字得到数据表格中字段的名字
                        String columnName =  methodName.substring( 3 ,
                                methodName.length());
                         //  得到方法的参数类型
                        Class[] parmts =  method.getParameterTypes();
                         if  (parmts[ 0 ] ==  String. class ) {
                             //  如果参数为String类型，则从结果集中按照列名取得对应的值，并且执行改 set 方法
                            method.invoke(obj, set .getString(columnName));
                        }
                         if  (parmts[ 0 ] ==  int . class ) {
                            method.invoke(obj, set .getInt(columnName));
                        }
                    }
 
                }
            }
 
        } catch (Exception e) {
            e.printStackTrace();
        }
         return  obj;
    }
}

4、开始测试效果怎么样：

public class  Tester {
    public static void main(String args[]) {
         // 获得NetJavaSession对象
        NetJavaSession session =  new NetJavaSession();
         // 创建一个UserInfo对象
        UserInfo user =  new UserInfo();
         // 设置对象的属性
        user.setId( 6988 );
        user.setAge( 44 );
        user.setPwd( "pwd" );
        user.setName( "champion" );
         // 将对象保存到数据库中
        String sql =  session.getSaveObjectSql(user);
        System.out.println( "保存对象的sql语句："  +  sql);
         // 查找对象
        UserInfo userInfo =  (UserInfo) session.getObject(
                 "cn.netjava.pojo.UserInfo" , 6988 );
        System.out.println( "获取到的信息："  +  userInfo);
 
    }
} 

5、打印出来的结果：


_ext
关注
专栏目录
通过反射访问任意类的私有方法和属性
凯旋的博客
08-31 5840
给出一个如下类： package test2; public class MathDemo {     private int m = 10;          private MathDemo(){              }          private int add(int a,int b){         return a+b;     }  
反射如何拿到私有属性_java利用反射访问类的私有(private)属性及方法
weixin_33236595的博客
12-30 3085
java语言中，在一个类中，为了不让外界访问到有的属性和方法，通常将其设置为private，用正常的方式(对象名.属性名，对象名.方法名)将无法访问此属性与方法，但有没有其他方法可以访问呢？答案是有的，这就是java反射带来的便利。利用反射访问类的私有属性及方法如下：1.准备一个java类,包含私有属性及方法：//Exam.javapublicclassExam{privateStringfie...
java利用反射访问类的私有(private)属性及方法
热门推荐
funcy的专栏
10-01 6万+
java语言中，在一个类中，为了不让外界访问到有的属性和方法，通常将其设置为private，用正常的方式（对象名.属性名，对象名.方法名）将无法访问此属性与方法，但有没有其他方法可以访问呢？答案是有的，这就是java反射带来的便利。利用反射访问类的属性及方法如下 1.
如何通过 反射 调用某个对象的私有方法？
dotNET跨平台
01-19 274
咨询区 Jeromy Irvine我的类中有一组私有方法，我现在想根据灵活的输入值来动态调用其中的私有方法，代码类似是这个样子。MethodInfodynMethod=this.Ge...
Java-利用反射访问类的私有(private)属性及方法&private的意义
梵高先生
02-25 1万+
Java，在一个类中，为了不让外界访问到某些属性和方法，通常将其设置为private，用正常的方式（对象名.属性名，对象名.方法名）将无法访问此属性与方法，但有没有其他方法可以访问呢？答案是有的，这就是java反射带来的便利。利用反射访问类的私有属性及方法如下： /** * @Description: 反射 * @author: Mr_VanGogh * @date: 2019/2/20...
反射获取私有属性
祁_z
09-14 5294
主要步骤： 1. 类.class.getDeclaredFields()方法，获取类的所有public、private成员属性变量； 2. field[index].setAccessible(true)，将私有属性变量设置为可访问的（打破了私有不可访问的规则）； 2.1. field[index].get(类的实例)，获取变量值。 public class MyTestBean { private String testStr; private String testStr...
【Java反射】通过反射访问类的私有属性
Awt_FuDongLai的博客
06-17 4466
步骤 获取类对象 通过类对象，获取Field对象 通过Field对象的set方法修改属性 通过Field对象的get方法获取属性 TestReflection3.java package study; import java.lang.reflect.Field; public class TestReflection3 { public static void main(String[] args) throws NoSuchFieldException, IllegalAccessExcep
PHP实现在对象之外访问其私有属性private及保护属性protected的方法
10-18
3. **克隆（clone）对象**：如`yunke`类的`merge()`方法所示，通过克隆对象，然后修改克隆对象的属性，可以达到改变原对象属性的效果，但这种方法并不直接访问原对象的私有属性，而是创建了一个独立的副本。...
java 反射 调用私有方法（有参数私有方法）获取私有属性值
10-22
在Java中，私有方法和私有属性通常不允许外部类直接访问，这是为了保护类的封装性。然而，通过反射机制，我们可以绕过这些限制。以下是如何使用Java反射来调用私有方法并获取私有属性值的详细步骤： 1. **获取Class...
PHP获取类私有属性的3种方法
10-14
本文介绍了三种在PHP中获取类私有属性值的方法，包括反射（Reflection）、对象转数组以及闭包（Closure）。 首先，我们来谈谈反射。反射是PHP提供的一种强大的特性，允许在运行时检查和操作类、函数、接口等。通过...
利用反射直接访问类中的私有变量
koutatu的专栏
01-02 368
package reflection; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class testMain {  /**   * @param args   */  publ
利用反射访问私有属性、调用私有方法
踏雁寻花
02-28 1358
访问私有属性的代码： package com.tyxh.create; public class Customer { private int a = 1; public int getA() { return a; } } package com.tyxh.create; import java.lang.reflec
java 反射方式访问私有属性和方法
ArmandXu的专栏
09-28 488
一       Field[] fileds = catClass.getDeclaredFields();  //得到catClass类所有的属性（包括私有属性） 二     field.setAccessible(true);  //  该方法表示取消java语言访问检查  三    field.set(target , "ysq"); //为属性赋值  （如果没
java反射机制私有方法_用反射机制调用Java的私有方法
weixin_31597881的博客
02-27 93
class="java">import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;public class StrTest {public static void main(String args[]) {try {PrivateMethodClass a = new Private...
java 反射 私有成员_Java对类私有变量的暴力反射技术讲解
weixin_42309293的博客
02-12 237
Java对类私有变量的暴力反射假设有一个类，他有一个私有变量：package com.howlaa.day04;public class ReflectPoint {private int priVar;public ReflectPoint(int priVar){this.priVar =priVar;}}如果我们直接采用.get的方式，是不可能看到私有变量的。我们可以这样：package c...
通过反射机制外部访问私有变量与私有方法
Hydrion的博客
07-09 809
一般情况下，在外部是无法访问私有变量和私有方法的，但是运用反射机制则可以绕过这个限制。 假设有一个A类： class A{ private String var; private void methodA(){ System.out.println("the var is" + var); } } 我们想要在外部访问它的私有变量和方法，则可以: ...
如何通过反射机制访问类的私有属性
weixin_44145150的博客
11-20 591
public class Main{ public static void main(String[] args){ Person p=new Person(1024,"myname"); Class c1=p.getClass(); try{ Field field=c1.getDeclaredField("name"); field.getAccessible(...
通过反射如何调用私有属性？
qq_45672914的博客
03-31 157
对象.setAccessible(true);
java反射获取对象私有属性
最新发布
09-09
您可以使用Java反射机制来获取对象的私有属性。首先，您需要获取该类的`Class`对象，然后使用`getDeclaredField()`方法来获取指定名称的私有字段。接下来，您需要使用`setAccessible(true)`方法来设置该私有字段可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值