我们可以简单地声明，当父类被继承时，父类的私有成员实际上成为子类的私有成员，并且不能被进一步继承或子类的对象不可访问。

Well, my answer to interviewer's question is - Private members are not inherited in sub-classes but they are accessible to subclass or subclass's object only via public getter or setter methods or any such appropriate methods of original class. The normal practice is to keep the members private and access them using getter and setter methods which are public. So whats the point in only inheriting getter and setter methods when the private member they deal with are not available to the object? Here 'inherited' simply means it is available directly in the sub-class to play around by newly introduced methods in sub-class.

将下面的文件保存为ParentClass.java并自己尝试它->

public class ParentClass {
  private int x;

  public int getX() {
    return x;
  }

  public void setX(int x) {
    this.x = x;
  }
}

class SubClass extends ParentClass {
  private int y;

  public int getY() {
    return y;
  }

  public void setY(int y) {
    this.y = y;
  }

  public void setXofParent(int x) {
    setX(x); 
  }
}

class Main {
  public static void main(String[] args) {
    SubClass s = new SubClass();
    s.setX(10);
    s.setY(12);
    System.out.println("X is :"+s.getX());
    System.out.println("Y is :"+s.getY());
    s.setXofParent(13);
    System.out.println("Now X is :"+s.getX());
  }
}

Output:
X is :10
Y is :12
Now X is :13

如果我们尝试在子类的方法中使用ParentClass的私有变量x，那么它不能被任何修改直接访问(意味着不能继承)。但是x可以通过原始类的setX()方法在子类中修改，就像在setXofParent()方法中做的那样，或者可以使用ChildClass对象使用setX()方法或setXofParent()方法修改，最终调用setX()。这里setX()和getX()是一种通往ParentClass的私有成员x的门。

另一个简单的例子是Clock超类将hours和min作为私有成员，将适当的getter和setter方法作为公共方法。然后是数字时钟作为时钟的子类。在这里，如果DigitalClock的对象不包含hours和mins成员，那么事情就搞砸了。

It would seem that a subclass does inherit the private fields in that these very fields are utilized in the inner workings of the subclass (philosophically speaking). A subclass, in its constructor, calls the superclass constructor. The superclass private fields are obviously inherited by the subclass calling the superclass constructor if the superclass constructor has initialized these fields in its constructor. That's just an example. But of course without accessor methods the subclass cannot access the superclass private fields (it's like not being able to pop the back panel of an iPhone to take the battery out to reset the phone... but the battery is still there).

PS 我遇到的关于继承的许多定义之一是: “继承——一种编程技术，允许派生类扩展基类的功能，继承其所有的STATE(重点是我的)和行为。”

私有字段即使不能被子类访问，也是父类的继承状态。

私有成员(状态和行为)是继承的。它们(可以)影响类实例化的对象的行为和大小。更不用说，通过所有可用的封装破坏机制，或者它们的实现者可以假定，子类可以很好地看到它们。

虽然继承有一个“事实上的”定义，但它肯定与“可见性”方面没有联系，这是“不”答案所假设的。

所以，没有必要采取外交手段。JLS在这一点上是错误的。

任何认为他们不是“遗传”的假设都是不安全的和危险的。

因此，在两个事实上(部分)相互冲突的定义(我不会重复)中，唯一应该遵循的是更安全(或安全)的定义。

我必须回答，Java中的私有字段是继承的。请允许我演示一下:

public class Foo {

    private int x; // This is the private field.

    public Foo() {
        x = 0; // Sets int x to 0.
    }

    //The following methods are declared "final" so that they can't be overridden.
    public final void update() { x++; } // Increments x by 1.
    public final int getX() { return x; } // Returns the x value.

}


public class Bar extends Foo {

    public Bar() {

        super(); // Because this extends a class with a constructor, it is required to run before anything else.

        update(); //Runs the inherited update() method twice
        update();
        System.out.println(getX()); // Prints the inherited "x" int.

    }

}

如果你在一个程序中运行Bar Bar = new Bar();，那么你总是会在输出框中看到数字“2”。由于整数“x”被update()和getX()方法封装，因此可以证明该整数是继承的。

令人困惑的是，因为不能直接访问整数“x”，所以人们认为它不是继承的。然而，类中的每一个非静态的东西，无论是字段还是方法，都是继承的。

我们可以简单地声明，当父类被继承时，父类的私有成员实际上成为子类的私有成员，并且不能被进一步继承或子类的对象不可访问。