这取决于你对“继承”的定义。子类在内存中仍然有字段吗?肯定。它能直接访问它们吗?不。这只是定义的微妙之处;关键是要理解到底发生了什么。

Yes

重要的是要认识到，虽然有两个类，但只有一个对象。

当然，它继承了私有字段。它们大概是正确的对象功能所必需的，虽然父类的对象不是派生类的对象，但派生类的实例基本上肯定是父类的实例。如果没有所有的领域，就不可能是这样。

不，你不能直接访问它们。是的，它们是遗传的。他们必须如此。

这是个好问题!

更新:

呃,“不”

我想我们都学到了一些东西。由于JLS提出了确切的“不继承”措辞，所以回答“不继承”是正确的。由于子类不能访问或修改私有字段，因此，换句话说，它们不会被继承。但实际上只有一个对象，它确实包含私有字段，因此如果有人以错误的方式使用JLS和教程措辞，将很难理解OOP、Java对象以及实际发生的事情。

更新更新:

这里的争议涉及到一个根本的模糊:讨论的究竟是什么?的对象?或者我们在某种意义上谈论的是类本身?当描述类而不是对象时，允许有很大的自由度。因此，子类不继承私有字段，但作为子类实例的对象当然包含私有字段。

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成员，那么事情就搞砸了。

好吧，这是一个非常有趣的问题，我研究了很多，得出的结论是，父类的私有成员确实在子类的对象中可用(但不可访问)。为了证明这一点，这里是一个带有父类和子类的示例代码，我正在将子类对象写入txt文件，并在文件中读取名为“bhavesh”的私有成员，因此证明它确实在子类中可用，但由于访问修饰符而不可访问。

import java.io.Serializable;
public class ParentClass implements Serializable {
public ParentClass() {

}

public int a=32131,b,c;

private int bhavesh=5555,rr,weq,refw;
}

import java.io.*;
import java.io.Serializable;
public class ChildClass extends ParentClass{
public ChildClass() {
super();
}

public static void main(String[] args) {
ChildClass childObj = new ChildClass();
ObjectOutputStream oos;
try {
        oos = new ObjectOutputStream(new FileOutputStream("C:\\MyData1.txt"));
        oos.writeObject(childObj); //Writing child class object and not parent class object
        System.out.println("Writing complete !");
    } catch (IOException e) {
    }


}
}

打开MyData1.txt，搜索名为“bhavesh”的私有成员。请告诉我你们的想法。

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(重点是我的)和行为。”

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

我可以试着帮你。 当一个子类(例如命名为B)扩展一个超类(例如命名为a)时，它自动从它的超类继承字段(例如属性和/或方法)。 现在，B在它的内存布局中为类A中的每个字段提供了空间，包括私有字段。事实上，Java不允许子类B使用私有字段，因为它们是私有的。