类必须按如下方式实现DefaultLifecycleObserver

public class MyFavoriteClass implements DefaultLifecycleObserver

然后实现所需的方法（Android Studio：ALT + i）

@Override
public void onResume(@NonNull LifecycleOwner owner) {
    methodRunsAtOnResume();
}

@Override
public void onDestroy(@NonNull LifecycleOwner owner) {
    myFavoriteOnDestroyMethod();
}

在您的Activity或片段中，将其添加到onCreate（）

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    MyOtherClass clazz = new MyOtherClass();
    getLifecycle().addObserver(clazz);
}

要更正确地实现它，请创建您自己的观察者类，将您想要观察的对象传递给它。

它已被弃用，因为他们现在希望您使用Java 8并实现接口DefaultLifecycleObserver。由于Java 8允许接口具有默认实现，因此他们使用所有方法的空实现来定义DefaultLifecycleObserver，这样您只需覆盖您使用的那些方法。
用@OnLifecycleEvent标记函数的旧方法是Java 8之前的项目的支柱，这是允许类选择性地选择它所关心的生命周期事件的唯一方法，替代方法是强制这些类覆盖所有的生命周期接口方法，即使将它们留空。
在您的情况下，请更改类以实现DefaultLifecycleObserver，并更改函数以覆盖DefaultLifecycleObserver的适用函数。如果您的项目尚未使用Java 8，则需要更新Gradle构建文件。将这些文件放入模块build.gradle的android块中：

compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = '1.8'
    }

• 注意：他们可能使用了旧的Java模式，即提供一个接口Adapter类，该接口类具有每个接口函数的开放、空的实现。然而，这种方法的缺点是侦听器必须是唯一的侦听器。但我认为，如果您关心封装，通常应该是这种情况。

为了跟踪当前Activity的生命周期，可以使用LifecycleEventObserver类。首先，创建一个回调，

private val lifecycleEventObserver = LifecycleEventObserver { source, event ->
    if (event == Lifecycle.Event.ON_RESUME ) {
        Log.e( "APP" , "resumed" )
    }
    else if ( event == Lifecycle.Event.ON_PAUSE ) {
        Log.e( "APP" , "paused" )
    }
}

使用lifecycle.add( Observer )方法在Activity的onCreate方法中附加回调，

lifecycle.addObserver( lifecycleEventObserver )

您只需将不推荐使用的@OnLifecycleEvent替换为DefaultLifecycleObserver，如以下示例所示：
旧代码：

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate() {
    // your code
}

新代码：

override fun onCreate(owner: LifecycleOwner) {
    super.onCreate(owner)
    // your code
}

您可以创建此函数以使用DefaultLifecycleObserver，并在Activity的onCreate（）生命周期回调中调用它

private fun addDefaultLifeCycleObserver() {
        val defaultLifecycleObserver = object : DefaultLifecycleObserver {
            override fun onCreate(owner: LifecycleOwner) {
                super.onCreate(owner)
                Log.d("Main", "DefaultLifecycleObserver - onCreate")
            }
        }
        lifecycle.addObserver(defaultLifecycleObserver)
    }

注解需要使用代码生成或反射，这应该避免。

使用DefaultLifecycleObserver或LifecycleEventObserver代替。使用LifecycleEventObserver，我们可以直接添加观察者：

private val lifecycleEventObserver = LifecycleEventObserver { source, event ->
        when (event) {
            Lifecycle.Event.ON_RESUME ->  onAppInForeground()
            Lifecycle.Event.ON_PAUSE -> onAppInBackground()
            Lifecycle.Event.ON_DESTROY-> onAppDestroyed()
            Lifecycle.Event.ON_CREATE -> {}
            Lifecycle.Event.ON_START -> {}
            Lifecycle.Event.ON_STOP -> {}
            Lifecycle.Event.ON_ANY -> {}
        }
    }

首先从LifecycleEventObserver继承类
然后在init块或onCreate中添加以下行：

lifecycle.addObserver(this)

或者，如果您正在非活动/片段类中工作，则添加以下内容：

ProcessLifecycleOwner.get().lifecycle.addObserver(this)

然后覆盖onStateChanged函数：

override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
    when(event){
        Lifecycle.Event.ON_STOP -> TODO()
        Lifecycle.Event.ON_CREATE -> TODO()
        Lifecycle.Event.ON_START -> TODO()
        Lifecycle.Event.ON_RESUME -> TODO()
        Lifecycle.Event.ON_PAUSE -> TODO()
        Lifecycle.Event.ON_DESTROY -> TODO()
        Lifecycle.Event.ON_ANY -> TODO()
    }
}

此外，如果您已经在manifest中实现了androidx-startup，请将该代码更改为以下代码，否则LifecycleEventObserver将不会调用：

<provider
         android:name="androidx.startup.InitializationProvider"
         android:authorities="${applicationId}.androidx-startup"
         android:exported="false"
         tools:node="merge">

<!-- If you are using androidx.startup to initialize other components then define it in this block-->
         
</provider>