首先，Java官方文档中明确表示私有成员【即私有属性（field）和私有方法（method）】不会被继承。
    image.png

    Only members of a class that are declared protected or public are inherited by subclasses declared in a package other than the one in which the class is declared. Constructors, static initializers, and instance initializers are not members and therefore are not inherited.

    image.png

    但是对于那句话，不同的人有不同的理解；
    举个例子：

    1. import org.openjdk.jol.info.ClassLayout;
    2. import org.junit.Test;
    3. import org.openjdk.jol.info.ClassLayout;
    4. import java.lang.reflect.Field;
    5. import java.util.ArrayList;
    6. import java.util.Arrays;
    7. import java.util.List;
    9. public class Apptext{
    10.     @Test
    11.     public void toTest(){
    12.         ExtendPerson extendPerson = new ExtendPerson();
    13.         System.out.println(ClassLayout.parseInstance(extendPerson).toPrintable());
    14.     }
    15. }
    16. class Person {
    17.     private String name ="ahzoo";
    18.     public Person() {}
    19.     public Person(String name){System.out.println(name);}
    20.     private String getName() {return name;}
    21. }
    22. class ExtendPerson extends Person {
    23.     public ExtendPerson() {}
    24. }


    ClassLayout需要引入依赖：

    1.     <dependency>
    2.       <groupId>org.openjdk.jol</groupId>
    3.       <artifactId>jol-core</artifactId>
    4.       <version>0.8</version>
    5.     </dependency>

    image.png
    从上面的例子中可以看出，父类的私有成员在子类的内存中是出现了的

    再举个例子：

    1.  public class AppTest{
    2.     @Test
    3.     public void toTest2() throws Exception {
    4.         ExtendPerson extendPerson = new ExtendPerson();
    5.         extendPerson.doGet();
    6.     }
    7. }
    8. class Person {
    9.     private String name ="ahzoo";
    10.     public Person() {}
    11.     private String getName() {
    12.         return name;
    13.     }
    14.     private void setName(String name) {
    15.         this.name = name;
    16.     }
    17.     public void doGet(){
    18.         System.out.println(getName()); //ahzoo
    19.     }
    20. }
    22. class ExtendPerson extends Person {
    23.     public ExtendPerson() {}
    24. }

    image.png
    从这个例子中可以看出，子类是可以获得父类的私有成员的
    其它操作父类私有成员的方法：

    1. public class AppTest{
    2.      /**
    3.      * 使用反射获取父类私有属性
    4.      */
    5.     @Test
    6.     public void myTest() {
    8.         Class clazz = ExtendPerson.class;
    9. //        ExtendPerson person = (ExtendPerson) clazz.newInstance();
    10.         List fieldsList = new ArrayList<Field>();
    11.         // 获遍历所有父类
    12.         for(; clazz != Object.class ; clazz = clazz.getSuperclass()) { 
    13.             Field[] declaredFields = clazz.getDeclaredFields();
    14.             // 保存得到的属性
    15.             fieldsList.addAll(Arrays.asList(declaredFields));  
    16.         }
    18.         // 遍历获得的属性
    19.         for (Object field : fieldsList) {  
    20.             System.out.println(field); // private java.lang.String org.example.Person.name
    21.         }
    22.     }
    23.     /**
    24.      * 使用super获取操作父类私有成员
    25.      */
    26.     @Test
    27.     public void toTest2() {
    28.         ExtendPerson extendPerson = new ExtendPerson("ouo"); //将打印 ---ouo---
    29.     }
    30. }
    31. class Person {
    32.     private String name ="ahzoo";
    33.     public Person() {}
    34.     public Person(String name){System.out.println("---" + name + "---");}
    35.     private String getName() {return name;}
    36.     private void setName(String name) {this.name = name;}
    37.     public void doGet(){System.out.println(getName());}
    38. }
    40. class ExtendPerson extends Person {
    41.     public ExtendPerson() {}
    42.     public ExtendPerson(String name) {super(name);}
    43. }

    总结下上面的例子：

    1. 子类的内存中出现了父类的属性
    2. 虽然子类不能直接操作父类属性，但是可以通过间接的方式操作（父类提供的公共方法、super方法或者反射）

    以次可以推断出，子类确实是继承了父类的私有成员的。

    但是我还是更偏向于Java官方文档的说法：

    A subclass does not inherit the private members of its parent class. However, if the superclass has public or protected methods for accessing its private fields, these can also be used by the subclass.

    即：子类不会继承其父类的私有成员。但是，如果父类中具有能访问其私有字段的public或project修饰的方法，则子类也可以使用这些方法获取其私有成员。
    image.png

    回顾下继承性：
    子类继承父类时会在子类的构造器会在执行之前，使用super方法调用父类的构造器；
    同理，在调用父类构造器时，父类构造器又会在执行之前调用子类父类的父类的构造器……以次造成连锁反应，直到调用到Object类的构造器为止；
    每个类都会在其自身构造器执行之前完成父类构造器的执行，而构造器的作用就是获取其所在类的所有属性和方法，这其中自然也就包括了私有的。
    对此，我的理解是：
    子类对象在实例化时，调用到了父类的构造器，而父类构造器在执行时自然也就把其成员给初始化了，初始化到哪里了呢？自然是内存中，这也是为什么子类的内存中可以看到父类的私有成员；
    但是由于封装性的原理，私有成员只能在自己的类中使用，所以子类是无法在自己的类中使用父类的私有成员的，既然无法使用，那我说他没有继承，也没什么问题吧；
    这不就完美体现了继承性吗，所以再回到刚才那句Java官方文档对继承性就很合理了。

    再举个通俗的例子：
    儿子从父亲那里得到（继承）了很多东西，包括一栋房子，房子里有父亲的房间，由于父亲的房间属于私人空间，所以不能随意进入，需要从父亲那里拿到钥匙才能进入（钥匙就相当于父类的get方法），或者是父亲带你进去（super方法），亦或是找个开锁师傅（反射）；那么儿子到底有没有继承这个房间呢？我的观点是没有。
    image.png

    Java文档：
    https://docs.oracle.com/javase/specs/index.html

    https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html
    https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html