Java 嵌套类 (Nested Classes)

1. 嵌套类

• 嵌套类分为静态和非静态两类
• 传送门：https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

class OuterClass {
    ...
    class InnerClass {
        ...
    }
    static class StaticNestedClass {
        ...
    }
}

嵌套类命名格式：外部类名 + $ + 嵌套类名
特殊：匿名内部类使用数字进行编号，比如Outer$1.class

inner.png

1.1 静态嵌套类

• 不依赖外部类对象，可通过类名访问

访问静态嵌套类
OuterClass.StaticNestedClass
创建对象
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

1.2 非静态嵌套类

• 非静态嵌套类也称为内部类
• 包含3种：成员内部类、局部内部类、匿名内部类

创建对象

OuterClass outerObject = new OuterClass();
OuterClass.InnerClass innerObject = outerObject.new InnerClass();

2. 静态嵌套类

2.1 调用外部类属性

public class OuterClass {
    private String name = "outer";
    private static String sname = "static-outer";

    static class StaticNestedClass {

        public void onePrint() {
            System.out.println("onePrint: " + sname);
        }

        public static void twoPrint() {
            System.out.println("twoPrint: " + sname);
        }
    }
}

访问测试

@Test
public void test() {
    OuterClass.StaticNestedClass staticNestedClass = new OuterClass.StaticNestedClass();
    staticNestedClass.onePrint();

    OuterClass.StaticNestedClass.twoPrint();
}

2.2 调用静态嵌套类属性

public class Outer {
    private String name = "Bob";

    public static class Inner {
        private String name = "Alice";
        private static String address = "...";

        public void show() {
            // 调用外部类的属性，先创建外部类对象
            Outer outer = new Outer();
            System.out.println(outer.name);
            // 调用静态内部类的属性
            System.out.println(name);
            // 调用静态内部类的静态属性
            System.out.println(Inner.address);
        }
    }
}

访问测试

@Test
public void test() {
    Outer.Inner inner = new Outer.Inner();
    inner.show();
}

2.3 应用场景

Builder 模式构建对象

@Test
public void test() {
    User user = User.builder()
            .name("Tinyspot")
            .age(20)
            .build();
}

@Data
public class User {
    private String name;
    private Integer age;

    public static User.Builder builder() {
        return new User.Builder();
    }

    public static class Builder {
        private User user;

        public Builder() {
            user = new User();
        }

        public User build() {
            return user;
        }

        public Builder name(String name) {
            user.setName(name);
            return this;
        }

        public Builder age(Integer age) {
            user.setAge(age);
            return this;
        }
    }
}

3. 非静态嵌套类

@Test
public void test() {
    OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
    innerClass.print();
}

public class OuterClass {

    private String name = "outer";
    private static String sname = "static-outer";

    class InnerClass {
        public void print() {
            System.out.println("name: " + name);
            System.out.println("sname: " + sname);
        }
    }
}