/*

     内部类概述:

         把类定义在其他类的内部，这个类就被称为内部类。

         举例：在类A中定义了一个类B，类B就是内部类。

     内部的访问特点：

         A:内部类可以直接访问外部类的成员，包括私有。

         B:外部类要访问内部类的成员，必须创建对象。

 */

 class Outer {

     private int num = 10;

     class Inner {

         public void show() {

             System.out.println(num);

         }

     }

     public void method() {

         //找不到符号

         //show();

         Inner i = new Inner();

         i.show();

     }

 }

 class InnerClassDemo {

     public static void main(String[] args) {

     }

 }

 /*

     内部类位置

         成员位置:在成员位置定义的类，被称为成员内部类。

         局部位置:在局部位置定义的类，被称为局部内部类。

     成员位置:在成员位置定义的类，被称为成员内部类。    

 */

 class Outer {

     private int num = 10;

     //成员位置

     /*

     class Inner {

     }

     */

     public void method() {

         //局部位置

         class Inner {

         }

     }

 }

 class InnerClassDemo2 {

     public static void main(String[] args) {

     }

 }

 /*

     成员内部类:

         如何直接访问内部类的成员。

         外部类名.内部类名 对象名 = 外部类对象.内部类对象;

 */

 class Outer {

     private int num = 10;

     class Inner {

         public void show() {

             System.out.println(num);

         }

     }

 }

 class InnerClassDemo3 {

     public static void main(String[] args) {

         //需求：我要访问Inner类的show()方法

         //Inner i = new Inner();

         //i.show();---这样的方式是错误的

         //格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;

         Outer.Inner oi = new Outer().new Inner();

         oi.show();

     }

 }

 /*

     成员内部类的修饰符：

         private 为了保证数据的安全性

         static 为了方便访问数据

             注意：静态内部类访问的外部类数据必须用静态修饰。

     案例：我有一个人(人有身体，身体内有心脏。)

         class Body {

             private class Heart {

                 public void operator() {

                     System.out.println("心脏搭桥");

                 }

             }

             public void method() {

                 if(如果你是外科医生) {

                     Heart h = new Heart();

                     h.operator();

                 }

             }

         }

         按照我们刚才的讲解，来使用一下

         Body.Heart bh = new Body().new Heart();

         bh.operator();//但是我们是不希望外界对我们自己身体内部"心脏"进行操作的，怎么样才能实现这个？

         //加了private后，就不能被访问了，那么，怎么玩呢?

         Body b =  new Body();

         b.method();

 */

 class Outer {

     private int num = 10;

     private static int num2 = 100;

     //内部类用静态修饰是因为内部类可以看出是外部类的成员

     public static class Inner {

         public void show() {

             //System.out.println(num);//静态内部类访问外部类数据必须是静态修饰的，num不是静态，所以不能访问，num2可以访问

             System.out.println(num2);

         }

         public static void show2() {

             //System.out.println(num);

             System.out.println(num2);

         }

     }

 }

 class InnerClassDemo4 {

     public static void main(String[] args) {

         //使用内部类

         // 限定的新静态类，下面这样写法是错误的，内部类加了静态static修饰之后，是不能通过外部对象访问的，直接调用类名访问

         //Outer.Inner oi = new Outer().new Inner();

         //oi.show();

         //oi.show2();

         //成员内部类被静态修饰后的访问方式是:

         //格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

         Outer.Inner oi = new Outer.Inner();

         oi.show();

         oi.show2();

         //show2()的另一种调用方式

         Outer.Inner.show2();

     }

 }

 /*

     面试题：

         要求请填空分别输出30，20，10。

     注意：

         1:内部类和外部类没有继承关系。

         2:通过外部类名限定this对象

             Outer.this

 */

 class Outer {

     public int num = 10;

     class Inner {

         public int num = 20;

         public void show() {

             int num = 30;

             System.out.println(num);

             System.out.println(this.num);

             //System.out.println(new Outer().num);//这个是也是可以实现的

             System.out.println(Outer.this.num);

         }

     }

 }

 class InnerClassTest {

     public static void main(String[] args) {

         Outer.Inner oi = new Outer().new Inner();

         oi.show();

     }

 }