避免两次实现方法（类已经扩展了抽象类）

Question

我有一个 Plugin.java class，我在其中定义了两种方法，一种使用 JobScheduler（如果 API >= 21），另一种使用 AlarmManager（如果 API < 21).

@Override
public void onCreate() {
    super.onCreate();

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        scheduleDeleteJobScheduler(...);
    } else {
        scheduleDeleteAlarmManager(...);
    }
}

scheduleDeleteJobScheduler() 方法使用 JobService 删除我在数据库中的一些旧条目。

public class ScheduleDeleteService extends JobService {

    @Override
    public boolean onStartJob(JobParameters params) {
        deleteOldEntries();
        jobFinished(params, false);
        return false;
    }

    @Override
    public boolean onStopJob(JobParameters params) {
        return false;
    }

    public void deleteOldEntries(){...}
}

scheduleDeleteAlarmManager() 方法使用 BroadcastReceiver 来执行与 JobService 相同的操作。

public class ScheduleDeleteReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        deleteOldEntries();
    }

    public void deleteOldEntries(){...}
}

两个 classes 调用 deleteOldEntries() 方法从数据库中删除旧条目。此方法对两者（JobService 和 BroadcastReceiver）都是相同的。我想做的是避免有两种方法具有相同的实现。

因为我不能使用 Abstract 或 Super classes，因为我已经在扩展 JobService 和 BroadcastReceiver。我知道 Java 不允许我扩展多个 classes 因为它会导致编译器无法决定使用哪个 superclass 方法的 "Diamond Problem" .
并且通过使用接口，我只能声明没有实现（方法签名）的方法。
我知道我可以使用静态方法和默认方法（使用接口），但它们是在 Java 8 (Android Nougat - API 24) 中引入的。因此，如果我使用它们，使用 JobScheduler (API >= 21) 和 AlarmManager (API < 21) 的整个逻辑将毫无意义。

我可以让另一个 class 实现该方法，然后从 ScheduleDeleteService (JobService) 和 ScheduleDeleteReceiver (BroadCastReceiver) classes 调用它，但我需要一些建议来帮助我做出更好的实现。

Answer 1

还有一个选项：您可以按照接口的想法并将实现放在匿名中 class。因此，您需要一个单独的接口和实现 class，但只需要一个额外的文件。当然，如果可能的话，默认 method/multiple 继承的解决方案看起来会更优雅。

OldEntriesCleaner.java

interface OldEntriesCleaner {
    void deleteOldEntries();
}

主要activity

@Override
public void onCreate() {
    super.onCreate();

    OldEntriesCleaner cleaner = new OldEntriesCleaner() {
        @Override
        public void deleteOldEntries() {
            // Do the work here
        }
    };
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        scheduleDeleteJobScheduler(..., cleaner)
    } else {
        scheduleDeleteAlarmManager(..., cleaner)
    }
}

服务

public class ScheduleDeleteReceiver extends BroadcastReceiver {

    private OldEntriesCleaner cleaner;

    public ScheduleDeleteReceiver(OldEntriesCleaner cleaner) {
        this.cleaner = cleaner;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        cleaner.deleteOldEntries();
    }

}

Answer 2

我们可以在 Abstract Methods and Classes 中找到：

Consider using abstract classes if any of these statements apply to your situation:

You want to share code among several closely related classes.

...

首先，我实现了 ScheduleDelete Abstract Class:

abstract class ScheduleDelete {
    public void deleteOldEntries(){ ... }
}

之后，在 ScheduleDeleteService 中 class 我调用了 ScheduleDelete#deleteOldEntries() 方法：

public class ScheduleDeleteService extends JobService {

    @Override
    public boolean onStartJob(JobParameters params) {
        (new ScheduleDelete(){}).deleteOldEntries();
        jobFinished(params, false);
        return false;
    }

    @Override
    public boolean onStopJob(JobParameters params) {
        return false;
    }
}

在 ScheduleDeleteReceiver class 中，我调用了 ScheduleDelete#deleteOldEntries() 方法：

public class ScheduleDeleteReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        (new ScheduleDelete(){}).deleteOldEntries();
    }
}

避免两次实现方法（类已经扩展了抽象类）

Avoid implementing method twice (Classes already extending abstract classes)

java

android

alarmmanager

jobservice

避免两次实现方法（类 已经扩展了抽象 类）

Avoid implementing method twice (Classes already extending abstract classes)

java

android

alarmmanager

jobservice

避免两次实现方法（类已经扩展了抽象类）