Question

我有一个Plugin.java类，我在其中定义了两个方法，一个用于使用JobScheduler（如果API＆gt; = 21），另一个用于使用AlarmManager（如果API＆lt; 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(){...}
}

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

由于我不能使用Abstract或Super类，因为我已经扩展了JobService和BroadcastReceiver。我知道Java并不允许我扩展多个类，因为它会导致＆＃34; Diamond问题＆＃34;编译器无法决定使用哪种超类方法。
通过使用接口，我只能声明没有实现的方法（方法签名）。
我知道我可以使用静态和默认方法（使用接口），但它们是在Java 8（Android Nougat - API 24）中引入的。因此，如果我使用它们，使用JobScheduler（API＆gt; = 21）和AlarmManager（API＆lt; 21）的整个逻辑就毫无意义。

我可以有另一个实现该方法的类，只需从ScheduleDeleteService（JobService）和ScheduleDeleteReceiver（BroadCastReceiver）类中调用它，但我想提供一些建议来帮助我更好地实现。

Answer 1

还有一个选项选项：您可以通过界面遵循这个想法，并将实现放在匿名类中。因此，您需要一个单独的接口和实现类，但只需要一个额外的文件。当然，如果可能的话，使用默认方法/多重继承的解决方案会更加优雅。

<强> OldEntriesCleaner.java

interface OldEntriesCleaner {
    void deleteOldEntries();
}

主要活动

@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中找到的那样：

如果这些陈述中的任何一个适用于您的情况，请考虑使用抽象类：


您希望在几个密切相关的类之间共享代码。

...

首先，我实现了ScheduleDelete抽象类：

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

之后，在ScheduleDeleteService类中调用了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类中，我调用了ScheduleDelete＃deleteOldEntries（）方法：

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

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

2 个答案: