Java中的内部类超详细讲解_Java

什么是内部类？

内部类就是定义在另一个类内部的类。写在成员位置的，属于外部类的成员。

想象一下我们的日常生活：一台电脑包含cpu、内存、硬盘等组件。从面向对象的角度看，我们可以将电脑看作一个类(computer)，而cpu、内存等组件则可以看作电脑内部的类(cpu, memory, harddisk)。这些组件属于电脑，在电脑内部工作，与电脑有紧密的联系。

这就像java中的内部类概念：一个类定义在另一个类的内部，形成一种"类中有类"的结构。

生活中的内部类例子

// 电脑类
public class computer {
    private string brand;
    private double price;
    
    // cpu内部类
    class cpu {
        private string model;
        private int cores;
        
        public void run() {
            // cpu可以访问电脑的品牌信息
            system.out.println(brand + "电脑的" + model + "处理器正在运行...");
        }
    }
    
    // 显卡内部类
    class graphicscard {
        private string model;
        private int memory;
        
        public void display() {
            // 显卡也可以访问电脑的信息
            system.out.println(brand + "电脑的" + model + "显卡正在渲染画面...");
        }
    }
    
    // 电脑使用内部组件
    public void start() {
        cpu cpu = new cpu();
        cpu.model = "intel i7";
        cpu.run();
        
        graphicscard gc = new graphicscard();
        gc.model = "nvidia rtx 3080";
        gc.display();
    }
}

在这个例子中：

computer是外部类，代表整台电脑
cpu和graphicscard是内部类，代表电脑的组件
内部类可以访问外部类的属性(brand)
外部类可以直接创建和使用内部类

这种设计反映了现实世界中的"整体-部分"关系，内部类就像是外部类的一个组成部分。

public class outer {  // 外部类
    private int num = 10;
    
    class inner {  // 内部类
        // 内部类的代码
    }
}

为什么需要内部类？

理解内部类存在的原因，可以通过更多的生活例子来理解：

生活中的例子

汽车与发动机
- 汽车(car)是外部类，发动机(engine)是内部类
- 发动机是汽车的核心组件，与汽车紧密相关
- 发动机需要访问汽车的各种状态(油量、温度等)
- 一般不会将发动机单独使用，它主要为汽车服务
手机与应用程序
- 手机(phone)是外部类，应用程序(app)是内部类
- 应用程序需要访问手机的功能(摄像头、存储空间等)
- 应用程序主要为手机提供特定功能

内部类的存在意义

提高封装性
- 内部类可以访问外部类的所有成员，包括私有成员
- 内部类本身可以对外隐藏，只有外部类能访问它
- 实现高内聚、低耦合的设计理念
实现多重继承
- java不支持类的多重继承，但内部类可以继承其他类
- 通过在一个类中创建多个内部类，每个内部类继承不同的类，实现类似多重继承的效果
更好地实现回调机制
- 匿名内部类特别适合用于事件处理和回调机制
- 简化了接口实现的代码结构
隐藏实现细节
- 将实现细节隐藏在外部类内部，对外只暴露必要的接口
- 如集合框架中的迭代器实现，就是通过内部类完成的
组织逻辑上紧密相关的类
- 当一个类只对另一个类有用时，将其定义为内部类可以更好地组织代码
- 体现了"has-a"关系中的"a"是专属于宿主对象的情况

内部类的分类

java中的内部类主要分为四种类型：

成员内部类：写在类成员位置的内部类
静态内部类：使用static修饰的内部类
局部内部类：定义在方法中的内部类
匿名内部类：没有名字的内部类，隐藏了类的名字

1. 成员内部类

什么是成员内部类？

成员内部类是定义在类成员位置的内部类，就像一个普通的成员变量一样。

成员内部类的特点

可以使用外部类的所有成员和方法，即使是private的
在jdk 16之前，成员内部类中不能定义静态成员
成员内部类可以被访问修饰符修饰：private、default、protected、public
成员内部类不能脱离外部类对象独立存在，需要先创建外部类对象

