1. 内部类(嵌套类)

创建内部类非常简单，就是在类中定义另外一个类。
内部类，实际上就是类的嵌套。

/********************************************************************************
*   Java 一个类中可以嵌套另外一个类，语法格式如下：
    class OuterClass {          // 外部类
        // ...
        class InnerClass {      // 嵌套类，或称为内部类
            // ...
        }
    }

    要访问内部类，可以通过创建外部类的对象，然后创建内部类的对象来实现。
    嵌套类有两种类型：
        a. 非静态内部类；
        b. 静态内部类；
* */

2. 非静态内部类

2.1 创建

/*
* 非静态内部类
    非静态内部类是一个类中嵌套着另外一个类。它有访问外部类成员的权限，通常被称为内部类。
    由于内部类嵌套在外部类中，因此必须首先实例化外部类，然后创建内部类的对象来实现。
* */
class Outter {
    private int index = 100;

    public void print() {
        Inner inner = new Inner();
        inner.print();
    }

    class Inner {
        void print() {
            System.out.println(index);
            System.out.println(Outter.this.index);
        }
    }
}

public class App {
    public static void main(String[] args) {
        //
        Outter outter = new Outter();
        outter.print();

        // 创建内部类
        Outter.Inner inner = outter.new Inner();
        inner.print();
    }
}

内部类如何访问外部类成员？
可以通过外部类名称.this的形式来获得外部类对象的引用；
上例中的 System.out.println(Outer.this.index)等价于System.out.println(index);
一般情况下，无需这么麻烦，因为这种关系式隐式建立的，所以不需要显示的去调用"外部类名称.this"的方式去访问外部类成员。
但是，当内部类中的成员和外部类中的成员重名，或者内部类有多层嵌套时，就需要使用外部类名称.this这种方式来显式地指定访问的是哪一个成员，详见下面。

2.2 访问外部类
首先看以下代码。

class outer {
    private int index = 100;
    
    class middle {
        private int index = 99;

        class inner {
            private  int index = 98;

            public void print() {
                System.out.println("outer:> " + outer.this.index);
                System.out.println("middle:> " + outer.middle.this.index);
                System.out.println("inner:> " + index);
            }
        }
    }
}

（1）内部类对象的创建
内部类对象必须通过外部类对象来创建，这样才能建立联系，而不是简单的new；

outer.middle.inner in = new outer.middle.inner(); // 错误

需要通过外部类对象.new 内部类名称这种特殊的语法形式来创建内部类对象。

outer out = new outer();
 outer.middle middle = out.new middle();
 outer.middle.inner in = middle.new inner();
 in.print();

（2）访问index
outer、middle、inner这三个类中都有一个同名的实例变量index，在inner类的print()中，为了能够明确访问的是哪一个index，需要使用"外部类名称.this"的形式来指定引用的变量。

（3）说明
可以看到，内部类对象的创建是比较麻烦的。在实际开发中，如果需要在外部用到内部类对象，
则一般由外部类给出一个获取内部类对象的方法。这样可以，简化内部类对象的创建，还可以对外屏蔽内部类对象的创建细节。

class outer {
    private int index = 100;

    class middle {
        private int index = 99;

        class inner {
            private  int index = 98;

            public void print() {
                System.out.println("outer:> " + outer.this.index);
                System.out.println("middle:> " + outer.middle.this.index);
                System.out.println("inner:> " + index);
            }
        }

        public inner getInner() {
            return new inner();
        }
    }

    public middle getMiddle() {
        return new middle();
    }
}

public class App {
    public static void main(String[] args) {
        outer out = new outer();
        outer.middle.inner in = out.getMiddle().getInner();

        in.print();
    }
}

3. 静态内部类

/*
* 静态内部类
    静态内部类可以使用 static 关键字定义，静态内部类我们不需要创建外部类来访问，可以直接访问它。
    之前非静态内部类的创建格式如下：
    Outter outter = new Outter();
    Outter.Inner inner = outter.new Inner();
    
    现在静态内部类的创建相对非静态内部类的创建就非常简单了：
    Outter.Inner inner = new Outter.Inner();
* */
class Outter {
    int num1 = 10;

    static class Inner  {
        int num2 = 20;
    }
}


public class App {
    public static void main(String[] args) {
        Outter.Inner inner = new Outter.Inner();
        System.out.println(inner.num2);
    }
}

4. 从内部类访问外部类成员

内部类一个高级的用法就是可以访问外部类的属性和方法。

class OutClass {
    int num =100;

    class InnClass {
        public int InnerMethod() {
            return num;
        }
    }
}

public class App {
    public static void main(String[] args) {
        OutClass outCls = new OutClass();
        OutClass.InnClass inner = outCls.new InnClass();
        System.out.println(inner.InnerMethod());
    }
}