正如其他人所提到的，Lint警告是因为潜在的内存泄漏。你可以通过传递一个处理程序来避免Lint警告。回调时构造Handler(即你不子类化Handler，没有Handler非静态内部类):

Handler mIncomingHandler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        // todo
        return true;
    }
});

据我所知，这并不能避免潜在的内存泄漏。消息对象持有对mIncomingHandler对象的引用，该对象持有对Handler的引用。回调对象，该对象持有对Service对象的引用。只要Looper消息队列中有消息，服务就不会被GC。但是，除非消息队列中有长时间延迟的消息，否则这不会是一个严重的问题。

如果您正在使用Kotlin，只需在声明嵌套类时删除inner关键字即可。

Kotlin中的嵌套类默认情况下是静态的，使用inner声明它们使它们成为非静态的。

将嵌套的Handler子类声明更改为

class myService : Service() {

inner class IncomingHandler : Handler(Looper.getMainLooper()) {
/////
}

}

to

class myService : Service() {

class IncomingHandler : Handler(Looper.getMainLooper()) {
/////
}

}

我不确定，但你可以尝试初始化处理程序为空在onDestroy()

这种方法对我来说很有效，通过将处理消息的位置保留在它自己的内部类中，从而保持代码干净。

您希望使用的处理程序

Handler mIncomingHandler = new Handler(new IncomingHandlerCallback());

内部类

class IncomingHandlerCallback implements Handler.Callback{

        @Override
        public boolean handleMessage(Message message) {

            // Handle message code

            return true;
        }
}

借助@Sogger的回答，我创建了一个通用的Handler:

public class MainThreadHandler<T extends MessageHandler> extends Handler {

    private final WeakReference<T> mInstance;

    public MainThreadHandler(T clazz) {
        // Remove the following line to use the current thread.
        super(Looper.getMainLooper());
        mInstance = new WeakReference<>(clazz);
    }

    @Override
    public void handleMessage(Message msg) {
        T clazz = mInstance.get();
        if (clazz != null) {
            clazz.handleMessage(msg);
        }
    }
}

的接口:

public interface MessageHandler {

    void handleMessage(Message msg);

}

我是这样使用的。但我不能百分百确定这是否安全。也许有人可以对此发表评论:

public class MyClass implements MessageHandler {

    private static final int DO_IT_MSG = 123;

    private MainThreadHandler<MyClass> mHandler = new MainThreadHandler<>(this);

    private void start() {
        // Do it in 5 seconds.
        mHandler.sendEmptyMessageDelayed(DO_IT_MSG, 5 * 1000);
    }

    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case DO_IT_MSG:
                doIt();
                break;
        }
    }

    ...

}

正如其他人所提到的，Lint警告是因为潜在的内存泄漏。你可以通过传递一个处理程序来避免Lint警告。回调时构造Handler(即你不子类化Handler，没有Handler非静态内部类):

Handler mIncomingHandler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        // todo
        return true;
    }
});

据我所知，这并不能避免潜在的内存泄漏。消息对象持有对mIncomingHandler对象的引用，该对象持有对Handler的引用。回调对象，该对象持有对Service对象的引用。只要Looper消息队列中有消息，服务就不会被GC。但是，除非消息队列中有长时间延迟的消息，否则这不会是一个严重的问题。