《Java成员内部类和静态内部类》

成员内部类的使用：

说明：成员内部类是定义在外部类的成员位置，并且没有 static 修饰。

1 、 可以直接访问外部类的所有成员，包含私有的。

2、 可以添加任意访问修饰符（public 、 protected、默认、private）。因为它的地位就是一个成员。

public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer00 outer00 = new Outer00();
        outer00.print();
    }
}

class Outer00{
    private String name = "张三";
    private int age = 18;

    //1. 注意： 成员内部类是定义在外部类的成员位置
    //2. 可以添加任意访问修饰符（public 、 protected、默认、private）。因为它的地位就是一个成员。
    private class Inner{ // 成员内部类
        public void say(){
            //可以直接访问外部类的所有成员，包含私有的。
            System.out.println("姓名： " + name + "年龄： " + age);
        }
    }
    
    //写方法来调用成员内部类
    public void print(){
        Inner inner = new Inner();
        inner.say();
    }
}

3 、 作用域，和外部类的其他成员一样，为整个类体。在外部类的成员方法中创建成员内部类的对象，在调用该方法（例如上面例子中的print方法）。

4、 成员内部类 - - -访问- - - > 外部类成员（比如属性，方法），访问方式是【直接访问】。

5、 外部类 - - - 访问 - - - > 成员内部类，访问方式是【创建对象，再访问】。

6、 外部其他类 - - - 访问 - - - > 成员内部类，访问方式本质上有两种。

第一种：代码如下。

        Outer00 outer00 = new Outer00();
        
        //outer00.new Inner(); 相当于把 new Inner() 当作是 outer00 的成员
        //这就是一个语法，不必过于纠结。
        Outer00.Inner inner = outer00.new Inner();

第二种，代码如下。

class 外部其他类{ 
  public static void main(String[] args) {
        Outer00 outer00 = new Outer00();

        //第二种方法 ,在外部类中编写一个方法，可以返回Inner对象
        Outer00.Inner innerInstance = outer00.getInnerInstance();
    }
}

class Outer00{  //外部类  
    public class Inner{ // 成员内部类
      
    }
    //编写的方法，可以返回Inner 对象
    public Inner getInnerInstance(){
        return new Inner();
    }
}

 7、 如果外部类和内部类成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以用（外部类名.this.成员）去访问。

class Outer00{
    private String name = "张三";

        private String name = "李四";
        public void say(){
            System.out.println(" 外部类姓名： " + Outer00.this.name + "内部类姓名 " + name);
        }
    }

}

静态内部类的使用

说明，静态内部类是定义在外部类的成员位置，并用static修饰。

1 、 可以直接访问外部类的所有静态方法，包含私有的，但不能直接访问非静态成员。

2 、 可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员。

3 、 作用域，如其他成员，为整个类体。

4、 静态内部类 - - -访问- - - > 外部类（比如静态属性，静态方法），访问方式是【直接访问】。

5、 外部类 - - - 访问 - - - > 静态内部类，访问方式是【创建对象，再访问】。

6、 外部其他类 - - - 访问 - - - > 静态内部类。

public class StaticInnerClass {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        //方式一
        //因为静态内部类，是可以通过类名直接访问（前提是满足访问权限）
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        //方式二
        //编写一个方法，可以返回静态内部类对象实例
        Outer10.Inner10 inner10Instance = outer10.getInner10Instance();
        inner10Instance.say();
    }
}

class Outer10{
    private static String name = "张三";
    
  static class Inner10{

        public void say(){
            System.out.println(name);
        }
    }

    public Inner10 getInner10Instance(){
      return new Inner10();
    }
}

 7、 如果外部类和内部类成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以用（外部类名.成员）去访问。(因为访问的静态成员，所以加this是没有意义的)

class Outer10{
    private static String name = "张三";
  
  static class Inner10{

        private static String name = "李四";
        public void say(){
            System.out.println(name);//李四
            System.out.println(Outer10.name);//张三
        }
    }
}