简介

非静态内部类是指在一个类的内部定义另一个非静态类，这个非静态类就成为了外部类的成员之一。在Java中，要防止非静态内部类的内存泄漏，需要注意以下几点：

1. 非静态内部类必须保存对外部类实例的引用，因此要避免外部类实例和内部类实例的相互引用，否则会导致内存泄漏。

2. 要避免内部类持有外部类实例的引用，可以使用弱引用或者静态内部类的方式。

3. 如果使用弱引用，要注意判断弱引用是否为空，否则会产生空指针异常。

1、使用弱引用或者静态内部类的方式

非静态内部类的例子（存在内存泄漏）

public class OuterClass {
    private String name;

    public OuterClass(String name) {
        this.name = name;
    }

    public void display() {
        InnerClass innerClass = new InnerClass();
        innerClass.printName();
    }

    private class InnerClass {
        public void printName() {
            System.out.println(name);
        }
    }
}

在上面的例子中，内部类持有外部类实例的引用，如果外部类实例被销毁，内部类仍然存在，就会造成内存泄漏。要避免这种情况，可以使用弱引用或者静态内部类的方式，如下所示：

public class OuterClass {
    private String name;

    public OuterClass(String name) {
        this.name = name;
    }

    public void display() {
        InnerClass innerClass = new InnerClass(new WeakReference<>(this));
        innerClass.printName();
    }

    private static class InnerClass {
        private WeakReference<OuterClass> outerClass;

        public InnerClass(WeakReference<OuterClass> outerClass) {
            this.outerClass = outerClass;
        }

        public void printName() {
            OuterClass outer = outerClass.get();
            if (outer != null) {
                System.out.println(outer.name);
            } else {
                System.out.println("OuterClass instance has been collected.");
            }
        }
    }
}

2、释放非静态内部类引用防止内存泄漏

Java 中的非静态内部类是依赖于外部类对象而存在的，因此在使用非静态内部类时需要注意及时释放引用。下面是几种释放非静态内部类引用的方法：

一、将内部类对象的引用设置为 null，这样 JVM 会自动回收内存。

OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
//使用inner对象
inner = null; //释放内部类对象引用

二、将外部类对象的引用设置为 null，这样内部类对象也会被释放。

OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
//使用inner对象
outer = null; //释放外部类对象引用和内部类对象引用

三、在非静态内部类中，使用弱引用或软引用来引用外部类对象，这样在外部类对象不再被使用时就可以被 JVM 回收。

public class OuterClass {
    public class InnerClass {
        private WeakReference<OuterClass> outer;

        public InnerClass(OuterClass outer) {
            this.outer = new WeakReference<>(outer);
        }
        
        //使用outer.get()获取外部类对象
    }
}

四、在非静态内部类中，使用静态内部类代替非静态内部类。静态内部类不依赖于外部类对象而存在，因此可以避免内存泄漏。

public class OuterClass {
    public static class InnerClass {
        //使用静态内部类
    }
}

通过以上几种方法可以有效地释放非静态内部类的引用，避免内存泄漏问题。

附加：如何查看我们写的代码有没有造成内存泄漏呢

在 Android 中，可以使用 Android Profiler 工具来检测是否有内存泄漏。以下是使用 Android Profiler 的步骤：

1. 打开 Android Studio，启动要测试的应用程序。

2. 点击“Run”按钮，将应用启动到设备或模拟器上。

3. 点击 Android Studio 的“Profiler”选项卡，然后点击“Memory”（内存）选项卡。

4. 等待一段时间，直到你看到内存使用图，然后尝试重现内存泄漏的情况。

5. 在内存泄漏发生时，点击“Dump Java Heap”按钮，生成堆转储文件。

6. 在 Android Profiler 中点击“Export”按钮，将堆转储文件保存到本地。

7. 在 Android Studio 中打开 Android Device Monitor，然后选择“Heap Dump”选项卡。

8. 点击“Open”按钮并选择刚才保存的堆转储文件，然后点击“OK”。

9. 在 Heap Dump 分析器中查找可能的内存泄漏。

10. 可以使用一些第三方工具，例如 LeakCanary 或 MAT（Memory Analysis Tool）来分析堆转储文件，以确定内存泄漏的原因。