4.9 内部类

4.9 内部类
定义：
将一个类定义在另一个类的里面，里面那个类就称为内部类（内置类，嵌套类）。
访问特点：
内部类可以直接访问外部类中的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。
    示例1：
01.  /*
02.  内部类的设计：
03.  分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时候就定义
内部类。
04.  */
05.  classOuter{
06.  privateintnum=3;
07. 
08.  classInner//内部类
09.  {
10.  voidshow(){
11.  System.out.println("showrun..."+num);
12.  }
13.  }
14. 
15.  publicvoidmethod(){
16.  Innerin=newInner();
17.  in.show();
18.  }
19.  }
20. 
21.  classInnerClassDemo{
22.  publicstaticvoidmain(String[]args){
23.  Outerout=newOuter();
24.  out.method();
25.  }
26.  }
复制代码
运行结果：
    示例2：  
01.  class Outer{
02.         private int num = 3;
03. 
04.         class Inner
05.         {
06.               void show(){
07.                    System.out.println("show run..." + num);
08.               }
09.         }
10.  }
11. 
12.  class InnerClassDemo{13.         public static void main(String[] args){
14.               //直接访问外部类中的内部类中的成员
15.              Outer.Inner in = new Outer().new Inner();
16.              in.show();
17.         }
18.  }
复制代码
运行结果：
内部类的位置：
内部类定义在成员位置上，可以被private、static成员修饰符修饰。被static修饰的内部类只能访问外部类中
的静态成员。
    示例1：
01.  class Outer{
02.         private static int num = 3;
03. 
04.         static class Inner
05.         {
06.               void show(){
07.                    System.out.println("show run..." + num);
08.               }
09.         }
10.  }
11. 
12.  class InnerClassDemo{
13.         public static void main(String[] args){
14.               //如果内部类是静态的，相当于一个外部类
15.              Outer.Inner in = new Outer.Inner();
16.              in.show();
17.         }
18.  }
复制代码
运行结果：

    示例2：如果内部类是静态的，内部类成员也是静态的，可以不用创建内部类对象，直接调用。
01.  class Outer{
02.         private static int num = 3;
03. 
04.         static class Inner
05.         {
06.               static void show(){
07.                    System.out.println("show run..." + num);
08.               }
09.         }
10.  }
11. 
12.  class InnerClassDemo{
13.         public static void main(String[] args){
14.              Outer.Inner.show();
15.         }
16.  }
复制代码
运行结果：
P.S.
1、如果内部类中定义了静态成员，该内部类也必须是静态的！
    示例：
01.  class Outer{
02.       private static int num = 3;
03. 
04.       static class Inner
05.       {
06.            static void show(){
07.                 System.out.println("show run..." + num);
08.            }
09.       }
10.  }
复制代码
2、为什么内部类能直接访问外部类中的成员呢？
那是因为内部类持有了外部类的引用，外部类名.this。
    示例：
01.  class Outer{
02.         int num = 3;
03.         class Inner{
04.               int num = 4;
05.               void show(){
06.                     int num = 5;
07.                     System.out.println(num);
08.                     System.out.println(this.num);
09.                     System.out.println(Outer.this.num);
10.               }
11.         }
12.         void method(){
13.               new Inner().show();
14.         }
15.  }
16. 
17.  class InnerClassDemo{
18.         public static void main(String[] args){
19.               new Outer().method();
20.         }
21.  }
复制代码
运行结果：
3、内部类定义在局部位置上，也可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量，但必须是被final修饰的。
    示例：
01.  class Outer{
02.         int num = 3;
03.         void method(final int y){
04.               final int x = 9;
05.               class Inner{
06.                     void show(){
07.                          System.out.println("show..." + x + "," + y);
08.                     }
09.               }
10.              Inner in = new Inner();
11.              in.show();
12.         }
13.  }
14. 
15.  class InnerClassDemo{
16.         public static void main(String[] args){
17.               new Outer().method(4);
18.         }
19.  }
复制代码
运行结果：
     匿名内部类
定义：
就是内部类的简化写法。
前提：
内部类可以继承或实现一个外部类或者接口。
格式：
new外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}
简单理解：
就是建立一个带内容的外部类或者接口的子类匿名对象。
什么时候使用匿名内部类呢？
通常使用方法是接口类型参数，并且该接口中的方法不超过三个，可以将匿名内部类作为参数传递。
好处：
增强阅读性。
    示例1：
01.  abstract class Demo{
02.         abstract void show();
03.  }
04. 
05.  class Outer{
06.         int num = 4;
07. 
08.         void method(){
09.               new Demo(){//匿名内部类
10.                     void show(){
11.                          System.out.println("show......" + num);
12.                    }
13.               }.show();
14.         }
15.  }
16. 
17.  class InnerClassDemo{
18.         public static void main(String[] args){
19.               new Outer().method();
20.         }
21.  }
复制代码
运行结果：
    示例2：  
01.  interface Inter{
02.         void show1();
03.         void show2();
04.  }
05. 
06.  class Outer{
07.         public void method(){
08.              Inter in = new Inter(){
09.                     public void show1(){
10.                            System.out.println("...show1...." );
11.                     }
12.                     public void show2(){
13.                            System.out.println("...show2...." );
14.                     }
15.              };
16.              in.show1();
17.              in.show2();
18.         }
19.  }
20. 
21.  class InnerClassDemo{
22.         public static void main(String[] args){
23.               new Outer().method();
24.         }
25.  }
复制代码
运行结果：
    示例3：  
01.  interface Inter{
02.         void show1();
03.         void show2();
04.  }
05. 
06.  /*
07.  通常的使用场景之一：
08.  当函数参数是接口类型时，而且接口中的方法不超过三个。
09.  可以用匿名内部类作为实际参数进行传递。
10.  */
11.  class InnerClassDemo{
12.        public static void main(String[] args){
13.               show(new Inter(){
14.                     public void show1(){
15.                          System.out.println("...show1..." );
16.                     }
17.                     public void show2(){
18.                          System.out.println("...show2..." );
19.                     }
20.              });
21.         }
22.         public static void show(Inter in){
23.              in.show1();
24.              in.show2();
25.         }
26.  }
复制代码
运行结果：
对象的初始化过程
    示例： 
01.  class Fu{
02.         int num = 9;
03. 
04.         {
05.              System.out.println("Fu" );
06.         }
07. 
08.        Fu(){
09.               super();//Object
10.               //显示初始化
11.               //构造代码块初始化
12.              show();
13.         }
14.         void show(){
15.              System.out.println("fu show " + num);//被覆盖，运行子类的
16.         }
17.  }
18. 
19.  class Zi extends Fu{
20.         int num = 8;
21. 
22.        {
23.              System.out.println("Zi" );
24.        }
25. 
26.        Zi(){
27.               super();
28.               //显示初始化
29.               //构造代码块初始化
30.              show();
31.        }
32. 
33.         void show(){
34.              System.out.println("zi show " + num); 
35.         }
36.  }
37. 
38.  public class Demo{
39.         public static void main(String[] args){
40.               new Zi();
41.         }
42.  }
复制代码
运行结果：
 
~END~
~爱上海，爱黑马~