Java内部类

内部类

主要用来服务外部类的，在外部类定义体内，临时定义的类

成员内部类

概念

定义在与成员变量、方法同一层级，身份上充当成员之一

访问权限

可以访问外部类所有成员（包括私有），直接写成员名

注意，外部类成员与内部类成员同名，调用是将使用自身的成员（变量和方法）

外部类方法可以访问内部类所有成员包括私有，先创建内部类对象

如果内外类的成员名冲突，内部类的成员使用this指定，外部类使用“外部类名.this”指定，后面几个内部类也是如此

举例

定义成员内部类变量：外部类.内部类 变量名 = 外部类对象.new 内部类()

// 前提是已经创建了外部类对象outer
Outer.Inner inner = outer.new Inner();

举例

package inner;

public class OuterClass {

    private String tag;
    private String description;

    public OuterClass(String tag, String description) {
        this.tag = tag;
        this.description = description;
    }

    public String getDescription() {
        return this.description;
    }

    // 定义一个成员内部类
    class MemberInnerClass {
        // 命名冲突，使用时需要特殊指定
        private String tag;

        public void showDescription() {
            // 可以访问外部类的成员（包括私有）
            System.out.println("内部类标签：" + this.tag + ", 外部类的标签是：" + OuterClass.this.tag + ", 外部类的描述是：" + getDescription());
        }
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass("outer", "这是一个普通类");
        // 定义一个成员内部类变量
        OuterClass.MemberInnerClass memberInnerClass = outerClass.new MemberInnerClass();
        memberInnerClass.tag = "inner";
        memberInnerClass.showDescription();
    }

}

静态内部类

属于静态成员，除了自身的成员，所以只能访问外部类的静态成员

举例

定义：不需要创建外部类对象

Outer.Inner inner = new Outer.Inner();

举例

package inner;

public class TestStaticInner {

    private static final String tag = "outer";
    private String description;

    public static class StaticInnerClass{
        public void showDescription() {
            // 可以访问外部类的静态成员（包括私有）
            System.out.println("外部类的标签是：" + tag);
        }
    }

    public static void main(String[] args) {
        // 不依靠外部类对象，创建静态内部类对象
        TestStaticInner.StaticInnerClass innerClass = new TestStaticInner.StaticInnerClass();
        innerClass.showDescription();
    }

}

局部内部类

方法体或代码块中创建的类，代码块结束，类的作用随之消失

访问权限

• 可以访问外部类的所有成员（类似于成员内部类）
• 代码块中的不变或不可变的变量（常量）
• 类作用在代码块，外部类即用即访问，但是别的代码块就无法使用了

举例

package inner;

class Outer {
    private int outerData = 30;

    public void doSomething() {
        final int localVariable = 40;
        class LocalInner {
            public void showData() {
                System.out.println("外部类的数据: " + outerData);
                System.out.println("局部变量的值: " + localVariable);
            }
        }
        LocalInner localInner = new LocalInner();
        localInner.showData();
    }
}

public class TestLocalClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.doSomething();
    }
}

匿名内部类

一般用于临时继承接口或者别的类，因为实现方式特殊在别处用不上（小众哥），所以即时定义，即时使用

当实现的接口是函数式接口，常常使用lambda表达式，简化代码

举例

package inner;

// 定义接口
interface MyInterface {
    void doWork();
}

class OuterA {
    public void performAction() {
        // 创建匿名内部类实现 MyInterface 接口
        MyInterface myInterface = new MyInterface() {
            // 即刻实现
            @Override
            public void doWork() {
                System.out.println("执行接口中的方法，通过匿名内部类实现");
            }
        };
        
        // 本例子，接口MyInterface只有一个抽象方法，即这是一个函数式接口，可使用lambda表达式，简化代码
        MyInterface lambdaMyInterface = ()->{
            System.out.println("lambda表达式的方式实现接口");
        };
        // 即刻使用
        myInterface.doWork();
        lambdaMyInterface.doWork();
    }
}

public class TestAnonymousClass {
    public static void main(String[] args) {
        OuterA outer = new OuterA();
        outer.performAction();
    }
}