通过Java中的反射访问抽象类中的子字段

Question

I have 2 classes:

public abstract class AbstractTestClass {
    private String abstractString = "abstract";
    public void showFields() throws IllegalAccessException{
        for (Field field : this.getClass().getDeclaredFields()) {
            System.out.println(field.get(this));
        }
    }
}

public class TestClass extends AbstractTestClass {
    private String concreteString = "concreteString";
}

And test:

public class MainTest {
    public static void main(String[] args) throws IllegalAccessException{
        TestClass test = new TestClass();
        test.showFields();
    }
}

Running this test causes next exception:

java.lang.IllegalAccessException: Class AbstractTestClass can not access a member of class TestClass with modifiers "private"

When i'm debuging code, this contains instance of TestClass.

Questions:

1. Why does it happen?
2. How to make this code work, not using Field.setAccessible() or changing visibility of fileds?

Answer 1

How to make this code work, not using Field.setAccessible() or changing visibility of fileds?

You can't, you have to make the field accessible to use it

Answer 2

I believe you are making the same mistake I made when I was starting out: that the abstract class and the extending class are two piece welded together to form a single class with access to all of each others fields and methods etc.

Sadly, this is not true: inheritance is a closer relationship that in a normal parent-child object, but access rules must still be obeyed eg if a method is declared protected in the abstract class and the extending class is in a different package, then it cannot be accessed (and vice versa).

Because the method showFields() is defined in AbstractTestClass , it can only access the fields in that class. Fields in TestClass are essentially walled off.

The only way around it that I can think of is to override showFields() in TestClass , swallow any exceptions about not being able to access private fields, then call super.showFields() and swallow any exceptions again. Not pretty.

public abstract class AbstractTest {
  private String abstractString = "abstract";
  public void showFields() throws IllegalAccessException {
    for (Field field : this.getClass().getSuperclass().getDeclaredFields()) {
      try {
        System.out.println(field.get(this));
      }
      catch (IllegalAccessException e) { 
        // swallow 
      }
    }
  }
}

public class MyTest extends AbstractTest
{
  private String concreteString = "concreteString";
  @Override public void showFields() throws IllegalAccessException {
    for (Field field : this.getClass().getDeclaredFields()) {
      try {
        System.out.println(field.get(this));
      }
      catch (IllegalAccessException e) {  
        // swallow
      }
    }
    super.showFields();
  }
}

I doubt this is what you had in mind...