Java-内部类

一、内部类的基本概念

1. 什么是内部类

内部类（Inner Class）是定义在另一个类内部的类。它可以访问外部类的所有成员，包括私有成员。

2. 内部类的分类

• 成员内部类（Member Inner Class）

• 静态内部类（Static Nested Class）

• 局部内部类（Local Inner Class）

• 匿名内部类（Anonymous Inner Class）

二、成员内部类

1. 定义方式

class Outer {
    private int outerField = 10;
    
    // 成员内部类
    class Inner {
        void display() {
            System.out.println("访问外部类字段: " + outerField);
        }
    }
}

2. 特点

• 可以访问外部类的所有成员（包括private）

• 不能定义静态成员（除非是静态常量）

• 必须通过外部类实例来创建内部类实例

3. 创建实例

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.display();

4. 使用场景

• 当需要访问外部类私有成员时

• 逻辑上紧密相关的类组合

三、静态内部类

1. 定义方式

class Outer {
    private static int staticField = 20;
    
    // 静态内部类
    static class StaticInner {
        void display() {
            System.out.println("访问外部类静态字段: " + staticField);
        }
    }
}

2. 特点

• 只能访问外部类的静态成员

• 可以有自己的静态成员

• 不依赖外部类实例

3. 创建实例

Outer.StaticInner staticInner = new Outer.StaticInner();
staticInner.display();

4. 使用场景

• 不需要访问外部类实例成员时

• 工具类或辅助类

四、局部内部类

1. 定义方式

class Outer {
    void outerMethod() {
        final int localVar = 30;
        
        // 局部内部类
        class LocalInner {
            void display() {
                System.out.println("访问局部变量: " + localVar);
            }
        }
        
        LocalInner inner = new LocalInner();
        inner.display();
    }
}

2. 特点

• 定义在方法或作用域内

• 只能访问final或effectively final的局部变量

• 作用范围仅限于定义它的代码块

3. 使用场景

• 只在某个方法内部使用的辅助类

• 需要访问方法局部变量的情况

五、匿名内部类

1. 定义方式

interface Greeting {
    void greet();
}

class Outer {
    void outerMethod() {
        // 匿名内部类
        Greeting greeting = new Greeting() {
            @Override
            public void greet() {
                System.out.println("Hello, 匿名内部类!");
            }
        };
        
        greeting.greet();
    }
}

2. 特点

• 没有类名，直接实例化接口或抽象类

• 只能创建一个实例

• 可以访问外部类的成员和final局部变量

3. 使用场景

• 事件监听器

• 只需要使用一次的简单实现

• Java 8之前实现函数式编程的方式

六、内部类的特殊语法

1. 访问外部类引用

class Outer {
    private String name = "Outer";
    
    class Inner {
        void printNames() {
            System.out.println("内部类: " + this);
            System.out.println("外部类: " + Outer.this);
        }
    }
}

2. 内部类中的this

• this：指代内部类实例本身

• Outer.this：指代外部类实例

七、内部类的字节码分析

编译后会产生独立的.class文件：

• 成员内部类：Outer$Inner.class

• 静态内部类：Outer$StaticInner.class

• 局部内部类：Outer$1LocalInner.class（数字表示定义顺序）

• 匿名内部类：Outer$1.class，Outer$2.class等

八、内部类的实际应用

1. 迭代器模式实现

public class MyList {
    private String[] items = {"A", "B", "C"};
    
    public Iterator iterator() {
        return new MyIterator();
    }
    
    // 成员内部类实现迭代器
    private class MyIterator implements Iterator {
        private int index = 0;
        
        public boolean hasNext() {
            return index < items.length;
        }
        
        public String next() {
            return items[index++];
        }
    }
}

2. 构建器模式

public class Person {
    private final String name;
    private final int age;
    
    private Person(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
    }
    
    // 静态内部类作为构建器
    public static class Builder {
        private String name;
        private int age;
        
        public Builder name(String name) {
            this.name = name;
            return this;
        }
        
        public Builder age(int age) {
            this.age = age;
            return this;
        }
        
        public Person build() {
            return new Person(this);
        }
    }
}

九、内部类的优缺点

优点：

1. 更好的封装性（可以隐藏实现细节）

2. 直接访问外部类成员

3. 代码组织更清晰

4. 可以避免命名冲突

缺点：

1. 增加代码复杂度

2. 可能造成内存泄漏（特别是非静态内部类持有外部类引用）

3. 调试难度增加

十、使用建议

1. 优先考虑静态内部类：除非需要访问外部类实例成员

2. 避免过度使用：只在逻辑上真正相关时使用

3. 注意内存泄漏：非静态内部类隐式持有外部类引用

4. 考虑替代方案：Java 8+的Lambda可以替代某些匿名内部类用法

总结

Java内部类是一个强大的特性，提供了多种形式的类定义方式：

• 成员内部类：紧密关联，访问外部类实例成员

• 静态内部类：不依赖外部类实例，访问静态成员

• 局部内部类：方法内临时使用，访问final局部变量

• 匿名内部类：一次性实现，简洁但有限

合理使用内部类可以：

• 提高代码的封装性和组织性

• 实现更优雅的设计模式

• 创建更灵活的代码结构