JavaSE---内部类

1、概述

　　　　1.1　　内部类：一个类  定义在  其他类的内部，这个类被称为内部类；

　　　　　　　  内部类可以   放在  外部类  的任何位置；

　　　　1.2、语法

?
1
2
3
4
5
6
public class Test {
 
    修饰符 class 内部类类名{
 
    }
}

 

2、内部类访问特点

　　　　内部类 可以直接访问外部类的成员，包括私有

　　　　外部类 想访问内部类的成员，必须创建对象

3、根据内部类存放的位置，分为

　　　　成员内部类 ：　　　　

?
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package com.an.innerclass.memberinnerclass;
 
public class Outer {
 
    private int age=18;
    private static String name="jack";
    String job="teacher";
 
    public void say(){
        System.out.println("Outer say...");
    }
 
    private MemberInnerClass memberInnerClass=null;
    public MemberInnerClass getMemberInnerClass(){
        if (null==memberInnerClass){
            memberInnerClass=new MemberInnerClass();
        }
        return memberInnerClass;
    }
 
    /**
     * 位置：作为外部类的成员
     * 成员内部类 可以 访问 外部类的所有成员属性、成员方法（包括 private、static）
     *
     */
    public class MemberInnerClass{
 
        void useOuter(){
            System.out.println(age);
            System.out.println(name);
            System.out.println(job);
            //如果 成员内部类 拥有的成员变量或方法 与 外部类同名时，默认访问的 是成员内部类的成员
            say();
            //如果 成员内部类 拥有的成员变量或方法 与 外部类同名时，要访问外部类成员，需要使用 外部类.this.成员方法｜成员变量
            Outer.this.say();
        }
 
        void say(){
            System.out.println("MemberInnerClass say...");
        }
 
    }
}
 
class Test{
    public static void main(String[] args) {
        //外部类  访问  内部类 的成员  只能创建 内部类对象，再由 内部类对象 访问 内部类成员
        //第一种方式：
        Outer.MemberInnerClass memberInnerClass=new Outer().new MemberInnerClass();
        memberInnerClass.useOuter();
 
        //第二种方式：
        Outer.MemberInnerClass memberInnerClass1=new Outer().getMemberInnerClass();
    }
}

　

?
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
javac编译Outer.java
 
public class Outer {
    private int age = 18;
    private static String name = "jack";
    String job = "teacher";
    private Outer.MemberInnerClass memberInnerClass = null;
 
    public Outer() {
    }
 
    public void say() {
        System.out.println("Outer say...");
    }
 
    public Outer.MemberInnerClass getMemberInnerClass() {
        if (null == this.memberInnerClass) {
            this.memberInnerClass = new Outer.MemberInnerClass();
        }
 
        return this.memberInnerClass;
    }
 
    public class MemberInnerClass {
        public MemberInnerClass() {
        }
 
        void useOuter() {
            System.out.println(Outer.this.age);
            System.out.println(Outer.name);
            System.out.println(Outer.this.job);
            this.say();
            Outer.this.say();
        }
 
        void say() {
            System.out.println("MemberInnerClass say...");
        }
    }
}
 
public class Outer$MemberInnerClass {
    public Outer$MemberInnerClass(Outer var1) {
        this.this$0 = var1;
    }
 
    void useOuter() {
        System.out.println(Outer.access$000(this.this$0));
        System.out.println(Outer.access$100());
        System.out.println(this.this$0.job);
        this.say();
        this.this$0.say();
    }
 
    void say() {
        System.out.println("MemberInnerClass say...");
    }
}
 
class Test {
    Test() {
    }
 
    public static void main(String[] var0) {
        Outer var10002 = new Outer();
        var10002.getClass();
        MemberInnerClass var1 = new MemberInnerClass(var10002);
        var1.useOuter();
        MemberInnerClass var2 = (new Outer()).getMemberInnerClass();
    }
}

　

 

　　　　局部内部类：

　　　　　　定义在方法中，仅在方法中有效；

　　　　　　不能使用任何修饰符，也不能用static修饰；

?
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
26
27
28
29
30
package com.an.innerclass.partinnerclass;
 
public class Outer {
 
    private String name="jack";
    private static int age=18;
 
    public void say(){
        /**
         * 局部内部类 不能有 public、protected、private 以及 static 修饰符的
         *
         * 外部如何使用局部内部类 ：
         *      外部类对象.外部类成员方法.内部类对象.内部类成员方法
         */
        class PartInnerClass{
            public void show(){
                System.out.println(name);
                System.out.println(age);
            }
        }
 
 
        new PartInnerClass().show();
    }
}
class Test{
    public static void main(String[] args) {
        new Outer().say();
    }
}

　

?
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
javac编译Outer.java
 
public class Outer {
    private String name = "jack";
    private static int age = 18;
 
    public Outer() {
    }
 
    public void say() {
        class PartInnerClass {
            PartInnerClass() {
            }
 
            public void show() {
                System.out.println(Outer.this.name);
                System.out.println(Outer.age);
            }
        }
 
        (new PartInnerClass()).show();
    }
}
 
class Outer$1PartInnerClass {
    Outer$1PartInnerClass(Outer var1) {
        this.this$0 = var1;
    }
 
    public void show() {
        System.out.println(Outer.access$000(this.this$0));
        System.out.println(Outer.access$100());
    }
}
 
