【Java】内部类【主线学习笔记】

---

前言

Java是一门功能强大且广泛应用的编程语言，具有跨平台性和高效的执行速度，广受开发者喜爱。在接下来的学习过程中，我将记录学习过程中的基础语法、框架和实践技巧等，分享学习心得，对自己学习过程进行整理和总结，也希望能为其他学习Java的朋友提供一些帮助和参考。

---

内部类

在Java中，将一个类A定义在另一个类B的里面，里面那个类A就称为内部类，类B则称为外部类。
当一类事务A的内部，还有一个部分需要一个完整的结构B进行描述，而这个内部的完整的结构B又只为外部事物A提供服务，不在其他地方单独使用，那么这个内部的完整结构B最好使用内部类。遵循高内聚，低耦合的面向对象开发原则。

内部类的使用举例

Thread类内部声明了state类，表示线程的生命周期。
HashMap类中声明了Node类，表示封装的key和value.

内部类的分类

• 成员内部类：直接声明在外部类的里面。其中有可以根据是否被static修饰而分为静态的成员内部类和非静态的成员内部类。

• 局部内部类：声明在方法内、构造器内、代码块内。其中又可以分为匿名的局部内部类和非匿名的局部内部类。

成员内部类:

class OuterClass {
    private String outerField = "Outer field";

    // 非静态成员内部类
    class InnerClass {
        void display() {
            System.out.println("Accessing from InnerClass: " + outerField);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建外部类对象
        OuterClass outer = new OuterClass();
        // 通过外部类对象创建内部类对象
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display();  // 输出: Accessing from InnerClass: Outer field
    }
}

静态成员内部类：

class OuterClass {
    private static String staticOuterField = "Static Outer field";

    // 静态成员内部类
    static class StaticInnerClass {
        void display() {
            System.out.println("Accessing from StaticInnerClass: " + staticOuterField);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建静态内部类对象，不需要外部类实例
        OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();//直接声明内部静态 类
        staticInner.display();  // 输出: Accessing from StaticInnerClass: Static Outer field
    }
}

局部内部类：

class OuterClass {
    void outerMethod() {
        // 定义局部内部类
        class LocalInnerClass {
            void display() {
                System.out.println("This is a local inner class.");
            }
        }
        // 使用局部内部类
        LocalInnerClass localInner = new LocalInnerClass();
        localInner.display();
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.outerMethod();  // 输出: This is a local inner class.
    }
}

匿名局部内部类：

public class OuterClassTest {
    
    //开发中常见情况
    //Comparable是一个接口
    //方式1：提供了接口的实现类的对象
    public Comparable getInstance1(){

        //提供了实现了comparable接口的类
        class myCompare implements Comparable{

            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        myCompare c = new myCompare();
        return c;
    }
    
    //方式2：提供了接口的实现类的匿名对象
    public Comparable getInstance2(){

        //提供了实现了comparable接口的类
        class myCompare implements Comparable{

            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        return new myCompare();
    }
    
    //方式3：提供了接口的匿名实现类的对象
    public Comparable getInstance3(){
        Comparable c = new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
        return c;
    }

    //方式4：提供了接口的匿名实现类的匿名对象
    public Comparable getInstance4(){
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }
    
}

对于成员内部类的理解

从类的角度：可以声明属性、方法、构造器、内部类、代码块等结构；可以声明父类，可以实现接口；可以使用final修饰；可以使用abstract修饰；
从外部类的角度看：在内部可以调用外部类的结构，如属性、方法等；除了使用public、缺省外，还可以用private、protected修饰

---