如何使用成员内部类？

方式一：在外部类中直接创建内部类对象并使用

public class outer {
    private int num = 10;
    
    // 成员内部类
    class inner {
        public void show() {
            system.out.println("外部类成员变量num=" + num);
        }
    }
    
    // 在外部类中使用内部类
    public void method() {
        inner i = new inner();
        i.show();
    }
}

方式二：在其他类中使用成员内部类

public class test {
    public static void main(string[] args) {
        // 先创建外部类对象
        outer outer = new outer();
        
        // 再创建内部类对象
        outer.inner inner = outer.new inner();
        
        // 使用内部类方法
        inner.show();
    }
}

成员内部类访问外部类同名成员

如果内部类和外部类有同名的成员变量，可以使用外部类名.this.成员变量来访问外部类的成员：

public class outer {
    private int num = 10;
    
    class inner {
        private int num = 20;
        
        public void show() {
            int num = 30;
            system.out.println("局部变量：" + num);  // 30
            system.out.println("内部类成员变量：" + this.num);  // 20
            system.out.println("外部类成员变量：" + outer.this.num);  // 10
        }
    }
}

2. 静态内部类

什么是静态内部类？

静态内部类是使用static关键字修饰的内部类，是一种特殊的成员内部类。

静态内部类的特点

静态内部类只能访问外部类的静态成员，不能直接访问非静态成员
静态内部类可以包含静态成员，也可以包含非静态成员
创建静态内部类对象时，不需要依赖外部类对象

静态内部类的使用

创建静态内部类对象的格式：

外部类名.内部类名 对象名 = new 外部类名.内部类名();

示例代码：

public class car {  // 外部类
    private string carname;
    private static int carage = 10;
    
    // 静态内部类
    static class engine {
        private string enginename;
        
        public void show() {
            // 可以访问外部类静态成员
            system.out.println("汽车年龄：" + carage);
            
            // 不能访问外部类非静态成员
            // system.out.println(carname); // 编译错误
        }
    }
}

// 使用静态内部类
public class test {
    public static void main(string[] args) {
        // 直接创建静态内部类对象，不需要外部类对象
        car.engine engine = new car.engine();
        engine.show();
    }
}

静态内部类的方法调用

调用静态内部类的静态方法：外部类名.内部类名.方法名();
调用静态内部类的非静态方法：先创建静态内部类对象，再用对象调用方法

public class outer {
    // 静态内部类
    static class inner {
        // 静态方法
        public static void staticmethod() {
            system.out.println("静态内部类的静态方法");
        }
        
        // 非静态方法
        public void normalmethod() {
            system.out.println("静态内部类的非静态方法");
        }
    }
}

// 调用方法
public class test {
    public static void main(string[] args) {
        // 调用静态方法
        outer.inner.staticmethod();
        
        // 调用非静态方法
        outer.inner inner = new outer.inner();
        inner.normalmethod();
    }
}

3. 局部内部类

什么是局部内部类？

局部内部类是定义在方法中的类，像局部变量一样，只能在定义它的方法内部使用。

局部内部类的特点

只能在定义它的方法内部使用
可以访问外部类的所有成员
可以访问方法中的final或effectively final（java 8以后）的局部变量

局部内部类的使用

public class outer {
    private int outerfield = 10;
    
    public void method() {
        final int localvar = 20;  // final局部变量
        int effectivelyfinal = 30;  // effectively final变量（不会被修改）
        
        // 局部内部类
        class localinner {
            public void show() {
                // 访问外部类成员
                system.out.println("外部类成员：" + outerfield);
                
                // 访问方法中的局部final变量
                system.out.println("局部变量：" + localvar);
                
                // 访问effectively final变量
                system.out.println("effectively final变量：" + effectivelyfinal);
            }
        }
        
        // 创建局部内部类对象并调用方法
        localinner inner = new localinner();
        inner.show();
        
        // 注意：这里不能修改effectivelyfinal的值
        // effectivelyfinal = 40; // 这样会导致编译错误
    }
}

