内部类详解

最新推荐文章于 2023-03-02 12:25:08 发布

原创最新推荐文章于 2023-03-02 12:25:08 发布 · 325 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java

Java学习专栏收录该内容

4 篇文章

订阅专栏

定义

◼ 在类的内部可以定义一个另一个类

◼ 如果在Outer类的内部再定义一个Inner类，此时Inner类就称为内部类(或嵌套类)，而类Outer则称为外部类(或宿主类)

◼ 如果有多层嵌套，最外层的类称为顶层类

class Outer {	//外部类
	class Inner {	//内部类
		…
	}
}

内部类的分类

1.非静态成员内部类

(1) 在外部类的静态方法和外部类以外的其他类中，必须通过外部类的实例创建内部类的实例 ★

public class Outer {
class Inner {
// static int a;
}

public void method1() {
    Inner i = new Inner(); // 实例方法：直接new（不需要创建外部类实例）
}

public static void method2() {
    Outer.Inner i = new Outer().new Inner(); // 静态方法：需要创建外部类实例( new Outer() )
}

class Inner2 {
    Inner i = new Inner(); // 内部类：直接new（不需要创建外部类实例）
}

}
class OtherClass {
Outer.Inner i = new Outer().new Inner(); // 其他类：需要创建外部类实例( new Outer() )
}

上述代码中method2()为外部类的静态方法，outerClass类为外部类以外的其他类，都需要先创建外部类实例new.Outer()再进行内部类实践的创建，创建方式为new Outer().new.Inner();

(2) 非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员 ★

package edu.wust.examples;
public class Outer {
    public int a = 100;
    static int b = 100;
    final int c = 100;
    private int d = 100;
    class Inner {
        int a2 = a + 1; // 访问public的a
        int b2 = b + 1; // 访问static的b
        int c2 = c + 1; // 访问final的c
        int d2 = d + 1; // 访问private的d
    }
}

public class Test {
public static void main(String args[]) {
Outer.Inner i = new Outer().new Inner(); // 创建内部类实例
System.out.println( i.a2 ); // 输出101
System.out.println( i.b2 ); // 输出101
System.out.println( i.c2 ); // 输出101
System.out.println( i.d2 ); // 输出101
}
}

上述Inner类可以访问Outer类的a，b，c，d。但是如果在outer类中用到inner类的变量，就是错的

(3) 非静态内部类不能有静态方法、静态属性和静态代码块 ★

非静态内部类同名变量问题

public class Outer {
    private int size;
    public class Inner { //内部类
        private int size;
        public void doStuff( int size ) {
            size++; // doStuff()方法自己的形参size
            this.size++; //内部类自己的成员变量
            Outer.this.size++; //外部类成员变量
        }
    }
}

Outer.size++; X 因为该size不是静态变量所以最后一步Outer.this.size错误

2.静态内部类

(1) 通常一个普通类不允许声明为静态的，只有一个内部类才可以

(2) 在创建静态内部类的实例时，不需要创建外部类的实例

public class Outer {
    static class Inner {
//静态内部类
    }
}
class OtherClass {
    Outer.Inner i = new Outer.Inner();	//静态内部类的实例化
}

静态内部类相当于把它放在外面不再是嵌套的内部类，变成了顶层类

(3) 静态内部类中可以定义静态成员和实例成员

public class Outer {
    static class Inner {
        int a = 0; // 实例变量a
        static int b = 0; // 静态变量b
    }
}
class OtherClass {
    Outer.Inner i = new Outer.Inner();
    int a2 = i.a; // 访问实例成员
    int b2 = Outer.Inner.b; // 通过类名访问静态成员
}

(4)静态内部类可以直接访问外部类的静态成员，如果要访问外部类的实例成员，则需要通过外部类的实例去访问

public class Outer {
    int a = 0; // 实例变量a
    static int b = 0; // 静态变量 b
    static class Inner {
        Outer o = new Outer(); // 外部类实例
        int a2 = o.a; // 访问实例变量
        int b2 = b; // 访问静态变量
    }
}