下面使用以下代码讲解成员内部类的继承
package test7;
//第一步，引入内部类定义。无论该类是否如子类在同一个包下还是同一个文件下。
import test7.Person.Address;
public class ExtendsInnerClassTest {
public static void main(String[] args) {
Person p1 = new Person("forestqqqq",20);
new AddressDetail(p1,"TianJin","HeXi",1234).printAddress();
}
}
//外部类Person
class Person{
private String name;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
//内部类Address
public class Address{
private String city;
private String street;
private int number;
public Address(String city,String street,int number) {
this.city = city;
this.street = street;
this.number = number;
}
public Address(int number){
this.city = "TianJin";
this.street = "HeXi";
this.number = number;
}
public void printAddress(){
System.out.println(name+"'s age is "+age+" and Address is "+city+","+street+number);
}
}
}
//第二步，使用extends关键字，子类继承该内部类。
//内部类的子类AddressDetail
class AddressDetail extends Address{
//第三步，给子类的每一个构造方法传递一个参数，即外部类实例。
//（其实这一步是为第四步做准备的，只要第四步能够实现，这一步是可以省略的，
//也就是说，并不是每一个构造方法都需要传入外部类实例的，只要它能够实现第四步）
public AddressDetail(
Person p, //******这就是传入的的父类实例
String city,String street,int number){
//第四步，直接或间接（这里是直接）实例化父类内容
p.super(city,street,number);
}
//这个第三步省略了
public AddressDetail(){
//第四步，直接或间接（这里是间接）实例化父类内容
this(new Person("forestqqqq",20),"TianJin","HeXi",1234);
}
}
第一 继承成员内部类的步骤(看代码和注释)
1import该类
2继承该类
3在每一个构造方法中添加一个参数，即外部类对象
4在构造方法的第一句，直接或间接的调用外部类对象的super方法，初始化父类内容
第二分析成员内部类的继承方式
想弄明白成员内部类的继承方式应该依次弄清楚以下这些知识点：
1内部类是Java语法规范，不是虚拟机规范。虚拟机不清楚Java语法中是否有内部类这种东西，也没精力去维护内部类与外部类之间的复杂的关系。虚拟机只是乐于加载一个又一个的class文件，而且它只知道每一个class文件就代表者一个单独的类就行了。
2内部类与外部类之间的复杂的关系，是在编译器编译java文件成为class文件时生成的。编译器将一文件中的每一个类（内部类或者外部类）分别编译成为不同的class文件。如上例中，编译之后生成4个class文件，即，ExtendsInnerClassTest.class、Person.class、Person$Address.class和AddressDetail.class。其中Person.class是外部类Person的class文件，Person$Address.class是内部类的class文件。
3编译器是通过改造内部类和外部类的构造方法、普通方法和属性定义来实现两个类之间的复杂联系的。
外部类Person反编译之后的结果：
class Person{
public Person(String name,int age){
//..
}
static String access$0(Person p){
return ..;
}
static int access$1(Person p){
return ..;
}
private String name;
private int age;
}
内部类Address反编译之后的结果：
class Person$Address{
public Person$Address(Person p,String city,String street,int number){
//..
}
public Person$Address(Person p,int number){
//..
}
public void printAddress(){
System.out.println(Person.access$0(this.this$0) + "'s age is " + Person.access$1(this.this$0) + " and Address is " + this.city + "," + this.street + this.number);
}
private String city;
private String street;
private int number;
final Person this$0;
}
从代码上我们看到外部类Person中多了两个静态方法access$0和access$1，它们分别返回的是name和age，这两个方法是在编译时动态生成的，如果内部类中没有访问到name和age这两个外部类的属性，则这两个静态方法不会生成。正是因为内部类的printAddress方法中使用到了这两个属性，所以才就生成了这两个静态方法。
我们还看到内部类中多了一个外部类的引用属性：
final Person this$0;
这个属性保证了内部类与外部类的关联。
我们还看到，编译器改造了内部类的每一个构造方法，为每一个构造方法提供了一个外部类实例作为参数，实际上这个参数是用来初始化this$0这个属性的。这就保证了实例化内部类前必须实例化外部类对象。内部类就好像粘附在外部类实例上一样，外部类的实例总是先于内部类实例存在。
4子类继承内部类也需要保证外部类实例先于内部类实例存在。所以子类实例的初始化顺序是，首先初始化外部类实例，然后初始化内部类内容，最后初始化子类独有的内容。因为经过编译器的改造后，内部类Address没有无参的构造方法，所以子类必须直接或者间接的调用父类的构造方法，但是父类每一个构造方法（经过改造后的）都要求有外部类的实例作为参数，所以，你必须给子类构造方法一个外部类实例。其实这是上面第三步和第四步的要求。
第四步的代码：
p.super(city,street,number);
是调用的内部类的构造方法，其实它在经过编译器改造之后是
super(p,city,street,number)
目的就是实例化父类（内部类）的内容。
总结起来就一句话，父类内容先于子类内容存在，外部类内容先于内部类内容存在