Java内部类详解-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_47690874/article/details/121110973

Java基础-内部类

定义及作用

如果在类（外部类）中再定义一个类，此时该类就称为内部类。其作用在于更好的实现隐藏，一般而言非内部类无法访问类的private和protectted .内部类拥有外部类的所有元素的访问权限。

分类

内部类可以分为实例内部类、静态内部类、局部内部类

特点

内部类仍然是一个独立的类，经过编译之后会生成.class文件，但是前面冠以外部类的类名和$符号
非静态内部类可以自由访问外部类的成员变量。静态的只能访问外部类的静态成员变量（这是静态属性）

简单使用

public class Test {
    public class InnerClass {
        public int getSum(int x,int y) {
            return x + y;
        }
    }
    public static void main(String[] args) {
        Test.InnerClass ti = new Test().new InnerClass();
        int i = ti.getSum(2,3);
        System.out.println(i);    // 输出5
    }
}

**注意事项
在外部类中可以直接实例化内部类进行访问；在外部类以外的其他类需要通过内部类完整类名访问内部类：Test.InnerClass ti = new Test().new InnerClass();
**

非静态内部类

特点

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

public class Outer {
    class Inner1 {
    }

    Inner1 i = new Inner1(); // 不需要创建外部类实例

    public void method1() {
        Inner1 i = new Inner1(); // 不需要创建外部类实例
    }

    public static void method2() {
        Inner1 i = new Outer().new inner1(); // 需要创建外部类实例
    }

    class Inner2 {
        Inner1 i = new Inner1(); // 不需要创建外部类实例
    }
}

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

在非静态内部类中，可以访问外部类的所有成员

public class Outer {
    public int a = 100;
    static int b = 100;
    final int c = 100;
    private int d = 100;

    public String method1() {
        return "实例方法1";
    }

    public static String method2() {
        return "静态方法2";
    }

    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
        String str1 = method1(); // 访问实例方法method1
        String str2 = method2(); // 访问静态方法method2
    }

    public static void main(String[] args) {
        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
        System.out.println(i.str1); // 输出实例方法1
        System.out.println(i.str2); // 输出静态方法2
    }
}

内外部类存在同名成员，this.t表示内部类成员，而外部类.this.t则表示外部类的成员t 。
在非静态内部类中不能定义static成员，除非同时使用final和static修饰。

静态内部类

定义

static修饰的内部类

使用及注意事项

在创建内部类实例时，不需要创建外部类实例

public class Outer {
    static class Inner {

    }
}
class OtherClass {
    Outer.Inner oi = new Outer.Inner();
}

静态内部类中可以定义静态成员和实例成员。外部类以外的其他类需要通过完整的类名访问静态内部类中的静态成员，如果要访问静态内部类中的实例成员，则需要通过静态内部类的实例。

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

静态内部类可以直接访问外部类的静态成员，如果需要访问外部类的实例成员，需要创建外部类实例对象访问

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