1. 作用域和外部类的其他成员一样，为整个类体，可以在外部类的成员方法中创建成员内部类对象，再调用方法。
    2. 成员内部类访问外部类成员（比如：属性），可以直接访问。
    3. 外部类访问成员内部类，访问方式为：创建对象，再访问。
    4. 外部其他类也可以使用成员内部类。 ```java package test;

    public class Main { public static void main(String[] args) { Outer outer = new Outer(); outer.t1();

    1.     System.out.println("==============");
    2.     //外部其他类，使用成员内部类的三种方式
    3.     // 第一种方式(一种特定的语法)
    4.     //相当于把 new Inner()当做是outer成员
    5.     System.out.println("方法一：");
    6.     Outer.Inner inner = outer.new Inner();
    7.     inner.say();
    8.     // 第二方式
    9.     // 在外部类中，编写一个方法，可以返回 Inner对象
    10.     System.out.println("方法二：");
    11.     Outer.Inner inner1 = outer.getInner();
    12.     inner1.say();
    13.     //第三种方式
    14.     System.out.println("方法三：");
    15.     new Outer().new Inner().say();
    16.     System.out.println("==============");
    18. }

    } class Outer { //外部类 private int n1 = 10; public String name = “WTY2002”; private void hi() { System.out.println(“hi()方法…”); }

    1. //1.注意: 成员内部类，是定义在外部内的成员位置上
    2. //2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    3. public class Inner {//成员内部类
    4.     private int n1 = 66;
    5.     private double sal = 99.8;
    6.     public void say() {
    7.         //可以直接访问外部类的所有成员，包含私有的
    8.         //如果成员内部类的成员和外部类的成员重名，会遵守就近原则.
    9.         //可以通过： 外部类名.this.属性 来访问外部类的成员
    10.         System.out.println("n1 = " + n1 + " name = " + name);
    11.         System.out.println("外部类的n1=" + Outer.this.n1);
    12.         hi();
    13.     }
    14. }
    16. //方法，返回一个Inner实例
    17. public Inner getInner(){
    18.     return new Inner();
    19. }
    21. //写方法
    22. public void t1() {
    23.     //使用成员内部类
    24.     //创建成员内部类的对象，然后使用相关的方法
    25.     Inner Inner = new Inner();
    26.     Inner.say();
    27.     System.out.println(Inner.sal);
    28. }

    } ``` image.png