Java内部类

1、概要

  • 外部类的类名需和类文件名相同，只能使用 public 和 default

  • 内部类是指在一个外部类的内部再定义一个类。内部类作为外部类的一个成员，并且依附于外部类而存在的

  • 内部类可为静态，可用 protected 和 private 修饰（而外部类只能使用 public 和 缺省 的包访问权限）

  • 内部类主要有一下几种：成员内部类、局部内部类、静态内部类、匿名内部类

2、概念

  • 内部类官方的叫法是嵌套类(Nested Classes)

  • 嵌套类包括静态内部类(Static Nested Classes)和非静态内部类(Inner Classes)

  • 而静态内部类分为成员内部类，局部内部类(Local Classes)和匿名内部类(Anonymous Classes)

3、特性

  • 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号

  • 内部类不能用普通的方式访问

  • 内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量

  • 外部类不能直接访问内部类的的成员，但可以通过内部类对象来访问

4、作用

  • 内部类方法可以访问该类定义所在的作用域的数据，包括私有的数据

  • 内部类可以对同一个包中的其他类隐藏起来,一般的非内部类，是不允许有 private 与protected权限的，但内部类可以

  • 可以实现多重继承

  • 当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷

  • 每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。大家都知道Java只能继承一个类，它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类

5、代码

1、成员内部类

即在一个类中直接定义的内部类，成员内部类与普通类的成员没什么区别，可以与普通成员一样进行修饰和限制。成员内部类不能含有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
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
72
73
74
75
package com.test;
 ​
 public class Outer {
     private static int number = 100;
     private int j = 20;
     private String name = "Java";
 ​
     public static void outer_funOne(){
         System.out.println("外部类Outer的静态方法:outer_funOne");
     }
 ​
     public void outer_funTwo(){
         System.out.println("外部类的普通方法：outer_funTwo");
     }
 ​
     //成员内部类，可以访问外部类的所有成员
     class Demo{
         //内部类不允许定义静态变量
         //static int demo_i = 100;
         int j =50; //内部类和外部类的实例变量可以共存
 ​
         //成员内部类中的方法定义
         public void demo_funOne(){
             //内部类中访问内部类自己的变量直接用变量名
             //也可以用  this.j
             System.out.println(j);
 ​
             //内部类中访问外部类的成员变量语法：外部类类名.this.变量名
             System.out.println("内部类访问外部类变量："+Outer.this.j);
 ​
             //如果内部类中没有与外部类中有相同的变量，则可以直接用变量名使用
             System.out.println(name);
 ​
             //内部类调用外部类方法
             outer_funOne();  //静态方法
             outer_funTwo();  //非静态方法
 ​
         }
 ​
     }
 ​
     public static void outer_funThree(){
         //外部类静态方法访问成员内部类
         // 1、建立外部类对象
         Outer out = new Outer();
         //  2、根据外部类建立内部类对象
         Demo demo = out.new Demo();
         // 访问内部类方法
         demo.demo_funOne();
         //访问内部类字段
         System.out.println("内部类成员字段："+demo.j);
     }
 ​
     public static void main(String[] args) {
         //调用内部类的方法
         // 1、创建外部类对象
         Outer out = new Outer();
         // 2、通过外部类对象创建内部类对象
         Outer.Demo demo = out.new Demo();
 ​
         // 1、2步简写
         // Outer.Demo demo1 = new Outer().new Demo();
 ​
         //方法调用
         demo.demo_funOne();
 ​
     }<br>
 }
 ​
 // 结果
 50
 内部类访问外部类变量：20
 Java
 外部类Outer的静态方法:outer_funOne
 外部类的普通方法：outer_funTwo

2、局部内部类

在方法中定义的内部类称为局部内部类。与局部变量类似，局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，和此外围类所有的成员。

注意：

  • 局部内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化

  • 局部内部类对象不能使用该内部类所在方法的非final局部变量。