4. 匿名内部类

什么是匿名内部类？

匿名内部类是隐藏了名字的内部类，本质上是一个没有名字的局部内部类，它必须继承一个类或实现一个接口。

匿名内部类的特点

没有显式的类名
在声明的同时完成实例化
一般用于实现接口或继承类
编译后会生成 外部类名$数字.class 文件

匿名内部类的格式

new 类名或接口名() {
    // 重写方法
};

匿名内部类的使用场景

当接口的实现类（或父类的子类）只使用一次时，可以使用匿名内部类简化代码。

匿名内部类示例

1. 实现接口的匿名内部类

public class test {
    public static void main(string[] args) {
        // 使用匿名内部类实现runnable接口
        runnable r = new runnable() {
            @override
            public void run() {
                system.out.println("这是匿名内部类实现的run方法");
            }
        };
        
        new thread(r).start();
        
        // 更简洁的写法
        new thread(new runnable() {
            @override
            public void run() {
                system.out.println("直接创建匿名内部类");
            }
        }).start();
    }
}

2. 继承类的匿名内部类

abstract class animal {
    public abstract void eat();
}

public class test {
    public static void main(string[] args) {
        // 使用匿名内部类继承抽象类
        animal a = new animal() {
            @override
            public void eat() {
                system.out.println("狗吃骨头");
            }
        };
        
        a.eat();
    }
}

3. 带参数的匿名内部类

interface calculator {
    int calculate(int a, int b);
}

public class test {
    public static void main(string[] args) {
        // 使用匿名内部类实现带参数的接口
        calculator c = new calculator() {
            @override
            public int calculate(int a, int b) {
                return a + b;
            }
        };
        
        system.out.println("计算结果：" + c.calculate(10, 20));
    }
}

内部类的实际应用

1. 实现多重继承

java不支持类的多继承，但可以通过内部类模拟实现：

class a {
    public void methoda() {
        system.out.println("来自a类的方法");
    }
}

class b {
    public void methodb() {
        system.out.println("来自b类的方法");
    }
}

// 通过内部类实现对a和b功能的同时使用
class c {
    // 继承a的内部类
    private class innera extends a {
        public void methoda() {
            super.methoda();
        }
    }
    
    // 继承b的内部类
    private class innerb extends b {
        public void methodb() {
            super.methodb();
        }
    }
    
    // 对外提供方法
    public void methoda() {
        new innera().methoda();
    }
    
    public void methodb() {
        new innerb().methodb();
    }
}

2. 封装实现细节

内部类可以用来隐藏实现细节，如集合类中的迭代器实现：

public class myarraylist<e> {
    private object[] elements;
    private int size;
    
    // 其他代码...
    
    // 使用内部类实现迭代器
    private class myiterator implements iterator<e> {
        private int cursor;
        
        @override
        public boolean hasnext() {
            return cursor < size;
        }
        
        @override
        public e next() {
            if (cursor >= size) {
                throw new nosuchelementexception();
            }
            return (e) elements[cursor++];
        }
    }
    
    // 对外提供获取迭代器的方法
    public iterator<e> iterator() {
        return new myiterator();
    }
}

3. 回调机制

匿名内部类常用于实现事件监听和回调：

// 在swing中使用匿名内部类处理按钮点击
jbutton button = new jbutton("点击我");
button.addactionlistener(new actionlistener() {
    @override
    public void actionperformed(actionevent e) {
        system.out.println("按钮被点击了！");
    }
});

内部类与lambda表达式

在java 8之后，对于只有一个抽象方法的接口（函数式接口），可以使用lambda表达式代替匿名内部类，使代码更加简洁：

// 使用匿名内部类
runnable r1 = new runnable() {
    @override
    public void run() {
        system.out.println("使用匿名内部类");
    }
};

// 使用lambda表达式
runnable r2 = () -> system.out.println("使用lambda表达式");

// 启动线程
new thread(r1).start();
new thread(r2).start();

