我必须回答，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”，所以人们认为它不是继承的。然而，类中的每一个非静态的东西，无论是字段还是方法，都是继承的。

例如,

class Person {
    private String name;

    public String getName () {
        return this.name;
    }

    Person(String name) {
        this.name = name;
    }
}

public class Student extends Person {

    Student(String name) {
        super(name);
    }
    
    public String getStudentName() {
        return this.getName(); // works
        // "return this.name;" doesn't work, and the error is "The field Person.name is not visible"

    }
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student("Bill");

        String name = s.getName(); // works
        // "String name = s.name;" doesn't work, and the error is "The field Person.name is not visible"

        System.out.println(name);
    }
}

Yes

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

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

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

这是个好问题!

更新:

呃,“不”

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

更新更新:

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

子类不继承父类的私有成员。但是，如果父类具有用于访问其私有字段的公共或受保护方法，则子类也可以使用这些方法。

不。私有字段没有被继承…所以我们才发明了"保护"这是有意为之。我想这证明了受保护修饰符的存在。

现在来看看上下文。继承是什么意思——如果它存在于从派生类创建的对象中?是的，它是。

如果你的意思是它是否对派生类有用。嗯,没有。

现在，当你进行函数式编程时，父类的私有字段不会以一种有意义的方式继承给子类。对于子类，超类的私有字段与任何其他类的私有字段相同。

在功能上，它不是遗传的。但理想情况是这样的。

好吧，刚刚看了一下Java教程，他们引用了这样的话:

超类中的私人成员 子类不继承父类的私有成员。但是，如果父类具有用于访问其私有字段的公共或受保护方法，则子类也可以使用这些方法。

参见:http://download.oracle.com/javase/tutorial/java/IandI/subclasses.html

我同意，这个领域是存在的。但是，子类在私有字段上没有任何特权。对于子类，私有字段与任何其他类的私有字段相同。

我相信这只是个人观点的问题。你可以左右争论的任何一方。这两种方法都是合理的。

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