?
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
package com.test;
​
public class Outer {
    private static int number = 100;
    private int j = 20;
    private String name = "Java";
​
    //定义外部类方法
    public void outer_funOne(int k){
        final int number = 100;
        int j = 50;
​
        //方法内部的类（局部内部类）
        class Demo{
            public Demo(int k){
                demo_funOne(k);
            }
​
            int number = 300; //可以定义与外部类同名的变量
            // static int j = 10;  //不可以定义静态变量
​
            //内部类的方法
            public void demo_funOne(int k){
                System.out.println("内部类方法：demo_funOne");
                //访问外部类的变量，如果没有与内部类同名的变量，则可直接用变量名
                System.out.println(name);
                //访问外部类与内部类同名的变量
                System.out.println(Outer.this.number);
                System.out.println("内部类方法传入的参数是："+k);
            }
        }
​
        new Demo(k);
    }
​
    public static void main(String[] args) {
        //访问内部类必须要先有外部类对象
        Outer out = new Outer();
        out.outer_funOne(11);
    }
​
}
​
// 结果
内部类方法：demo_funOne
Java
100
内部类方法传入的参数是：11

3、匿名内部类

匿名内部类就是没有名字的内部类

实现方式

  • 继承一个类，重写其方法

  • 实现一个接口（可以是多个），实现其方法

使用情景

  • 只用到类的一个实例

  • 类在定义后马上用到

  • 类非常小（SUN推荐是在4行代码以下）

  • 给类命名并不会导致你的代码更容易被理解

注意

  • 匿名内部类不能有构造方法

  • 匿名内部类不能定义任何静态成员、方法和类

  • 匿名内部类不能是public,protected,private,static

  • 只能创建匿名内部类的一个实例

  • 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类

  • 因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效

?
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
class Out {
     void show() {
         System.out.println("调用 Out 类的 show() 方法");
     }
 }
 ​
 public class TestAnonymousInterClass {
     // 在这个方法中构造一个匿名内部类
     private void show() {
         new Out() {
             // 获取匿名内部类的实例
             void show() {
                 System.out.println("调用匿名类中的 show() 方法");
             }
         }.show();
     }
      
     public static void main(String[] args) {
         TestAnonymousInterClass test = new TestAnonymousInterClass();
         test.show();
     }
 }
 ​
 // 结果
 调用匿名类中的 show() 方法

4、静态内部类

如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为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
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
package com.test;
 
public class Outer {
    private static int number = 100;
    private int j = 20;
    private String name = "Java";
 
    public static void outer_funOne(){
        System.out.println("外部类静态方法:outer_funOne");
    }
 
    public void outer_funTwo(){
 
    }
 
    //静态内部类可以用public、protected、private修饰
    //静态内部类可以定义静态类或非静态内部类
    private static class Demo{
        static int j = 100;
        String name = "C#";
 
        //静态内部类里的静态方法
        static void demo_funOne(){
            //静态内部类只能访问外部类的静态成员（静态变量、静态方法）
            System.out.println("静态内部类访问外部类静态变量："+number);
            outer_funOne();//访问外部类静态方法
 
        }
 
        //静态内部类非静态方法
        void demo_funTwo(){
 
        }
 
    }
 
    public void outer_funThree(){
        //外部类访问内部类静态成员：内部类.静态成员
        System.out.println(Demo.j);
        //访问静态方法
        Demo.demo_funOne();
        //访问静态内部类的非静态成员，实例化内部类即可
        Demo demo = new Demo();
        //访问非静态变量
        System.out.println(demo.name);
        //访问非静态方法
        demo.demo_funTwo();
 
    }
 
    public static void main(String[] args) {
        new Outer().outer_funThree();
    }
 
}
 
// 结果
100
静态内部类访问外部类静态变量：100
外部类静态方法：outer_funOne
C#
posted @   程序员予沫  阅读(201)  评论(0)  编辑  收藏  举报
相关博文：
·  Java集合框架
·  流程控制switch–case-break-continue
·  Java内部类
·  Java基础复习——内部类
·  Java内部类
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异
· 三行代码完成国际化适配，妙~啊~
点击右上角即可分享
微信分享提示
SQL AI 助手