Java 成员内部类

什么是成员内部类？

• 无static修饰，属于外部类的对象。
• JDK16之前，成员内部类中不能定义静态成员，JDK16开始也可以定义静态成员。

public class Outer{
    //成员内部类
    public class Inner{
        
    }
}
1
2
3
4
5
6

成员内部类创建对象的格式：

//格式：外部类.内部类 对象名 = new 外部类构造器.new 内部类构造器();
//范例：
Outer.Inner i = new Outer().new Inner();
1
2
3

使用实例：

public class Outer {
    //定义成员内部类
    public  class Inner{
        private String name;

        public Inner(String name) {
            this.name = name;
        }

        public Inner() {
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void show(){
            System.out.println("名称：" + name);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Test {
    public static void main(String[] args) {
        //创建成员内部类对象
        Outer.Inner i = new Outer().new Inner();

        //调用内部类对象方法
        i.setName("内部类");
        System.out.println(i.getName());
        i.show();
    }
}
1
2
3
4
5
6
7
8
9
10
11

结果：

成员内部类的访问拓展

1. 成员内部类中是否可以直接访问外部类的静态成员变量？

​ 可以，外部类的静态成员只有一份可以被共享访问

​ 2.成员内部类的实例方法中是否可以直接访问外部类的实例成员？

​ 可以，因为必须先有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员。

总结

1. 成员内部类是什么样的、有什么特点？
   • 无static修饰，属于外部类的对象
   • 可以直接访问外部类的静态成员，实例方法中可以直接访问 外部类的实例成员
2. 成员内部类如何创建对象？
   • 外部类.内部类名 对象名 = new 外部类构造器.new 内部类构造器();

成员内部类使用案例：

public class People {
    private int heartbeat = 150;
    public class Heart{
        private int heartbeat = 110;
        public void show(){
            int heartbeat = 78;
            System.out.println(heartbeat); //78
            System.out.println(this.heartbeat);//110
            System.out.println(People.this.heartbeat);//150
        }
    }
}

public class Test {
    public static void main(String[] args) {
        //创建成员内部类对象
        People.Heart h = new People().new Heart();

        //调用内部类对象方法
        h.show();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

注意：在成员内部类中访问所在外部类对象，格式：外部类.this。