内部类

内部类主要有以下几类：成员内部类、局部内部类、静态内部类、匿名内部类

1.成员内部类

 成员内部类也称常规内部类，是指内部类直接嵌套在外部类的类体里
 这时内部类就相当于外部类的一个成员变量或成员方法，是外部类的一个成员。

在成员内部类中，可以拥有自己的成员变量和方法，也可以是一个独立的类，内部类和外部类

的实例变量是可以共存的。

创建的时候先要创建外部类然后再创建内部类。

 

 1 /*
 2  * 成员内部类
 3  */
 4 public class OuterClass {
 5     // 外部类名
 6     private String outerClassName = "outerClass";
 7     // 内部外部标志 与内部类的对象命名相同
 8     private String inOutFlg = "outer";
 9     
10     public OuterClass(){
11         System.out.println("外部类OuterClass创建完成！");
12     }
13 
14     /*
15      * 成员内部类
16      */
17     public class InnerClass {
18         // 内部类名
19         String innerClassName = "InnerClass";
20         // 内部外部标志   与外部类的对象命名相同
21         String inOutFlg = "inner";
22 
23         /*
24          * 内部类构造方法
25          */
26         public InnerClass(){
27             System.out.println("内部类InnerClass创建完成！");
28         }
29 
30         /*
31          * 打印外部类名
32          */
33         public void printOuterClassValue() {
34             // 在成员内部类中可以访问外部类的所有成员
35             System.out.println(outerClassName);
36             // 当内部类中存在与外部成员变量相同的变量时，外部成员的调用
37             System.out.println(OuterClass.this.inOutFlg);
38         }
39         /*
40          * 打印内部类名
41          */
42         public void printInnerClassValue(){
43             System.out.println(innerClassName);
44             // 当内部类中存在与外部成员变量相同的变量时，内部成员的调用
45             System.out.println(InnerClass.this.inOutFlg);
46         }
47     }
48     
49     /*
50      * 外部类内部对内部类的访问
51      */
52     void getClassName (){
53         InnerClass innerClass = new InnerClass();
54         innerClass.printOuterClassValue();
55     }
56 
57 }

测试：

 1     public static void main(String[] args) {
 2         // 外部类的创建
 3         OuterClass out = new OuterClass();
 4         // 从外部类访问内部类的成员函数
 5         out.getClassName();
 6         // 内部类的创建
 7         OuterClass.InnerClass innerClass = out.new InnerClass();
 8         // 访问内部类的成员函数
 9         innerClass.printInnerClassValue();
10     }
11 
12 }

 

 

2.局部内部类

局部内部类也称方法内部类，它对外面的所有类来说都是隐藏的，即使是它所属的外部类，仅有它所在的方法知道它；

它不仅可以访问它所属外部类中的数据，还可以访问该方法中定义的局部变量，不过局部变量必须声明为final类型。

 

接口声明：

 public interface InnerClassIF {
2     // 打印内部类名
3     void printInnerClassValue();
4     // 打印外部类名
5     void printOuterClassValue();
6     // 打印方法内定义的变量
7     void printOuterMethodValue();
8 }

 

 

 1 /*
 2  * 方法内部类
 3  */
 4 public class OuterClass {
 5     // 外部类名
 6     private String outerClassName = "outerClass";
 7     // 内部外部标志 与内部类的对象命名相同
 8     private String inOutFlg = "outer";
 9     
10     public OuterClass(){
11         System.out.println("外部类OuterClass创建完成！");
12     }
13     
14     /*
15      * 方法内部定义的类，只能在该方法范围内访问
16      */
17     InnerClassIF getClassName (){
18         String path = "D盘";
19         final String classPath = "C盘";
20 
21         /*
22          * 方法内部类
23          */
24         class InnerClass implements InnerClassIF {
25             // 内部类名
26             String innerClassName = "InnerClass";
27             // 内部外部标志   与外部类的对象命名相同
28             String inOutFlg = "inner";
29 
30             /*
31              * 内部类构造方法
32              */
33             public InnerClass(){
34                 System.out.println("内部类InnerClass创建完成！");
35             }
36 
37             /*
38              * 打印外部类名
39              */
40             public void printOuterClassValue() {
41                 // 在方法内部类中可以访问外部类的所有成员
42                 System.out.println(outerClassName);
43                 // 当内部类中存在与外部成员变量相同的变量时，外部成员的调用
44                 System.out.println(OuterClass.this.inOutFlg);
45             }
46             /*
47              * 打印内部类名
48              */
49             public void printInnerClassValue(){
50                 System.out.println(innerClassName);
51                 // 当内部类中存在与外部成员变量相同的变量时，内部成员的调用
52                 System.out.println(InnerClass.this.inOutFlg);
53             }
54             /*
55              * 打印方法内定义的变量
56              */
57             public void printOuterMethodValue(){
58                 // 在方法内部类中只能访问该方法中用final定义的成员
59                 System.out.println(classPath);
60             }
61         };
62         return new InnerClass();
63     }
64 
65 }

