Java基础（内部类和静态内部类)

Posted 2021-09-04 半卷清詞

内部类（Inner Class）和静态内部类（Static Nested Class）的区别：

定义在一个类内部的类叫内部类，包含内部类的类称为外部类。内部类可以声明public、protected、private等访问限制，可以声明 为abstract的供其他内部类或外部类继承与扩展，或者声明为static、final的，也可以实现特定的接口。外部类按常规的类访问方式使用内部 类，唯一的差别是外部类可以访问内部类的所有方法与属性，包括私有方法与属性。

(1)创建实例

OutClass.InnerClass obj = outClassInstance.new InnerClass(); //注意是外部类实例.new，内部类

AAA.StaticInner in = new AAA.StaticInner();//注意是外部类本身，静态内部类

(2)内部类中的this

内 部类中的this与其他类一样是指的本身。创建内部类对象时，它会与创造它的外围对象有了某种联系，于是能访问外围类的所有成员，不需任何特殊条件，可理 解为内部类链接到外部类。 用外部类创建内部类对象时，此内部类对象会秘密的捕获一个指向外部类的引用，于是，可以通过这个引用来访问外围类的成员。

(3)外部类访问内部类

内部类类似外部类的属性，因此访问内部类对象时总是需要一个创建好的外部类对象。内部类对象通过‘外部类名.this.xxx’的形式访问外部类的属性与方法。如：

   System.out.println("Print in inner Outer.index=" + pouter.this.index);
   System.out.println("Print in inner Inner.index=" + this.index);

（4）内部类向上转型

内部类也可以和普通类一样拥有向上转型的特性。将内部类向上转型为基类型，尤其是接口时，内部类就有了用武之地。如果内部类是private的，只可以被它的外部类问，从而完全隐藏实现的细节。

（5）方法内的类

方法内创建的类（注意方法中也能定义类），不能加访问修饰符。另外，方法内部的类也不是在调用方法时才会创建的，它们一样也被事先编译了。

（6）静态内部类

定义静态内部类：在定义内部类的时候，可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。

通常称为嵌套类，当内部类是static时，意味着：

[1]要创建嵌套类的对象，并不需要其外围类的对象；

[2]不能从嵌套类的对象中访问非静态的外围类对象（不能够从静态内部类的对象中访问外部类的非静态成员）；

嵌 套类与普通的内部类还有一个区别：普通内部类的字段与方法，只能放在类的外部层次上，所以普通的内部类不能有static数据和static字段， 也不能包含嵌套类。但是在嵌套类里可以包含所有这些东西。也就是说，在非静态内部类中不可以声明静态成员，只有将某个内部类修饰为静态类，然后才能够在这 个类中定义静态的成员变量与成员方法。

另外，在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。普通非静态内部类的 对象是依附在外部类对象之中的，要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。静态类和方法只属于类本身，并不属于 该类的对象，更不属于其他外部类的对象。

（7）内部类标识符

每个类会产生一个.class文件，文件名即为类名。同样，内部类也会产生这么一个.class文件，但是它的名称却不是内部类的类名，而是有着严格的限制：外围类的名字，加上$,再加上内部类名字。

（8）为何要用内部类？

1. 内部类一般只为其外部类使用；
2. 内部类提供了某种进入外部类的窗户；
3. 也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外部类是否已经继承了某个接口。因此，内部类使多重继承的解决方案变得更加完整。

加深印象，参考一下：

例子1：

package cn.tobin.cls;

public class OutClassTest {
    static int a;

    int b;

    public static void test() {
        System.out.println("outer class static function");
    }

    public static void main(String[] args) {
        OutClassTest oc = new OutClassTest();
        // new一个外部类
        OutClassTest oc1 = new OutClassTest();
        // 通过外部类的对象new一个非静态的内部类
        OutClassTest.InnerClass no_static_inner = oc1.new InnerClass();
        // 调用非静态内部类的方法
        System.out.println(no_static_inner.getKey());

        // 调用静态内部类的静态变量
        System.out.println(OutClassTest.InnerStaticClass.static_value);
        // 不依赖于外部类实例,直接实例化内部静态类
        OutClassTest.InnerStaticClass inner = new OutClassTest.InnerStaticClass();
        // 调用静态内部类的非静态方法
        System.out.println(inner.getValue());
        // 调用内部静态类的静态方法
        System.out.println(OutClassTest.InnerStaticClass.getMessage());
    }

    private class InnerClass {
        // 只有在静态内部类中才能够声明或定义静态成员
        // private static String tt = "0";
        private int flag = 0;

