精华内容
下载资源
问答
  • 2021-02-12 15:02:10

    一般在其他类中是不能这个得到类中private属性和访问private方法的,但天无绝人之路,java强大的反射机制可以完成这个任务。

    建一个测试类A:

    package com.shao.test;

    public class A {

    private String testStr="just for test";

    private void get(int index,String value){

    System.out.println(index+":"+value+" and testStr:"+testStr);

    }

    }

    现在我们来访问A中的testStr属性和get方法:

    package com.shao.test;

    import java.lang.reflect.Field;

    import java.lang.reflect.InvocationTargetException;

    import java.lang.reflect.Method;

    public class B {

    public static void main(String[]args) throws ClassNotFoundException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException, NoSuchMethodException, InvocationTargetException{

    Field field=Class.forName("com.shao.test.A").getDeclaredField("testStr");

    field.setAccessible(true);

    A a=new A();

    System.out.println(field.getType().toString()); //print:class java.lang.String

    System.out.println(field.getName()); //print:testStr

    System.out.println(field.getModifiers()); //print:2

    Object s=field.get(a);

    System.out.println(s); //print:just for test

    String x="Hello";

    field.set(a, x);

    System.out.println(field.get(a)); //print:Hello

    Method method=Class.forName("com.shao.test.A").getDeclaredMethod("get", new Class[]{int.class,String.class});

    method.setAccessible(true);

    method.invoke(a, 3,"apples"); //print:3:apples and testStr:Hello

    }

    }

    属性使用Filed类获取,方法使用Method类去调用。

    更多相关内容
  • 1、首先,创建一个类,部分属性和方法设置为private。 package com.example.demo.utils; /** * @Author HL * @Date 2021年3月20日 */ public class Person { private String id = "10"; private String name...

    1、首先,创建一个类,部分属性和方法设置为private。

    package com.example.demo.utils;
    
    /**
     * @Author HL
     * @Date 2021年3月20日
     */
    public class Person {
        private String id = "10";
        private String name = "张三";
    
        private String getId() {
            return id;
        }
    
        private String getName() {
            return name;
        }
    
        public String getInfo() {
            return id + ", " + name;
        }
    }
    

    2、再创建一个类,利用Java反射机制调用私有属性和方法。

    package com.example.demo.utils;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    /**
     * 测试Java反射技术
     * @Author HL
     * @Date 2021年3月20日
     */
    public class ReflectTest {
        public static void main(String[] args) {
            reflectMethod();
        }
    
        /**
         * 反射方法获取私有属性及方法
         *
         * @Author HL
         * @Date 2021年3月20日
         */
        public static void reflectMethod() {
            try {
                // 获得Person类
                Class c1 = Person.class;
                Person p1 = (Person) c1.newInstance();
                // 获得Person所有属性
                Field[] fields = c1.getDeclaredFields();
                for (int i = 0; i < fields.length; i++) {
                    // 将目标属性设置为可以访问
                    fields[i].setAccessible(true);
                    System.out.println("修改前" + fields[i].getName() + ": " + fields[i].get(p1));
                    // 给属性重新赋值
                    fields[i].set(p1, null);
                    System.out.println("修改后" + fields[i].getName() + ": " + fields[i].get(p1));
                }
                // 获得Person所有方法
                Method[] methods = c1.getDeclaredMethods();
                for (int i = 0; i < methods.length; i++) {
                    // 将目标方法设置为可以访问
                    methods[i].setAccessible(true);
                    // 输出所有方法名称
                    System.out.println("方法" + methods[i].getName());
                }
                // 获得指定名称的方法
                Method method = c1.getDeclaredMethod("getInfo");
                method.setAccessible(true);
                System.out.println("getInfo方法返回值:" + method.invoke(p1));
    
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            }
    
        }
    }
    

    3、代码执行结果如下。

    修改前id: 10
    修改后id: null
    修改前name: 张三
    修改后name: null
    方法getName
    方法getId
    方法getInfo
    getInfo方法返回值:null, null
    
    Process finished with exit code 0
    

     

    展开全文
  • javaprivate只能被本类访问。但是还可以利用java中的反射从外界调用private变量或方法。package reflect;import java.lang.reflect.Field;import java.lang.reflect.Method;public class PrivateCarReflect {...

    java中private只能被本类访问。但是还可以利用java中的反射从外界调用private变量或方法。

    11082242.html

    11082242.html

    98cd230aa92ce06ade58a41a06c13a2e.png

    package reflect;

    import java.lang.reflect.Field;

    import java.lang.reflect.Method;

    public class PrivateCarReflect {

    public static void main(String[] args) throws Throwable{

    //获取当前线程再获取类加载器

    ClassLoader loader = Thread.currentThread().getContextClassLoader();

    //通过类加载器获取我们想操作的类

    Class clazz = loader.loadClass("reflect.PrivateCar");

    //类转换一下

    PrivateCar pcar = (PrivateCar) clazz.newInstance();

    //field场地,declared宣告,

    //field用于获取字段

    Field colorFld = clazz.getDeclaredField("color");

    //取消java语言访问检查以访问private变量

    colorFld.setAccessible(true);

    colorFld.set(pcar, "红色");

    Method driveMtd = clazz.getDeclaredMethod("drive");

    //取消java语言访问检查以访问protected方法

    driveMtd.setAccessible(true);

    driveMtd.invoke(pcar, (Object[])null);

    }

    }

    反射Class类、Constructor类、Field类。

    表示java类的Class类显然要提供一系列的方法,来获得其中的变量,方法,构造方法,修饰符,包等信息,这些信息就是用相应类的实例对象来表示,它们是Field、Method、Contructor、Package等等。

    field中有修饰符、类型、变量名等复杂的描述内容,因此也可以将字段封装称为一个对象。用来获取类中field的内容,这个对象的描述叫Field。同理方法和构造函数也被封装成对象Method、Constructor。要想对一个类进行内容的获取,必须要先获取该字节码文件的对象。该对象是Class类型。

    以下为AccessibleObject、Method、Field类源码:

    //AccessibleObject 类是 Field、Method 和 Constructor 对象的基类。

    public class AccessibleObject implements AnnotatedElement {

    /*

    * 1、实现了AnnotatedElement对注解支持的相关方法

    * 2、提供访问控制

    /

    void setAccessible(boolean flag)

    设置该对象(Field,Constructor,Method)是否可访问

    boolean isAccessible()

    该对象是否可访问

    void setAccessible(AccessibleObject[] array, boolean flag)

    设置这一组对象(Field,Constructor,Method)是否可访问

    }

    public interface Member{

    public static final int PUBLIC = 0; //标识类或接口的所有已声明成员的集合。

    public static final int DECLARED = 1; //标识类或接口的所有公共成员(包括继承成员)的集合。

    public Class> getDeclaringClass();// 所在类

    public String getName(); //返回此 Member 表示的底层成员或构造方法的简单名称。

    public int getModifiers(); //作为整数返回由此 Member 所表示的成员或构造方法的 Java 语言修饰符。

    public boolean isSynthetic(); //如果此成员是编译器引入的,则返回 true;否则,返回 false。

    }

    public final class Field extends AccessibleObject implements Member{

    // 1.字段的设值和取值 ,对于静态属性,obj传null

    set(Object obj, Object value)

    setXX(Object obj, Object value) ,比如setInt,setBoolean

    Object get(Object obj)

    getXX(Object obj) ,比如getInt,getBoolean

    // 2.字段上注解的获取

    getDeclaredAnnotations()

    getAnnotation(Class annotationClass);

    // 3.字段类型

    Type getGenericType();

    Class> getType();

    // 4.字段修饰符

    int modifer=field.getModifiers();

    String modify = Modifier.toString(modifiers);

    // 5.字段名称

    String getName();

    }

    参考博客:

    展开全文
  • Java反射获取private属性和方法(子类,父类,祖先….)先来看一个例子:String可变还是不可变?大家都应该知道,或者听过,String类是不可变的,为什么呢?因为String其实使用一个private final char [] value;来保存...

    版权声明:本文为博主原创文章,未经博主允许不得转载。

    Java反射获取private属性和方法(子类,父类,祖先….)

    先来看一个例子:String可变还是不可变?

    大家都应该知道,或者听过,String类是不可变的,为什么呢?因为String其实使用一个

    private final char [] value;来保存字符的;final,private,明显就不让你改了啊。但是,大家请看:

    String a="abc";

    Field valueFieldString=String.class.getDeclaredField("value");

    valueFieldString.setAccessible(true);

    char[]value=(char[])valueFieldString.get(a);

    value[2]='@';

    String b="abc";

    //a.intern();

    System.out.println(a);

    System.out.println(b);

    System.out.println(a==b);

    System.out.println("abc"==b);

    System.out.println("ab@"==a);

    System.out.println(a.equals("ab@"));

    System.out.println(a.equals("abc"));

    System.out.println("abc".equals("ab@"));

    输出(猜猜看,和你想的一不一样呢?):

    ab@

    ab@

    true

    true

    false//(如果把intern那个注释去掉的话,就是true)

    true

    true

    true

    如果,你都答对了,恭喜你,那请直接跳到 反射用法.

    否则:请看下面分析

    先摘一段官方intern()的注释:

    * Returns a canonical representation for the string object.

    *

    * A pool of strings, initially empty, is maintained privately by the

    * class {@code String}.

    *

    * When the intern method is invoked, if the pool already contains a

    * string equal to this {@code String} object as determined by

    * the {@link #equals(Object)} method, then the string from the pool is

    * returned. Otherwise, this {@code String} object is added to the

    * pool and a reference to this {@code String} object is returned.

    3个点:

    * 1.常量池(JVM中就是方法区)是由 String 这个class来私有的管理的。*

    * 2.调用intern()时,会查看常量池是否存在这个String对象,这是通过equals()方法来判断的。*

    * 3.如果存在,则返回常量池中那个String对象,否则,加入到常量池,并返回当前对象。*

    ps : equals()方法,首先是看obj1==obj2,也就是引用地址是否相等,如果等则返回true,然后是逐个字符比较。

    ok,有了以上知识。其实到这里你自己也可以分析出来了。

    我们来分析一下

    首先,String a="abc"; 这句话在内存(常量池)中放入了一个String对象:“abc”(内存地址假设为0x123,由char [] value = [‘a’,’b’,’c’]保存),

    然后第2~5行,我们先不管语法,只要知道是把“abc”这个字符串的第三个字符’c’替换为’@’,

    此时char [] value = [‘a’,’b’,’c’] 变为了char [] value = [‘a’,’b’,’@’],String这个class对象管理的还是“abc”这个对象。

    接下来 String b="abc",这句话会从常量池中寻找“abc”,此时会发现常量池中“abc”是存在的,于是,b就指向了“abc”,b其实就是“abc”的位置的一个引用,a也是一个“abc”位置的引用。

    那么接下来就是顺理成章了:

    System.out.println(a);//a指向"abc"这个对象,而这个对象,内部存储却是{'a','b','@'}

    System.out.println(b);//同上

    System.out.println(a==b);//都指向0x123

    System.out.println("abc"==b);//都是0x123

    System.out.println("ab@"==a);//"ab@"这个对象在常量池中没有,会先在常量中生成,地址显然不是0x123,所以输出false,但是,当调用了a.intern()后,会调用String的equals()去常量池中新建一个对象"ab@',并返回这个位置。

    System.out.println(a.equals("ab@"));

    System.out.println(a.equals("abc"));

    System.out.println("abc".equals("ab@"));

    如果仔细想想,其实还是有疑问,在这里就不展开了,不然偏题了,因为我对底层也不懂,intern是c++实现的,具体看这篇:

    反射

    反射,RTTI,Class对象,这些就不说了,看一段代码:

    static void getClassFieldAndMethod(Class cur_class) {

    String class_name = cur_class.getName();

    Field[] obj_fields = cur_class.getDeclaredFields();

    for (Field field : obj_fields) {

    field.setAccessible(true);

    System.out.println(class_name + ":" + field.getName());

    }

    Method[] methods = cur_class.getDeclaredMethods();

    for (Method method : methods) {

    method.setAccessible(true);

    System.out.println(class_name + ":" + method.getName());

    }

    if (cur_class.getSuperclass() != null) {

    getClassFieldAndMethod(cur_class.getSuperclass());

    }

    }

    8

    9

    10

    11

    12

    13

    14

    15

    16

    这段代码输入是一个Class的对象,递归输出这个类的父类,祖父类直到Object类的所有方法和域。

    再看一段:

    static void getObjField(Object obj) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{

    Class cur_class = obj.getClass();

    getClassFieldAndMethod(cur_class);

    Field vfield=cur_class.getDeclaredField("value");

    vfield.setAccessible(true);

    char[]value=(char[])vfield.get(obj);

    System.out.println(Arrays.toString(value));

    }

    ok,这段代码输入任意一个对象,调用上面那段代码的方法getClassFieldAndMethod(),这样你就知道这个对象都有些什么域,什么方法了,再通过域的名称,就可以获取当前这个对象的域的值,进而可以修改了!!

    是不是很简单,从此以后谁都不能限制你在Java程序里面为所欲为了!

    展开全文
  • 细话Java:"失效"的private修饰符
  • java语言中,在一个类中,为了不让外界访问到有的属性和方法,通常将其设置为private,用正常的方式(对象名.属性名,对象名.方法名)将无法访问此属性与方法,但有没有其他方法可以访问呢?答案是有的,这就是java...
  • java 获取对象属性值与属性名称

    千次阅读 2021-02-13 01:04:29
    /*** 获取对象属性,返回一个字符串数组** @param o 对象* @return String[] 字符串数组*/private static String[] getFiledName(Object o){try{Field[] fields = o.getClass().getDeclaredFields();String[] field...
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼/*** 根据属性获取属性值* */private Object getFieldValueByName(String fieldName, Object o) {try {String firstLetter = fieldName.substring(0, 1).toUpperCase()...
  • // 对于每个属性获取属性名 str+=""; str=str+varName; str+=""; str+=""; str+=getFieldValueByName(varName,example); str+=""; str+=""; } str+=""; System.out.print(str); return str; } private Object ...
  • private Long id; private Integer age; private int shengao; private Byte sex; private String name; private String EName; private Company company; public int getShengao() { return shengao;
  • Java中的反射可以帮助程序做很多是事,对于运行状态下的类能获取其所有属性和方法。 一个类中的公共和私有的变量和方法、构造方法等信息都能通过反射进行获取 Class类:getDeclaredField把类的所有属性反射出来...
  • 这两天笔者几篇文章介绍了改类变量的文章. 关联文章的地址从计划的准则说来...但是如果这个类没有供提get和set方法,我们如何去获得到这个类的private成员变量呢?比如有这么一个类 Person:class Person{private Str...
  • java 反射 调用私有方法(有参数私有方法)获取私有属性
  • 首先我们明确一下“继承”一词的概念,在 Java 中,继承一词的意义是有限制的。一个子类只能继承其父类的可访问的成员,并且该子类没有覆盖或者说隐藏父类中的那些可访问成员。所以,一个类的成员就是指在这个类中所...
  • java反射获得父类私有属性

    千次阅读 2021-09-03 14:37:47
    备忘一下,拿Field的时候要用getClass().getSuperclass()来获取Field: Field f= getClass().getSuperclass().getDeclaredField("sqlSessionFactory"); f.setAccessible(true); ssf= (SqlSessionFactory) f.get(this...
  • 我们来看下例子:@Datapublic class Demo {public ...private String title;}public class Test {public static void main(String[] args) {try {Class clazz = Class.forName("com.lian.demo.Demo");Demo demo = (...
  • } } public class BimCloudtProjectInfoExtFiedlsDetail { @TableField("ext_id") private Long extId; @TableField("tenant_id") private Long tenantId; @TableField("project_id") private Long projectId; @...
  • 获取注解的属性,通过反射获取注解的属性值。二、示例代码1、定义一个注解,用于给 全局变量 field 字段 赋值package com.haha.study.annotation.value;import java.lang.annotation.Documented;import java...
  • /*** 根据属性获取属性值* */private Object getFieldValueByName(String fieldName, Object o) {try {String firstLetter = fieldName.substring(0, 1).toUpperCase();String getter = "get" + firstLetter + ...
  • java 反射根据属性获取属性

    千次阅读 2021-03-20 15:07:29
    二、根据属性获取属性值 1、考虑安全访问范围内的属性,没有权限访问到的属性不读取 /** * 根据属性获取属性值 * * @param fieldName * @param object * @return */ private String ...
  • private List<Person> persons; } 获取 Person 中的field等等 具体代码: Field[] declaredFields = xxxx.class.getDeclaredFields(); for (Field declaredField : declaredFields) { declaredField....
  • java获取类中的属性和值

    千次阅读 2021-02-26 13:48:39
    java中反射是一种非常神奇的机制,通过反射,我可以知道我的某个类含有那些属性,那些方法,继承自那个类,又有什么样的构造方法。如果我们要大量获取类中的内容,但事先我并不知道这个类中有什么样的属性,有什么样...
  • 获取java类中所有属性

    千次阅读 2021-03-04 01:40:23
    1.bean类:Test.javapackage com.dada.test;public class Test {private String id;private String name;private String age;public String getId() {return id;}public void setId(String id) {this.id = id;}...
  • javaprivate什么意思

    千次阅读 2021-02-12 20:48:38
    private作为一种权限修饰符可以修饰类、属性和方法;用private修饰的类、属性、方法,只能自己使用,别的类是不能访问的,也就是说对于别的类来说是隐藏不可见的,private一般不修饰类,但是可以修饰内部类。可以...
  • private String name; //设置私有成员变量,只能在本类使用 private int age; public void Setname(String name){ //set方法不需要返回值,只需要存在栈内存中 this.name=name; } public String Getname(){ .....
  • [ /** * 获取对象属性,返回一个字符串数组 * * @param o 对象 * @return String[] 字符串数组 */ private String[] getFiledName(Object o) { try {packagetest.demo;publicclassStudent{privateStringid;private.....
  • Java如何获取对象属性及对应值

    千次阅读 2021-02-12 12:25:52
    利用反射获取对象的所有属性及对应的值1、获取属性名数组private static String[] getFiledName(Object o) {Field[] fields = o.getClass().getDeclaredFields();String[] fieldNames = new String[fields.length];...
  • java反射机制根据属性获取属性值的操作,属性,对象,反射,访问权限,还可以java反射机制根据属性获取属性值的操作易采站长站,站长之家为您整理了java反射机制根据属性获取属性值的操作的相关内容。一、考虑安全...
  • 获取java类中的属性注释

    千次阅读 2020-07-08 14:21:22
    一般我们的某个数据库表对象model,java bean对象如下: package com.xxx.message.model; import com.middol.common.model.BaseModel; import lombok.Data; import lombok.EqualsAndHashCode; import javax....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 553,509
精华内容 221,403
关键字:

java获取private属性

java 订阅