如何访问它的子类一类的私有变量?

这是一个问题,有人问我,在接受采访时:我有A类与私有成员和B类扩展答:我知道一个类的私有成员不能被访问,但问题是:我需要从获得A类的私有成员B级,而不是与在B类相同的值创建变量

--------------解决方案-------------

采访者要么测试您的访问修饰符知识,或者你的方式来改变现有的课程,或两者兼而有之。

我会列出他们(公共,私有,保护,包装私人),每个的解释。 然后去上说,类A将需要被修改,以允许访问那些部件从B级,或者通过添加方法和读,或通过改变构件的访问修饰符。 或B类可以使用反射。 最后,说说每一种方法的优点和缺点。

反射? 省略进口的,这应该工作:

public class A {

private int ii = 23;

}

public class B extends A {

private void readPrivateSuperClassField() throws Exception {
Class<?> clazz = getClass().getSuperclass();
Field field = clazz.getDeclaredField("ii");
field.setAccessible(true);
System.out.println(field.getInt(this));
}

public static void main(String[] args) throws Exception {
new B().readPrivateSuperClassField();
}

}

如果你做这样的事情之前,调用它会无法正常工作readPrivateSuperClassField();

System.setSecurityManager(new SecurityManager() {
@Override
public void checkMemberAccess(Class<?> clazz, int which) {
if (clazz.equals(A.class)) {
throw new SecurityException();
} else {
super.checkMemberAccess(clazz, which);
}
}
});

还有其它条件下的思考方式是行不通的。 请参阅API文档安全管理器和信息AccessibleObject获取更多信息。 感谢CPerkins指出了这一点。

我希望他们只是测试你的知识,而不是找这个东西真正的应用;-)虽然我觉得一个丑陋的黑客攻击这样上面可以合法在某些边缘情况。

该体系结构被破坏。 私有成员都是私有的,因为你不希望他们的阶级和朋友之外的访问。

您可以使用黑客的朋友,存取,促进成员,或#define private public (嘿嘿)。 但这些都是短期的解决方案 - 你很可能将不得不重新审视破架构在某个阶段。

你不能从父类访问私有成员。 你必须让它保护或保护了可以访问他们/ public方法。

编辑:这是真的,你可以使用反射。 但是,这并不是要破坏封装平常,而不是好主意。

通过使用甲的士兵成员的公共存取(吸气和setter方法​​)...

嵌套类可以访问它包围类,字段和方法的所有的私有成员。 因此,公共或受保护的嵌套类继承一个子类有间接访问所有的超类的私有成员。

public class SuperClass
{
private int a = 10;
public void makeInner()
{
SubClass in = new SubClass();
in.inner();
}
class SubClass
{
public void inner()
{
System.out.println("Super a is " + a);
}
}
public static void main(String[] args)
{
SuperClass.SubClass s = new SuperClass().new SubClass();
s.inner();
}
}

通过使用getter和setter方法​​ü可以访问它

你有没有想过让他们保护? 只是要确保你知道这个选项,如果你再原谅我带来了这个琐事;)

如果我理解正确的问题,你可以改变privateprotected 。 受保护的变量是在子类中,但表现得像私有变量,否则。

  • 私有成员不能在派生类中被访问
  • 如果您要访问意味着您可以使用getter和setter方法​​。

class A
{
private int a;
void setA(int a)
{
this.a=a;
}
int getA()
{
return a;
}
}

Class B extends A
{
public static void main(String[] arg)
{
B obj= new B();
obj.setA(10);
System.out.println("The value of A is:"+obj.getA());
}
}

您可以使用setter和A级。这给人同样的感觉,如果你使用的是A类的对象的干将。

个人将被隐藏,直到您已获得正确的访问。 对于由谁写的父编程实例吸气或setter方法​​。 如果它们不是由可见不论当时接受这个事实,他们只是私人和无法接触到你。 到底为什么要这么做?

我不知道Java的,但在某些语言中的嵌套类型可以这样做:

class A {
private string someField;
class B : A {
void Foo() {
someField = "abc";
}
}
}

否则,使用的存取方法或protected领域(虽然他们经常被滥用)。

专用成员在子类中,你不能改变变量的方式访问,但你可以访问该变量为只读。

很显然,这使得它们的保护,或添加的setter /吸气剂是优选的技术。 反射是一种无奈之下的选择。

只是为了炫耀给面试官,如果“准入”是指读访问,以及如果一个类生成XML或JSON等,你可以序列化和解析有趣的领域。

Class A
{
private int i;

int getValue()
{
return i;
}
}
class B extends A
{
void getvalue2()
{
A a1= new A();
sop(a1.getValue());
}
}

要访问子类的父类的私有变量,你可以使用受保护或添加getter和setter私有变量父类..

从JLS§8.3。 域声明:

超类的私人领域可能是访问一个子类 - 例如,如果两个类是同一类的成员。 然而,一个私有字段是永远不会由子类继承。

我写的示例代码:

public class Outer
{
class InnerA
{
private String text;
}
class InnerB extends InnerA
{
public void setText(String text)
{
InnerA innerA = this;
innerA.text = text;
}
public String getText()
{
return ((InnerA) this).text;
}
}
public static void main(String[] args)
{
final InnerB innerB = new Outer().new InnerB();
innerB.setText("hello world");
System.out.println(innerB.getText());
}
}

的可访问性的解释InnerA.text在这里JLS§6.6.1。 确定辅助功能:

否则,成员或构造函数声明为私有的,并且允许访问,当且仅当它发生时封闭的成员或构造的声明顶层类(§7.6)的体内。

从外部直接您无法直接访问类的任何私有变量。

您可以访问私有成员的使用getter和setter。

方法来访问超类的私有成员在子类:

  1. 如果你想包访问只是改变私人领域的保护。 它允许访问同一包中的子类。
  2. 如果您有私人领域则只是提供一些存取方法(getter方法​​),你可以访问它们在你的子类。
  3. 你也可以用内部类如:

    public class PrivateInnerClassAccess {
    private int value=20;

    class InnerClass {

    public void accessPrivateFields() {
    System.out.println("Value of private field : " + value);
    }

    }

    public static void main(String arr[])
    {
    PrivateInnerClassAccess access = new PrivateInnerClassAccess();
    PrivateInnerClassAccess.InnerClass innerClass = access.new InnerClass();
    innerClass.accessPrivateFields();

    }

    }

    4。您也可以使用反射如

    public class A {
    private int value;
    public A(int value)
    {
    this.value = value;
    }
    }

    public class B {
    public void accessPrivateA()throws Exception
    {
    A a = new A(10);
    Field privateFields = A.class.getDeclaredField("value");
    privateFields.setAccessible(true);
    Integer value = (Integer)privateFields.get(a);
    System.out.println("Value of private field is :"+value);
    }

    public static void main(String arr[]) throws Exception
    {
    B b = new B();
    b.accessPrivateA();
    }
    }

直接我们不能访问它。 但使用setter和getter我们可以访问,

代码为:

class AccessPrivate1 {

private int a=10; //private integer
private int b=15;
int getValueofA()
{
return this.a;

}

int getValueofB()
{
return this.b;
}
}

public class AccessPrivate{
public static void main(String args[])
{
AccessPrivate1 obj=new AccessPrivate1();

System.out.println(obj.getValueofA()); //getting the value of private integer of class AccessPrivate1

System.out.println(obj.getValueofB()); //getting the value of private integer of class AccessPrivate1
}
}

您可以在代码中使用访问器 (getter和setter方法)。

通过使用setter方法​​,你可以使用其他与恢复体力的帮助下,你可以通过设置该成员说,使用类的私有成员 - 从类需要并设置a.setAccessible(真);

您可能需要将其更改为受保护。 请参阅本

https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html

如果这是你必须做的,不惜任何代价只是做它,你可以使用反射的挫折感。 它会给你所有的课堂中定义的变量列表中无论是公共,私人或保护。 这当然有它的开销,但,是的,这是什么,这将让你使用私有变量。 有了这个,你可以在任何类中使用它。 它不必是仅仅一个子类,请参考下面的例子。 这可能有一些编译问题,但你可以得到的基本思路和它的工作原理

private void getPropertiesFromPrivateClass(){

Field[] privateVariablesArray = PrivateClassName.getClass().getDeclaredFields();
Set<String> propertySet = new HashSet<String>();
Object propertyValue;
if(privateVariablesArray.length >0){
for(Field propertyVariable :privateVariablesArray){
try {

if (propertyVariable.getType() == String.class){
propertyVariable.setAccessible(true);
propertyValue = propertyVariable.get(envtHelper);
System.out.println("propertyValue");
}
} catch (IllegalArgumentException illegalArgumentException) {
illegalArgumentException.printStackTrace();

} catch (IllegalAccessException illegalAccessException) {
illegalAccessException.printStackTrace();

}
}

希望这是一些帮助。 快乐学习:)

请注意,一个超类的一个私有字段可能是可访问的一个子类(例如,如果这两个类是同一类的承包商,​​客人),然而,一个私人域被从未由子类继承

简单!!!

public class A{
private String a;
private String b;
//getter and setter are here
}



public class B extends A{
public B(String a, String b){ //constructor
super(a,b)//from here you got access with private variable of class A
}
}

谢谢

改性剂添加到这些定义,要改变它们的含义的关键词。 Java语言有各种各样改性剂,其中包括以下内容:

  • Java访问修饰符
  • 非访问修饰符

要使用的改性剂,则其包含在一类,方法或变量的定义关键字。 在修改之前声明的其余部分。

这里有更多的信息:

http://tutorialcorejava.blogspot.in/p/java-modifier-types.html

分类:java的 时间:2015-03-15 人气:0
本文关键词: Java中,核心
分享到:

相关文章

Copyright (C) 55228885.com, All Rights Reserved.

55228885 版权所有 京ICP备15002868号

processed in 0.958 (s). 10 q(s)