1. /*
   
2.         成员内部类的修饰符：
   
3.                 private 为了保证数据的安全性
   
4.                 static 为了方便访问数据
   
5.                         注意：静态内部类访问的外部类数据必须用静态修饰。
   
6. */
   
7. class Outer {
   
8.         private int num = 10;
   
9.         private static int num2 = 100;
   
10.        
    
11.         //内部类用静态修饰是因为内部类可以看出是外部类的成员
    
12.         public static class Inner {
    
13.                 public void show() {
    
14.                         //System.out.println(num);
    
15.                         System.out.println(num2);
    
16.                 }
    
17. 
    
18.                 public static void show2() {
    
19.                         //System.out.println(num);
    
20.                         System.out.println(num2);
    
21.                 }               
    
22.         }
    
23. }
    
24. 
    
25. class InnerClassDemo4 {
    
26.         public static void main(String[] args) {
    
27.                 //使用内部类
    
28.                 // 限定的新静态类
    
29.                 //Outer.Inner oi = new Outer().new Inner();
    
30.                 //oi.show();
    
31.                 //oi.show2();
    
32.                
    
33.                 //成员内部类被静态修饰后的访问方式是:
    
34.                 //格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
    
35.                 Outer.Inner oi = new Outer.Inner();
    
36.                 oi.show();
    
37.                 oi.show2();
    
38.                
    
39.                 //show2()的另一种调用方式
    
40.                 Outer.Inner.show2();
    
41.         }
    
42. }

复制代码

       
        案例：我有一个人(人有身体，身体内有心脏。)
               
                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();
               
                Body b =  new Body();
                b.method();
*/

1.  成员内部类
                1.1:private 为了数据的安全性
                1.2:static 为了访问的方便性
                格式：
                成员内部类不是静态的：
                        外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
                成员内部类是静态的：
                        外部类名.内部类名 对象名 = new 外部类名.内部类名();

2.        局部内部类
                2.1:局部内部类访问局部变量必须加final修饰。
                因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。所以，堆内存还是用该变量，而改变量已经没有了。为了让该值还存在，就加final修饰。