class Test {
    Test() {
    }
 
    public static void main(String[] var0) {
        (new Outer()).say();
    }
}

　　

　

 

　　　　匿名内部类：

　　　　　　　　　　　　　　　　　　a,　　只使用一次；

　　　　　　　　　　　　　　　　　　b,　　语法：

　　　　　　　　　　　　　　　　　　　　　　　　new 父类构造器(实参)  |  实现接口(){      }

　　　　　　　　　　　　　　　　　　c,　　必须   继承一个父类（最多一个）  或  实现一个接口（最多一个）；

　　　　　　　　　　　　　　　　　　d,　　不能  定义构造器，但   可以有初始化块；

　　　　　　　　　　　　　　　　　　e,　　不能   是抽象类；

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.an.innerclass.nonameinnerclass;
 
public interface NonameInnerClass {
    void say();
}
 
class Test{
    public static void main(String[] args) {
        /**
         * 匿名内部类 不能有访问修饰符和 static 修饰符
         *
         * 位置：参数
         */
        say(new NonameInnerClass() {
            public void say() {
                System.out.println("NonameInnerClass say...");
            }
        });
    }
 
    public static void say(NonameInnerClass nonameInnerClass){
        nonameInnerClass.say();
    }
}

　　　　　　

?
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
26
27
28
29
30
31
javac编译Outer.java
 
public interface NonameInnerClass {
    void say();
}
 
class Test {
    Test() {
    }
 
    public static void main(String[] var0) {
        say(new NonameInnerClass() {
            public void say() {
                System.out.println("NonameInnerClass say...");
            }
        });
    }
 
    public static void say(NonameInnerClass var0) {
        var0.say();
    }
}
 
final class Test$1 implements NonameInnerClass {
    Test$1() {
    }
 
    public void say() {
        System.out.println("NonameInnerClass say...");
    }
}

　　　　匿名内部类 实质：

　　　　　　创建一个 实现接口的 类，重写方法；

　　　　静态内部类：

?
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
26
27
package com.an.innerclass.staticinnerclass;
 
public class Outer {
 
    private String name="rose";
    static String job="teacher";
 
    /**
     * 静态内部类 static修饰
     *      不能访问外部类非static成员
     *
     *      不依赖于外部类对象，直接使用new Outer.StaticInnerClass()
     */
    public static class StaticInnerClass{
 
        public void say(){
            System.out.println(job);
        }
    }
}
 
class Test{
    public static void main(String[] args) {
        Outer.StaticInnerClass staticInnerClass =new Outer.StaticInnerClass();
        staticInnerClass.say();
    }
}

　　

?
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
26
27
28
29
30
31
32
33
34
35
36
37
javac编译Outer.java
 
public class Outer {
    private String name = "rose";
    static String job = "teacher";
 
    public Outer() {
    }
 
    public static class StaticInnerClass {
        public StaticInnerClass() {
        }
 
        public void say() {
            System.out.println(Outer.job);
        }
    }
}
 
public class Outer$StaticInnerClass {
    public Outer$StaticInnerClass() {
    }
 
    public void say() {
        System.out.println(Outer.job);
    }
}
 
class Test {
    Test() {
    }
 
    public static void main(String[] var0) {
        StaticInnerClass var1 = new StaticInnerClass();
        var1.say();
    }
}

　　　　　　静态内部类 不依赖 外部类；

4、使用内部类

　　　　a, 外部类 中使用 内部类

　　　　b, 外部类 以外使用 内部类

　　　　　　非静态内部类：

　　　　　　　　声明 变量： OuterClass.InnerClass 变量名 ;

　　　　　　　　实例化 ：   OuterInstance.new InnerConstructor() ;  

?
1
Outer.MemberInnerClass memberInnerClass=new Outer().new MemberInnerClass();

　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Outer$MemberInnerClass {
    public Outer$MemberInnerClass(Outer var1) {
        this.this$0 = var1;
    }
 
    void useOuter() {
        System.out.println(Outer.access$000(this.this$0));
        System.out.println(Outer.access$100());
        System.out.println(this.this$0.job);
        this.say();
        this.this$0.say();
    }
 
    void say() {
        System.out.println("MemberInnerClass say...");
    }
}

　　　　　静态内部类：

　　　　　　声明 变量： OuterClass.InnerClass 变量名 ;

　　　　　　实例化 ：   new OuterClass.InnerConstructor() ;  

?
1
2
3
4
5
6
7
8
9
10
11
Outer.StaticInnerClass staticInnerClass =new Outer.StaticInnerClass();
 
 
public class Outer$StaticInnerClass {
    public Outer$StaticInnerClass() {
    }
 
    public void say() {
        System.out.println(Outer.job);
    }
}

　　

　

　　　　　　　　

　

　　　　　　　　　　

　　　　　　　　

posted on   anpeiyong  阅读(118)  评论(0)  编辑  收藏  举报

编辑推荐：
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 记一次.NET内存居高不下排查解决与启示
· 探究高空视频全景AR技术的实现原理
· 理解Rust引用及其生命周期标识（上）
· 浏览器原生「磁吸」效果！Anchor Positioning 锚点定位神器解析
阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？

导航

< 2025年3月 >
日 一 二 三 四 五 六
23 24 25 26 27 28 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 26 27 28 29
30 31 1 2 3 4 5
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