javaprivate反射_java反射调用private方法

Ⅰ 什么是java的反射

Java反射指的是对于任何的一个java类，我们都可以通过反射获取到这个类的所有属性和方法(包含私有的属性方法)，使用java反射我们也可以调用一个对象的任何方法。
我们知道Java是一门面向对象编程的语言，我们编程的时候，经常会将类的属性进行封装，然后提供public方法进行属性的设置和获取。类的属性我们通常会设置成private的私有属性，为的就是保护对象属性不被随意的修改和访问。但是反射机制却恰恰相反，通过反射，我们可以获取到这些被保护的属性和方法，并且可以修改和访问他们。
在java中我们可以使用object对象的getClass();方法获得Class的对象classObject;语法格式为 Class classObject = object.getClass() ;可以根据Class对象的方法获取object对象的相关属性和方法;
获取object对象的名字可以使用 classObject.getName();获取类的名称，获取到的结果包含包的名称;
获取object对象的包名称，可以使用classObject.getPackage();获取包的名称;
获取object对象的所有public属性，可以使用classObject.getFields();方法，返回列表是属性类Field[]对象列表;
获取object对象所有属性,可以使用classObject.getDeclaredFields();方法，返回的是所有属性列表(包含private属性);
获取object对象某个特定的属性,可以使用classObject.getField( fieldName );可以根据属性名称获取属性类的对象;
获取object对象private属性，可以使用classObject.getDeclaredField( fieldName );根据属性名获取属性对象信息;
获取object对象public方法，使用classObject.getMethods();可以获取到方法类Method[]对象列表;
获取object对象某个特定的public方法，使用classObject.getMethod( funName , Class... parameterTypes);根据方法名和方法参数类型列表，可以获取到方法类的对象;
获取object对象所有方法(包含private方法);使用classObject.getDeclaredMethods();可以获取所有的方法对象列表;
获取object对象某个特定方法(包含private方法)，使用classObject.getDeclaredMethod ( funName, Class... parameterTypes );根据方法名和方法参数类型列表，可以获取到类的特定方法(包含private方法);
获取object对象类中所有的public构造方法，可以使用classObject.getConstructors(); 获取到构造类Constructor的对象列表;
获取object对象类中某个特定的构造方法，可以使用classObject.getConstructor( Class... parameterTypes ); 根据参数类型列表，获取指定的构造函数对象;
获取object对象类中所有的构造方法(包含private)，可以使用classObject.getDeclaredConstructors(); 获取到构造类Constructor的对象列表;
获取object对象类中某个特定的构造方法(包含private)，可以使用classObject.getDeclaredConstructor( Class... parameterTypes ); 根据参数类型列表，获取指定的构造函数对象;

Ⅱ 怎样用java反射机制获得父类private 属性的值

Class c = null;
try {
c = Class.forName("com.ibm.lan.test.Sub");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}

Class superClass = c.getSuperclass();
Field[] fields = superClass.getDeclaredFields();

这是得到父类的属性
for(int i=0;i<fields .length;i++)
{
fields [i].setAccessible(true);
System.out.println(fields [i].getType());
fields [i].set();
}

Ⅲ java反射调用private方法

Java程序不能访问持久化类的private方法，但是利用JAVA的反射机制可以实现调用，代码如下:

<spanstyle="font-size:14px;">
importjava.lang.reflect.InvocationTargetException;
importjava.lang.reflect.Method;
publicclassReflectDemo{
	publicstaticvoidmain(String[]args)throwsException{
		Methodmethod=PackageClazz.class.getDeclaredMethod("privilegedMethod",newClass[]{String.class,String.class});
		method.setAccessible(true);
		method.invoke(newPackageClazz(),"452345234","q31234132");
	}
}
classPackageClazz{
	privatevoidprivilegedMethod(StringinvokerName,Stringadb){
		System.out.println("---"+invokerName+"----"+adb);
	}
}
</span>
#程序输出结果为：---452345234----q31234132

Ⅳ java反射机制详解

反射就是把Java的各种成分映射成相应的Java类。
Class类的构造方法是private，由JVM创建。
反射是java语言的一个特性，它允程序在运行时（注意不是编译的时候）来进行自我检查并且对内部的成员进行操作。例如它允许一个java的类获取他所有的成员变量和方法并且显示出来。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。（来自Sun）
JavaBean 是 reflection 的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 Java 组件(类) 的属性。
反射是从1.2就有的，后面的三大框架都会用到反射机制,涉及到类"Class",无法直接new CLass()，其对象是内存里的一份字节码.
Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
基本的 Java类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。Class 没有公共构造方法。
Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
Person p1 = new Person();
//下面的这三种方式都可以得到字节码
CLass c1 = Date.class();
p1.getClass();
//若存在则加载，否则新建,往往使用第三种,类的名字在写源程序时不需要知道，到运行时再传递过来
Class.forName("java.lang.String");

