1. 既然java反射可以访问和修改私有成员变量，那封装成private还有意义么
你没发现反射访问是很费力吗？，private的意义就在于没想让人访问，而JAVA反射的开发在于实现这个功能而已，其实在开发之初也没想到你用反射只是为了访问一个私有的变量。
2. java中的反射机制是什么有什么作用呢求解，谢谢。
1. 反射机制是什么
反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
2. 反射机制能做什么
反射机制主要提供了以下功能：
在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法；
在运行时调用任意一个对象的方法；
生成动态代理。
3. 反射机制的相关API
通过一个对象获得完整的包名和类名
packagenet.xsoftlab.ke;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
TestReflecttestReflect=newTestReflect();
System.out.println(testReflect.getClass().getName());
//结果net.xsoftlab.ke.TestReflect
}
}
实例化Class类对象
packagenet.xsoftlab.ke;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>class1=null;
Class<?>class2=null;
Class<?>class3=null;
//一般采用这种形式
class1=Class.forName("net.xsoftlab.ke.TestReflect");
class2=newTestReflect().getClass();
class3=TestReflect.class;
System.out.println("类名称"+class1.getName());
System.out.println("类名称"+class2.getName());
System.out.println("类名称"+class3.getName());
}
}
获取一个对象的父类与实现的接口
packagenet.xsoftlab.ke;
importjava.io.Serializable;
{
=-2862585049955236662L;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
//取得父类
Class<?>parentClass=clazz.getSuperclass();
System.out.println("clazz的父类为："+parentClass.getName());
//clazz的父类为：java.lang.Object
//获取所有的接口
Class<?>intes[]=clazz.getInterfaces();
System.out.println("clazz实现的接口有：");
for(inti=0;i<intes.length;i++){
System.out.println((i+1)+"："+intes[i].getName());
}
//clazz实现的接口有：
//1：java.io.Serializable
}
}
获取某个类中的全部构造函数 - 详见下例
通过反射机制实例化一个类的对象
packagenet.xsoftlab.ke;
importjava.lang.reflect.Constructor;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>class1=null;
class1=Class.forName("net.xsoftlab.ke.User");
//第一种方法，实例化默认构造方法，调用set赋值
Useruser=(User)class1.newInstance();
user.setAge(20);
user.setName("Rollen");
System.out.println(user);
//结果User[age=20,name=Rollen]
//第二种方法取得全部的构造函数使用构造函数赋值
Constructor<?>cons[]=class1.getConstructors();
//查看每个构造方法需要的参数
for(inti=0;i<cons.length;i++){
Class<?>clazzs[]=cons[i].getParameterTypes();
System.out.print("cons["+i+"](");
for(intj=0;j<clazzs.length;j++){
if(j==clazzs.length-1)
System.out.print(clazzs[j].getName());
else
System.out.print(clazzs[j].getName()+",");
}
System.out.println(")");
}
//结果
//cons[0](java.lang.String)
//cons[1](int,java.lang.String)
//cons[2]()
user=(User)cons[0].newInstance("Rollen");
System.out.println(user);
//结果User[age=0,name=Rollen]
user=(User)cons[1].newInstance(20,"Rollen");
System.out.println(user);
//结果User[age=20,name=Rollen]
}
}
classUser{
privateintage;
privateStringname;
publicUser(){
super();
}
publicUser(Stringname){
super();
this.name=name;
}
publicUser(intage,Stringname){
super();
this.age=age;
this.name=name;
}
publicintgetAge(){
returnage;
}
publicvoidsetAge(intage){
this.age=age;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
@Override
publicStringtoString(){
return"User[age="+age+",name="+name+"]";
}
}
获取某个类的全部属性
packagenet.xsoftlab.ke;
importjava.io.Serializable;
importjava.lang.reflect.Field;
importjava.lang.reflect.Modifier;
{
=-2862585049955236662L;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
System.out.println("===============本类属性===============");
//取得本类的全部属性
Field[]field=clazz.getDeclaredFields();
for(inti=0;i<field.length;i++){
//权限修饰符
intmo=field[i].getModifiers();
Stringpriv=Modifier.toString(mo);
//属性类型
Class<?>type=field[i].getType();
System.out.println(priv+""+type.getName()+""+field[i].getName()+";");
}
System.out.println("==========实现的接口或者父类的属性==========");
//取得实现的接口或者父类的属性
Field[]filed1=clazz.getFields();
for(intj=0;j<filed1.length;j++){
//权限修饰符
intmo=filed1[j].getModifiers();
Stringpriv=Modifier.toString(mo);
//属性类型
Class<?>type=filed1[j].getType();
System.out.println(priv+""+type.getName()+""+filed1[j].getName()+";");
}
}
}
通过反射机制调用某个类的方法
packagenet.xsoftlab.ke;
importjava.lang.reflect.Method;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
//调用TestReflect类中的reflect1方法
Methodmethod=clazz.getMethod("reflect1");
method.invoke(clazz.newInstance());
//Java反射机制-调用某个类的方法1.
//调用TestReflect的reflect2方法
method=clazz.getMethod("reflect2",int.class,String.class);
method.invoke(clazz.newInstance(),20,"张三");
//Java反射机制-调用某个类的方法2.
//age->20.name->张三
}
publicvoidreflect1(){
System.out.println("Java反射机制-调用某个类的方法1.");
}
publicvoidreflect2(intage,Stringname){
System.out.println("Java反射机制-调用某个类的方法2.");
System.out.println("age->"+age+".name->"+name);
}
}
通过反射机制操作某个类的属性
packagenet.xsoftlab.ke;
importjava.lang.reflect.Field;
publicclassTestReflect{
privateStringproprety=null;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
Objectobj=clazz.newInstance();
//可以直接对private的属性赋值
Fieldfield=clazz.getDeclaredField("proprety");
field.setAccessible(true);
field.set(obj,"Java反射机制");
System.out.println(field.get(obj));
}
}
4. 反射机制的应用实例
在泛型为Integer的ArrayList中存放一个String类型的对象。
packagenet.xsoftlab.ke;
importjava.lang.reflect.Method;
importjava.util.ArrayList;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
ArrayList<Integer>list=newArrayList<Integer>();
Methodmethod=list.getClass().getMethod("add",Object.class);
method.invoke(list,"Java反射机制实例。");
System.out.println(list.get(0));
}
}
通过反射取得并修改数组的信息
packagenet.xsoftlab.ke;
importjava.lang.reflect.Array;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
int[]temp={1,2,3,4,5};
Class<?>demo=temp.getClass().getComponentType();
System.out.println("数组类型："+demo.getName());
System.out.println("数组长度"+Array.getLength(temp));
System.out.println("数组的第一个元素:"+Array.get(temp,0));
Array.set(temp,0,100);
System.out.println("修改之后数组第一个元素为："+Array.get(temp,0));
}
}
将反射机制应用于工厂模式
packagenet.xsoftlab.ke;
interfacefruit{
publicabstractvoideat();
}
classAppleimplementsfruit{
publicvoideat(){
System.out.println("Apple");
}
}
classOrangeimplementsfruit{
publicvoideat(){
System.out.println("Orange");
}
}
classFactory{
publicstaticfruitgetInstance(StringClassName){
fruitf=null;
try{
f=(fruit)Class.forName(ClassName).newInstance();
}catch(Exceptione){
e.printStackTrace();
}
returnf;
}
}
/**
*对于普通的工厂模式当我们在添加一个子类的时候，就需要对应的修改工厂类。当我们添加很多的子类的时候，会很麻烦。
*Java工厂模式可以参考
*http://ke.xsoftlab.net/view/java-factory-pattern
*
*现在我们利用反射机制实现工厂模式，可以在不修改工厂类的情况下添加任意多个子类。
*
*但是有一点仍然很麻烦，就是需要知道完整的包名和类名，这里可以使用properties配置文件来完成。
*
*java读取properties配置文件的方法可以参考
*http://ke.xsoftlab.net/view/java-read-the-properties-configuration-file
*
*@authorxsoftlab.net
*/
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
fruitf=Factory.getInstance("net.xsoftlab.ke.Apple");
if(f!=null){
f.eat();
}
}
}
我有一个微信公众号，经常会分享一些Java技术相关的干货，还有一些学习资源。
如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。
3. java 怎么用反射访问私有变量
field2.setAccessible(true);
访问之前对访问的属性加上上面这句话才行。
4. Java反射 在只知道类名的情况下，怎样给其中的私有属性赋值
利用反射能
//假设类名为A
//实例化类
Ap=newA();
//获取class
Classc=p.getClass();
//获取该类所有的字段
Field[]fields=c.getDeclaredFields();
//遍历赋值
for(inti=0;i<fields.length;i++){
StringfiledName=fields[i].getName();
//AccessibleTest类中的成员变量为private,故必须进行此操作
fields[i].setAccessible(true);
//判断类型
Class<?>type=fields[i].getType();
//获取字段类型
StringtypeName=type.getName();
System.out.println(type.getName());
//对字段进行赋值第一个参数为对象引用第二个参数为要附的值
//如果为字符串类型
if("java.lang.String".equals(typeName)){
fields[i].set(p,"1");
}
//如果为日期类型
elseif("java.util.Date".equals(typeName)){
fields[i].set(p,newDate());
}
else{
fields[i].set(p,1);
}
}
//楼主我只是简单的写了下。可能还需要判断字段名称以及其他类型什么的。
最后希望楼主多看看java 文档。
5. java 反射 访问父类私有成员
可以看看这个 但是跟反射没什么关系。
利用多态，子类虽然访问不了父类的私有变量，但是可以通过方法访问，see
class a{
private int i = 11;
public void show(){
System.out.println(i);
}
}
class b extends a{
private int j= 12;
public static void main(String[] args){
a aa = new b();
aa.show();
}
}
6. java反射访问私有方法的的问题
java的反射可以绕过访问权限，访问到类的私有方法和成员。可能这点会引起安全性的讨论。反射的使用帮助解决很多复杂的问题，其运行时的类型检查，动态调用，代理的实现等，反射为我们写程序带来了很大的灵活性，很多功能都是基于反射。
利用反射还可以访问内部类、匿名内部类的私有属性。
用java自带的java -private 类名 反编译命令可以查看类的完整定义。（参考think in java）
下面举例子说明。首先定义一个接口
Java代码
public interface Ref {
public void f();
}
public interface Ref {
public void f();
}
接口的实现类
Java代码
public class RefImpl implements Ref {
//实现接口方法
public void f() {
System.out.println("public method f()");
}
void g(String args){
System.out.println("package method g():" + args);
}
private void w(){
System.out.println("private method w()");
}
}
public class RefImpl implements Ref {
//实现接口方法
public void f() {
System.out.println("public method f()");
}
void g(String args){
System.out.println("package method g():" + args);
}
private void w(){
System.out.println("private method w()");
}
}
测试类
Java代码
public class TestRef {
public static void main(String[] args) {
Ref ref = new RefImpl();
System.out.println(ref.getClass().getSimpleName()); //RefImpl类型
ref.f(); //调用接口方法
// ref.g(); //向上转型后实现类添加的方法不能调用
if(ref instanceof RefImpl){
RefImpl ref1 = (RefImpl)ref; //类型识别后转型
ref1.g("zhouyang");
// ref1.w(); //私有方法不能访问
}
//通过反射调用方法
try {
Ref ref2 = new RefImpl();
Method m = ref2.getClass().getDeclaredMethod("f");
Method m1 = ref2.getClass().getDeclaredMethod("g", String.class);//有参的方法
Method m2 = ref2.getClass().getDeclaredMethod("w");
System.out.println("==============");
m.invoke(ref); //调用方法f()
m1.invoke(ref, "yangzhou");
m2.setAccessible(true);///调用private方法的关键一句话
m2.invoke(ref);
} catch (Exception e) {
e.printStackTrace();
}
//java的javap反编译能够查看类的信息，-private 开关能够打开所有信息
//javap -private 类名 类必须是编译成.calss 文件
//利用反射访问私有成员，改变私有成员值，但是final域可以访问不可改变
PrivateField pf = new PrivateField();
// ps.ss; //私有成员不能访问
//打印原来的成员值
pf.print();
try {
//反射访问和改变原来值
Field[] f = pf.getClass().getDeclaredFields();
for(int i=0;i<f.length;i++){
f[i].setAccessible(true);
System.out.println(f[i].getType());//打印字段类型
System.out.println(f[i].get(pf)); //打印值
if("ss".equals(f[i].getName())){
f[i].set(pf, "hehe"); //修改成员值
}else{
f[i].setInt(pf, 55);
}
}
//重新打印修改后的成员值，final域值不变
pf.print();
} catch (Exception e) {
e.printStackTrace();
}
/*打印输出的结果
* RefImpl
public method f()
&nb
7. 一个java对象的属性是私有的，而且没有提供public的get和set方法，可以用反射的方式将其转成json吗
如果提供了get和set方法是可以实现的，因为变量是私有的，只能通过外部公用方法去访问这些变量，如果没有这些方法就只能通过本类访问，其他类没有办法访问