android——内部类防止内存泄漏

简介

非静态内部类是指在一个类的内部定义另一个非静态类，这个非静态类就成为了外部类的成员之一。在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;

        public InnerClass(WeakReference 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 outer;

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

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

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

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