Class.forName()字节码已经加载到java虚拟机中，去得到字节码；java虚拟机中还没有生成字节码用类加载器进行加载，加载的字节码缓冲到虚拟机中。
另外，大家可以关注微信公众号Java技术栈回复：JVM，获取我整理的系列JVM教程，都是干货。
考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。
import java.lang.reflect.*;

public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName("java.util.Stack");

Method m[] = c.getDeclaredMethods();

for (int i = 0; i < m.length; i++)
System.out.println(m[i].toString());
}
catch (Throwable e){
System.err.println(e);
}
}
}

public synchronized java.lang.Object java.util.Stack.pop()
public java.lang.Object java.util.Stack.push(java.lang.Object)
public boolean java.util.Stack.empty()
public synchronized java.lang.Object java.util.Stack.peek()
public synchronized int java.util.Stack.search(java.lang.Object)

这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。
以下示例使用 Class 对象来显示对象的类名：
void printClassName(Object obj) {
System.out.println("The class of " + obj +
" is " + obj.getClass().getName());
}

还可以使用一个类字面值（JLS Section 15.8.2）来获取指定类型（或 void）的 Class 对象。例如：
System.out.println("The name of class Foo is: "+Foo.class.getName());

在没有对象实例的时候，主要有两种办法。
//获得类类型的两种方式
Class cls1 = Role.class;
Class cls2 = Class.forName("yui.Role");

注意第二种方式中，forName中的参数一定是完整的类名（包名+类名），并且这个方法需要捕获异常。现在得到cls1就可以创建一个Role类的实例了，利用Class的newInstance方法相当于调用类的默认的构造器。
Object o = cls1.newInstance();
//创建一个实例
//Object o1 = new Role(); //与上面的方法等价

Ⅳ java有反射机制可以看到私有方法，为什么还要有private，public等之类的区别

private，public类似与 WEB系统中管理员,普通用户权限 . 是一种权限安全机制
反射的主要目的并不在与看到私有方法,更重要的是能在运行时可以动态自查自己的结构,在开发某些功能时特别有用,
例如:(1)把XML节点自动映射后JAVA BEAN中.
(2)批量操作带有接口的类的时
(3)代理功能实现等....
楼主需要潜心修行才能大彻大悟啊

Ⅵ 反射调用private方法实践(php、java)

单测中有个普遍性的问题，被侧类中的private方法无法直接调用。小拽在处理过程中通过反射改变方法权限，进行单测，分享一下，直接上代码。
简单被测试类
生成一个简单的被测试类，只有个private方法。
复制代码
代码如下:
<?php/**
*
崔小涣单测的基本模板。
*
*
@author
cuihuan
*
@date
2015/11/12
22:15:31
*
@version
$Revision:1.0$
**/class
MyClass
{/**
*
私有方法
*
*
@param
$params
*
@return
bool
*/private
function
privateFunc($params){if(!isset($params)){return
false;}echo
"test
success";return
$params;}}
单测代码
复制代码
代码如下:
<?php/***************************************************************************
*
*
$Id:
MyClassTest
T,v
1.0
PsCaseTest
cuihuan
Exp$
*
**************************************************************************//**
*
崔小涣单测的基本模板。
*
*
@author
cuihuan
*
@date
2015/11/12
22:09:31
*
@version
$Revision:1.0$
**/require_once
('./MyClass.php');class
MyClassTest
extends
PHPUnit_Framework_TestCase
{const
CLASS_NAME
=
'MyClass';const
FAIL
=
'fail';protected
$objMyClass;/**
*
@brief
setup:
Sets
up
the
fixture,
for
example,
opens
a
network
connection.
*
*
可以看做phpunit的构造函数
*/public
function
setup()
{date_default_timezone_set('PRC');$this->objMyClass
=
new
MyClass();}/**
*
利用反射，对类中的private
和
protect
方法进行单元测试
*
*
@param
$strMethodName
string
：反射函数名
*
@return
ReflectionMethod
obj
：回调对象
*/protected
static
function
getPrivateMethod($strMethodName)
{$objReflectClass
=
new
ReflectionClass(self::CLASS_NAME);$method
=
$objReflectClass->getMethod($strMethodName);$method->setAccessible(true);return
$method;}/**
*
@brief
:测试private函数的调用
*/public
function
testPrivateFunc(){$testCase
=
'just
a
test
string';//
反射该类$testFunc
=
self::getPrivateMethod('privateFunc');$res
=
$testFunc->invokeArgs($this->objMyClass,
array($testCase));$this->assertEquals($testCase,
$res);$this->expectOutputRegex('/success/i');//
捕获没有参数异常测试try
{
$testFunc->invokeArgs($this->transfer2Pscase,
array());}
catch
(Exception
$expected)
{$this->assertNotNull($expected);return
true;}$this->fail(self::FAIL);}}
运行结果
cuihuan:test
cuixiaohuan$
phpunit
MyClassTest.php
PHPUnit
4.8.6
by
Sebastian
Bergmann
and
contributors.Time:
103
ms,
Memory:
11.75MbOK
(1
test,
3
assertions)
关键代码分析
封装了一个，被测类方法的反射调用；同时，返回方法之前处理方法的接入权限为true，便可以访问private的函数方法。
复制代码
代码如下:
/**
*
利用反射，对类中的private
和
protect
方法进行单元测试
*
*
@param
$strMethodName
string
：反射函数名
*
@return
ReflectionMethod
obj
：回调对象
*/protected
static
function
getPrivateMethod($strMethodName)
{$objReflectClass
=
new
ReflectionClass(self::CLASS_NAME);$method
=
$objReflectClass->getMethod($strMethodName);$method->setAccessible(true);return
$method;}
下面给大家分享java中利用反射调用另一类的private方法
我们知道,Java应用程序不能访问持久化类的private方法,但Hibernate没有这个限制,它能够访问各种级别的方法,如private,
default,
protected,
public.
Hibernate是如何实现该功能的呢?答案是利用JAVA的反射机制,如下:
<span
style="font-size:14px;">import
java.lang.reflect.InvocationTargetException;
import
java.lang.reflect.Method;
public
class
ReflectDemo
{
public
static
void
main(String[]
args)
throws
Exception
{
Method
method
=
PackageClazz.class.getDeclaredMethod("privilegedMethod",
new
Class[]{String.class,String.class});
method.setAccessible(true);
method.invoke(new
PackageClazz(),
"452345234","q31234132");
}
}
class
PackageClazz
{
private
void
privilegedMethod(String
invokerName,String
adb)
{
System.out.println("---"+invokerName+"----"+adb);
}
}</span>
输出结果为：---452345234----q31234132

