Java 内部类与静态类

内部类

1：内部类拥有普通类的所有特性，也拥有类成员变量的特性

2：内部类可以访问其外部类的成员变量，属性，方法，其它内部类

静态类

1：只有内部类才能声明为static，也可以说是静态内部类

2：只有静态内部类才能拥有静态成员，普通内部类只能定义普通成员

3：静态类跟静态方法一样，只能访问其外部类的静态成员

4：如果在外部类的静态方法中访问内部类，这时候只能访问静态内部类

01 /**
02  * 外部类，不能声明为 static
03  *
04  * @author zhanqi
05  *
06  */
07 public class OuterClass {
08
09     private int ab = 1;
10     private static int sab = 2;
11
12     /**
13      * 普通内部类
14      */
15     public class NormalInnerClass {
16
17         // private static int age = 22;
18         private int age = 22; // 不能声明为static
19
20         public NormalInnerClass() {
21             // 可以访问外部类静态与非静态成员
22             System.out.println(ab);
23             System.out.println(sab);
24         }
25     }
26
27     /**
28      * 静态内部类
29      */
30     public static class StaticInnerClass {
31         // 定义静态与非静态成员都是可以的
32         private static int age = 22;
33         private int age2 = 22;
34
35         private void echo() {
36             // System.out.println(ab);
37             System.out.println(sab);// 只能访问外部类的静态成员
38         }
39     }
40 }

内部类的实例化

1：访问内部类，必须使用：外部类.内部类，OutClass.InnerClass

2：普通内部类必须绑定在其外部类的实例上

3：静态内部类可以直接 new

01 /**
02  * 外部类访问内部类
03  */
04 public class OuterClass {
05
06     /**
07      * 普通方法
08      */
09     public void method() {
10         StaticInnerClass sic = new StaticInnerClass();
11         NormalInnerClass nic = new NormalInnerClass();
12     }
13
14     /**
15      * Main
16      */
17     public static void main(String[] args) {
18         // 在静态方法中，只能访问静态成员，静态内部类
19         // NormalInnerClass nic = new NormalInnerClass();
20         StaticInnerClass sic = new StaticInnerClass();
21     }
22 }
23
24 /**
25  * 其它类访问内部类
26  */
27 class Test {
28     public static void main(String[] args) {
29         /**
30          * 1：其它类访问内部类，必须使用：外部类.内部类，OutClass.InnerClass
31          * 2：普通内部类必须绑定在其外部类的实例上
32          * 3：静态内部类可以直接 new
33          */
34         OuterClass.StaticInnerClass sic = new OuterClass.StaticInnerClass();
35         // OuterClass.NormalInnerClass n = new OuterClass.NormalInnerClass();
36
37         OuterClass oc = new OuterClass();
38         OuterClass.NormalInnerClass nic = oc.new NormalInnerClass();
39     }
40 }