静态内部类非静态内部类特性与使用

注：只有内部类才能被声明为静态类，即静态内部类

静态内部类;

1. 静态内部类能有静态成员变量、方法和非静态成员变量、方法。
2. 静态内部类只能够访问外部类的静态成员变量、静态方法。
3. 可实例化（前提是权限修饰符的权限足够）。
4. 可重写构造方法。
5. 可以嵌套静态或非静态内部类

非静态内部类：

1. 不能有静态成员(方法，变量)。
2. 可以访问外部的所有成员变量、方法。
3. 可实例化，实例化需要外部类的实例化对象（前提是权限修饰符的权限足够）。
4. 可重写构造方法。
5. 可以嵌套内部类，但不能嵌套静态内部类
6. 可被定义为接口类、抽象类。

测试用代码：

package main.java;

/**
 * @Author: xxx
 * @Description: 测试静态内部类与非静态内部类
 * @Date： Created in 21:03 2020/11/14
 */
public class StaticClass {
    private String wa = "外部类的非静态变量a";
    private static String wb = "外部类的静态变量b";

    public static void sff() {
        System.out.println("    ---外部类静态方法被调用---");
    }

    public void nsff() {
        System.out.println("    ---外部类非静态方法被调用---");
    }

    public static class SC1 {
        private String a = "静态内部类非静态变量变量a";
        private static String b = "静态内部类静态变量变量b";

        SC1() {
        }

        SC1(String a, String b) {
            this.a = a;
            SC1.b = b;
        }

        public void ff1() {
            System.out.println("<-----静态内部类的非静态方法ff1()开始执行----->");
            System.out.println("    " + a + " " + b + " " + wb);
            System.out.println("<-----静态内部类的非静态方法ff1()执行结束----->");
        }

        public static void ff2() {
            System.out.println("<-----静态内部类的静态方法ff2()开始执行----->");
            System.out.println("    " + b + " " + wb);
            sff();
            System.out.println("<-----静态内部类的静态方法ff2()执行结束----->");
        }
    }

    public class NSC2 {
        private String a = "非静态内部类非静态变量a";

        NSC2() {
        }

        NSC2(String a) {
            this.a = a;
        }

        public void ff1() {
            System.out.println("<-----非静态内部类的非静态方法ff1()开始执行----->");
            System.out.println("    " + a + " " + wa + " " + wb);
            sff();
            nsff();
            System.out.println("<-----非静态内部类的非静态方法ff1()执行结束----->");
        }
    }

    public static void main(String[] args) {
        System.out.println("测试用JDK版本号：" +
            System.getProperty("java.specification.version") + "\n");

        //外部类实例化
        StaticClass sc = new StaticClass();
        //静态内部类的实例化方式
        StaticClass.SC1 a1 = new StaticClass.SC1("新的静态内部类非静态变量a", "新的静态内部类静态变量b");
        a1.ff1();
        System.out.println("    实例化的静态内部类hashcode: " + a1.hashCode() + "\n");
        StaticClass.SC1.ff2();  //或者SC1.ff2()或a1.ff2()
        System.out.println("    静态调用的静态内部类hashcode: " + StaticClass.SC1.class.hashCode());
        System.out.println("\n》==========================================《\n");
        //非静态内部类的实例化方式
        StaticClass.NSC2 a2 = sc.new NSC2("新的非静态内部类非静态变量a");
        a2.ff1();
    }
}
/* 测试结果
 *测试用JDK版本号：1.8
 *
 *<-----静态内部类的非静态方法ff1()开始执行----->
 *  新的静态内部类非静态变量a 新的静态内部类静态变量b 外部类的静态变量b
 *<-----静态内部类的非静态方法ff1()执行结束----->
 *实例化的静态内部类hashcode: 1163157884
 *
 *<-----静态内部类的静态方法ff2()开始执行----->
 *  新的静态内部类静态变量b 外部类的静态变量b
 *   ---外部类静态方法被调用---
 *<-----静态内部类的静态方法ff2()执行结束----->
 *  静态调用的静态内部类hashcode: 1956725890
 *
 *》==========================================《
 *
 *<-----非静态内部类的非静态方法ff1()开始执行----->
 *  新的非静态内部类非静态变量a 外部类的非静态变量a 外部类的静态变量b
 *   ---外部类静态方法被调用---
 *   ---外部类非静态方法被调用---
 *<-----非静态内部类的非静态方法ff1()执行结束----->
 */

从上述可以看出，静态内部类除了定义在类内部，使用上几乎和外部类一样，并没有受到很多限制。

java文档中有描述，一旦将内部类定义为静态，则该类升级为顶级类，也就是说静态内部类就像是嵌套，亦即“我的存在和你无关”与外部类的关系并不是很紧密。

非静态内部类是真正意义上的内部类，隶属于外部类，成员类型受到限制，实例化也需借助实例化的外部类进行。