Ⅶ java中如何实现private反射获得对象字段值的

背景介绍：在一个Bean类中，需要通过反射机制获得private字段属性时，如果用通常获得步骤获得会报如下错误： java.lang.IllegalAccessException: Class Test can not access a member of class Bean with modifiers "private" at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:57) at java.lang.reflect.Field.doSecurityCheck(Field.java:811) at java.lang.reflect.Field.getFieldAccessor(Field.java:758) at java.lang.reflect.Field.get(Field.java:228) 解决如下代码实现代码： 1.Bean.class内容如下： public class Bean { private String aa; } 2.Test.class内容如下： public class Test { public static void main(String[] args) throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException { Bean test = new Bean(); Field f = Bean.class.getDeclaredField("aa"); //其中,最关键的代码是: //f.setAccessible(true); //这行代码把对象data上的name字段设置为public访问属性. f.setAccessible(true); System.out.println(f.get(test)); f.set(test, "t2"); System.out.println(f.get(test)); } } 运行Test类输出如下： null t2

Ⅷ java 一个类调用另一个类的private方法

Java调用private方法利用的是Java中的类反射机制。
定义一个class，定义一个内部private方法：
public class PrivateTest {
private void print() {
System.out.println("this is a private method");
}
}
再定义一个class去访问刚才定义的private方法，也就是print()如下
import java.lang.reflect.Method;

public class PrivateTest2 {
public static void main(String[] args) {
try {
Method method = PrivateTest.class.getDeclaredMethod("print", new Class[]{});
method.setAccessible(true);
Method.invoke(new PrivateTest(), new Object[] {});
} catch (Exception ex) {
System.out.println(ex.toString());
}
}
}
利用java的反射机制,即使是private方法,也可以被调用使用。

Ⅸ 既然Java反射可以访问和修改私有成员变量，那封装成private还有意义么

你没发现反射访问是很费力吗？，private的意义就在于没想让人访问，而JAVA反射的开发在于实现这个功能而已，其实在开发之初也没想到你用反射只是为了访问一个私有的变量。

Ⅹ java反射，调用private的方法

soeasy
Stringpath=“com.test.B”
Classclazz=Class.forName(path);//获得b的反射
Bb=(B)clazz.newInstance();//前提是b类有个无参构造函数
Methodm=clazz.getDeclaredMehod("SetName",String.class);
m.setAccessible(true);//不做安全检查，你才可以去访问私有方法
m.invoke(b,"哈哈");

这里是给B里面的(下面这个方法进行调用赋值)
privatevoidSetName(Strings){}


psgetDeclaredMehod是对私有的方法进行调用要访问必须加setAccessible
getMehod是对通用方法进行调用，不用加setAccessible

导航:首页 > 编程语言 > javaprivate反射

javaprivate反射

与javaprivate反射相关的资料