// 直接使用lambda创建线程
new thread(() -> system.out.println("直接使用lambda")).start();

内部类编译后的文件命名规则

编译含有内部类的java文件后，会生成多个.class文件：

成员内部类：外部类名$内部类名.class
静态内部类：外部类名$内部类名.class
局部内部类：外部类名$数字内部类名.class
匿名内部类：外部类名$数字.class

例如，如果有以下类定义：

public class outer {
    class inner {}
    static class staticinner {}
    
    public void method() {
        class localinner {}
        
        new runnable() {
            public void run() {}
        };
    }
}

编译后将生成以下文件：

outer.class
outer$inner.class
outer$staticinner.class
outer$1localinner.class
outer$1.class（匿名内部类）

内部类面试常见问题

1. 内部类的各种差异比较

特性	成员内部类	静态内部类	局部内部类	匿名内部类
定义位置	类成员位置	类成员位置	方法内部	方法内部
访问修饰符	可以使用	可以使用	不能使用	不能使用
是否可静态	jdk16前不可	可以	不可以	不可以
是否需要外部类对象	需要	不需要	需要	需要
是否可以访问外部类非静态成员	可以	不可以	可以	可以
是否可以访问外部类静态成员	可以	可以	可以	可以

2. 为什么局部内部类只能访问final局部变量？

这是因为局部变量在方法结束后就会被销毁，而局部内部类对象可能在方法结束后仍然存在。如果允许内部类修改局部变量，当变量已经被销毁后，内部类却还引用这个变量，会导致数据不一致。为了解决这个问题，java要求局部内部类访问的局部变量必须是final的（java 8后可以是effectively final）。

内部类与外部类的关系

内部类与外部类的关联

内部类持有外部类的引用
- 非静态内部类隐式持有外部类的引用（outer.this）
- 这也是为什么非静态内部类能访问外部类所有成员的原因
- 注意：这可能导致内存泄漏，当内部类对象生命周期比外部类对象长时
编译后的实现细节
- 内部类编译后会生成独立的.class文件
- 非静态内部类的构造函数会隐式接收外部类的引用
- 访问外部类私有成员时，编译器会生成特殊的访问方法

// 编译前的代码
public class outer {
    private int x = 10;
    
    class inner {
        void access() {
            system.out.println(x);  // 访问外部类的私有成员
        }
    }
}

// 编译器处理后的逻辑（简化表示）
public class outer {
    private int x = 10;
    
    // 为内部类提供的访问方法
    static int access$000(outer outer) {
        return outer.x;
    }
    
    class inner {
        final outer this$0;  // 持有外部类引用
        
        inner(outer outer) {
            this$0 = outer;  // 保存外部类引用
        }
        
        void access() {
            system.out.println(outer.access$000(this$0));  // 通过特殊方法访问
        }
    }
}

总结

内部类是java中一个强大的特性，它允许我们在一个类中定义另一个类，增强了封装性和代码的组织结构。主要分为四种类型：

成员内部类：像普通成员一样的内部类
静态内部类：使用static修饰的内部类
局部内部类：定义在方法中的内部类
匿名内部类：没有名字的内部类

内部类存在的主要意义：

提高封装性，隐藏实现细节
实现类似多重继承的功能
更好地组织逻辑上紧密相关的类
简化事件处理和回调机制的实现
提供更灵活的访问控制

使用内部类的建议：

当一个类只对另一个类有用时，考虑使用内部类
需要访问外部类私有成员时，使用非静态内部类
不需要访问外部类实例成员时，优先使用静态内部类（减少内存引用）
仅在方法内使用的类，定义为局部内部类
实现接口或扩展类且只使用一次时，考虑使用匿名内部类或lambda表达式

随着java的发展，内部类与lambda表达式、方法引用等新特性结合使用，可以使代码更加简洁和易读。掌握内部类是成为java高级开发者的必备技能。

到此这篇关于java中内部类的文章就介绍到这了,更多相关java内部类内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！


验证码：

Java中的内部类超详细讲解

2025年07月04日 • Java •我要评论