理解java特性：内部类

内部类

内部类, java的基础必学特性的尽头.

随便翻一本java名著 会发现 讲解的顺序一般就是 封装 继承 多态 接口 最后讲内部类。

内部类分很多种 我们先说最简单理解的。

简单理解 内部类就是 类里面再定义一个类。

新手要注意是类 里面定义了一个类 而不是类里面的的一个成员变量：

class Adapter{
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

  
}
Adapter 类里有一个Adaptee 类 
Adaptee 算不算是内部类

肯定不算

看一个内部类的经典例子：

public class OuterClass {
    private int outerField;

    public OuterClass(int outerField) {
        this.outerField = outerField;
    }

    // 成员内部类
    public class InnerClass {
        private int innerField;

        public InnerClass(int innerField) {
            this.innerField = innerField;
        }

        public void display() {
            System.out.println("Outer field: " + outerField);
            System.out.println("Inner field: " + innerField);
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass(10);
        OuterClass.InnerClass inner = outer.new InnerClass(20);
        inner.display();
    }
}

InnerClass 类是定义在 OuterClass 里面。
注意 内部类可以访问包括私有的外部类的成员变量：
System.out.println("Outer field: " + outerField);
但是外部类不能直接访问内部类的成员变量：

这个就是基本的成员内部类。

内部类适合在什么地方用？ 就是说内部的这个类是外部类的附属品 它独立存在没什么意义 但是直接把里面的东西都扔进外部类里面 又显得冗余。比如
汽车类里面内部定义一个发动机类
人体类里面内部定义一个心脏类

---

内部类分类

前三种对新手来说认识就好了 因为真正编码生涯里面 都是用的多写的很少， 重点是第四种要非常熟练

• 成员内部类
  就是上面的例子 内部类作为外部类的一个成员，直观的看就是在类里面 再定义一个类

• 静态内部类

public class OuterClass {
    private static int outerStaticField = 10;
    private int outerField = 20;

    // 静态内部类
    public static class StaticInnerClass {
        private static int innerStaticField = 30;

        public static void display() {
            System.out.println("Outer static field: " + outerStaticField); // 可直接访问外部类的静态成员
            // System.out.println("Outer field: " + outerField); // 编译错误，不能直接访问外部类的非静态成员
            System.out.println("Inner static field: " + innerStaticField);
        }
    }

    public static void main(String[] args) {
        OuterClass.StaticInnerClass.display(); // 直接通过类名访问静态内部类的静态成员
    }
}

StaticInnerClass是一个静态内部类，它可以直接访问外部类OuterClass的静态成员outerStaticField，但不能直接访问外部类的非静态成员outerField。在main方法中，我们通过外部类名直接访问了静态内部类的静态方法display。

注意上面的注释 静态内部类 他是个静态类 所以在静态类里面只能访问静态数据

然后再回忆static的含义 这个内部类并不属于某个OuterClass 的对象， 它属于OuterClass 本身，所以调用它不需要创建OuterClass 对象 直接 OuterClass.StaticInnerClass.display() 搞定！

现在可以回一下经典的单例模式设计， 单例模式就是经典的静态内部类

• 局部内部类

public class OuterClass {
    private int outerField = 10;

    public void display(int value) {
        // 局部内部类
        class LocalInnerClass {
            public void display() {
                System.out.println("Outer field: " + outerField); // 访问外部类的成员变量
                System.out.println("Method parameter: " + value); // 访问方法参数
            }
        }

        LocalInnerClass inner = new LocalInnerClass(); // 创建局部内部类的实例
        inner.display(); // 调用局部内部类的方法
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display(20);
    }
}

当一个类只在一个方法内部使用，并且不需要在其他地方访问时，可以考虑使用局部内部类。这样可以将局部内部类的作用域限制在方法内部，提高代码的封装性和安全性。
局部内部类可以用于实现一些辅助类或者工具类，使得方法内部的逻辑更加清晰，避免了将这些辅助类暴露在外部。

• 匿名内部类
  好了 前面两个认识就可以了， 现在我们来学习最最重要的 匿名内部类！

首先回到我们之前适配器的例子：
定义一个接口：

public interface SkyDream {
    public void fly();
}

需要一个类实现这个接口并重写方法
public class Plane implements SkyDream{
    @Override
    public void fly() {
        System.out.println("飞机实现了飞天的梦想");
    }
}

最后调用

public class InnerClassDemo {

    public static void sky(SkyDream skyDream){
        skyDream.fly();
    }

    public static void main(String[] args) {

     SkyDream skyDream = new Plane();
     
     sky(skyDream);
    }
}

所以对新手来说就有一个固有的思维 就是一个接口 一定要新建一个Plane类去实现它

现在问题来了 这个接口的方法 是一次性用品 调用者只调一次， 不需要每次都新建一个类去实现它，
其二 这个调用有可能是动态的 是代码执行过程中去调用 你事先无法预支 提前建好一个类去调用

这时候就出现了匿名内部类！

它的意义就是我可以不手动新建一个实现类的情况 直接重写接口的方法 ：

  public static void main(String[] args) {

     // 正常调用接口方法 先创建一个plane类去实现接口
        SkyDream skyDream = new Plane();

        sky(skyDream);

     //匿名内部类 根本不需要单独创建类 直接实现接口方法

        sky(new SkyDream() {
                @Override
                public void fly() {
                    System.out.println("匿名直接实现了飞天的梦想");
                }
            }
        );

        new SkyDream(){
            @Override
            public void fly() {
                System.out.println("第二种方式匿名直接实现了飞天的梦想");
            }
        }.fly();

    }

这里一定要注意 使用匿名内部类的意义和区别。

我重新了SkyDream 接口，但是我并没有创建任何类去 implements 它。

我直接用匿名内部类去重写了fly（）， 最后得到一个SkyDream 接口对象 然后直接调用我重写好的方法就好了

匿名经典案例

每一个java程序员都看过这段多创建程的代码，现在会看会发现 他就是标准的匿名内部类

public class Main {
    public static void main(String[] args) {
        // 匿名内部类实现Runnable接口
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello from anonymous inner class!");
            }
        };

        // 创建线程并启动
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

Runnable 是线程接口， 里面定义了 run方法 你需要调用它 那你本来需要新建一个类去实现Runnable 接口
但是匿名内部类就省掉了创建那个独立的类的过程！