        public InnerClass() {
            // 三.非静态内部类的非静态成员可以访问外部类的非静态变量和静态变量
            System.out.println("InnerClass create a:" + a);
            System.out.println("InnerClass create b:" + b);
            System.out.println("InnerClass create flag:" + flag);
            //
            System.out.println("InnerClass call outer static function");
            // 调用外部类的静态方法
            test();
        }

        public  String getKey() {
            return "no-static-inner";
        }
    }

    private static class InnerStaticClass {
        // 静态内部类可以有静态成员，而非静态内部类则不能有静态成员。
        private static String static_value = "0";

        // 静态内部类也可以有非静态成员
        private int flag = 0;

        public InnerStaticClass() {
            System.out.println("InnerClass create a:" + a);
            // 静态内部类不能够访问外部类的非静态成员
            // System.out.println("InnerClass create b:" + b);
            System.out.println("InnerStaticClass flag is " + flag);
            System.out.println("InnerStaticClass tt is " + static_value);
        }

        public int getValue() {
            // 静态内部类访问外部类的静态方法
            test();
            return 1;
        }

        public static String getMessage() {
            return "static-inner";
        }
    }

    public OutClassTest() {
        // new一个非静态的内部类
        InnerClass ic = new InnerClass();
        System.out.println("OuterClass create");
    }

}

运行结果：
InnerClass create a:0
InnerClass create b:0
InnerClass create flag:0
InnerClass call outer static function
outer class static function
OuterClass create
InnerClass create a:0
InnerClass create b:0
InnerClass create flag:0
InnerClass call outer static function
outer class static function
OuterClass create
InnerClass create a:0
InnerClass create b:0
InnerClass create flag:0
InnerClass call outer static function
outer class static function
no-static-inner
0
InnerClass create a:0
InnerStaticClass flag is 0
InnerStaticClass tt is 0
outer class static function
1
static-inner

/**

• 总结：
• 1.静态内部类可以有静态成员(方法，属性)，而非静态内部类则不能有静态成员(方法，属性)。
• 2.静态内部类只能够访问外部类的静态成员,而非静态内部类则可以访问外部类的所有成员(方法，属性)。
• 3.实例化一个非静态的内部类的方法：
• a.先生成一个外部类对象实例
• OutClassTest oc1 = new OutClassTest();
• b.通过外部类的对象实例生成内部类对象
• OutClassTest.InnerClass no_static_inner = oc1.new InnerClass();
• 4.实例化一个静态内部类的方法：
• a.不依赖于外部类的实例,直接实例化内部类对象
• OutClassTest.InnerStaticClass inner = new OutClassTest.InnerStaticClass();
• b.调用内部静态类的方法或静态变量,通过类名直接调用
• OutClassTest.InnerStaticClass.static_value
• OutClassTest.InnerStaticClass.getMessage()
  */

例子2：

package cn.tobin.cls;


public class OutClassTest2 implements AA {
    private static String flag ="OutClassTest2";
    private int index =1;
    @Override
    public void a() {
        System.out.println("OutClassTest2 implements AA.a");
    }

    private void setValue() {
        flag ="setValue";
        index =2;
        // 非静态方法内部不能定义静态内部类 ,切不能加 private，public控制修饰符,不能加static,编译报错
        class  InnerClass implements BB {
//            flag ="InnerClass";  //方法非静态内部类不能直接访问外围静态成员
//            index =3;  //方法非静态内部类不能直接访问外围非静态成员
            // 方法中非静态内部类不能定义静态成员
//            private static ss ="InnerClass";
            //方法中非静态内部类能定义非静态成员
            private int inn1=1;
            @Override
            public void b() {
                System.out.println(inn1);
                System.out.println("InnerClass implements BB.b");
            }

            public InnerClass() {
                System.out.println("InnerClass:"+inn1);
            }
        }
        InnerClass inn = new InnerClass();
        inn.b();
    }

    private static void printValue() {
        flag ="setValue";
//        index =2;
        // 在静态方法内部类,切不能加 private，public控制修饰符,不能加static,编译报错
        class  InnerStaticClass {
            //            flag ="InnerClass";  //静态方法内部类不能直接访问外围静态成员
//            index =3;  //静态方法内部类不能直接访问外围非静态成员
            // 静态方法中内部类不能定义静态成员
//            private static ss2 ="InnerStaticClass";
            //静态方法中内部类能定义非静态成员
            private int inn2=2;

            public InnerStaticClass() {
                System.out.println("InnerStaticClass:"+inn2);
            }
        }
        new InnerStaticClass();
    }

    public static void main(String[] args) {
        OutClassTest2 out = new OutClassTest2();
        out.setValue();
        out.printValue();

    }

}



interface  AA {
    abstract void a();
}

interface BB {
    abstract void b();
}

运行结果：
InnerClass:1
1
InnerClass implements BB.b
InnerStaticClass:2

总结：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。