测试：

 1     public static void main(String[] args) {
 2         // 外部类的创建
 3         OuterClass out = new OuterClass();
 4         // 访问成员方法，返回内部类对象的引用
 5         InnerClassIF innerClassIF = out.getClassName();
 6         innerClassIF.printInnerClassValue();
 7         innerClassIF.printOuterClassValue();
 8         innerClassIF.printOuterMethodValue();
 9         
10     }

 

3.静态内部类

在一个内部类前添加修饰符static，这个内部类就变为静态内部类。在一个静态内部类中可以声明静态成员和非静态成员，但是在非静态内部类中

不可以声明静态成员。同样，在静态内部类中不能访问外部类的非静态成员。

静态内部类的对象可以直接生成，不需要外部类的对象来生成，可以把静态内部类看作是一个顶级类。

静态内部类不可以用private来修饰。

 

 1 /*
 2  * 静态内部类
 3  */
 4 public class OuterClass {
 5     // 外部类名
 6     private static String outerClassName = "outerClass";
 7     // 内部外部标志 与内部类的对象命名相同
 8     private static String inOutFlg = "outer";
 9     
10     public OuterClass(){
11         System.out.println("外部类OuterClass创建完成！");
12     }
13 
14     /*
15      * 静态内部类
16      */
17     public static class InnerClass {
18         // 内部类名
19         static String innerClassName = "InnerClass";
20         // 内部外部标志   与外部类的对象命名相同
21         String inOutFlg = "inner";
22 
23         /*
24          * 内部类构造方法
25          */
26         public InnerClass(){
27             System.out.println("内部类InnerClass创建完成！");
28         }
29 
30         /*
31          * 打印外部类名
32          */
33         public static void printOuterClassValue() {
34             // 在静态内部类中可以访问外部类的所有静态成员
35             System.out.println(outerClassName);
36             // 当内部类中存在与外部成员变量相同的变量时，外部成员的调用
37             System.out.println(OuterClass.inOutFlg);
38         }
39         /*
40          * 打印内部类名
41          */
42         public void printInnerClassValue(){
43             System.out.println(innerClassName);
44             // 当内部类中存在与外部成员变量相同的变量时，内部成员的调用
45             System.out.println(InnerClass.this.inOutFlg);
46         }
47     }
48 }

测试：

     public static void main(String[] args) {
2         // 外部类直接访问静态内部类的静态方法
3         OuterClass.InnerClass.printOuterClassValue();
4         // 访问静态内部类的非静态方法
5         OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
6         innerClass.printInnerClassValue();
7     }

 

4.匿名内部类

匿名内部类是唯一一种没有构造方法的类。大部分匿名内部类用于接口的回调。

 1 public class InnerClassTest {
 2     public static void main(String[] args) {
 3         ArrayList<Integer> valueList = new ArrayList<>();
 4 
 5         valueList.add(26);
 6         valueList.add(2);
 7         valueList.add(5);
 8         valueList.add(4);
 9         valueList.add(19);
10         valueList.add(15);
11         valueList.add(1);
12         valueList.add(3);
13         valueList.add(6);
14         valueList.add(30);
15         
16         // 匿名内部类用于继承其他类或实现接口，只是对继承方法的实现与重写，不需要添加额外的方法
17         Collections.sort(valueList, new Comparator<Integer>() {
18 
19             @Override
20             public int compare(Integer o1, Integer o2) {
21                 // 升序
22                 if (o1.intValue() < o2.intValue()) {
23                     return -1;
24                 }
25                 return 0;
26             }
27         });
28         
29         for (int i = 0; i < valueList.size(); i++) {
30             System.out.println(valueList.get(i));
31         }
32     }
33 }