java虚拟行为'；s与泛型父项的继承

我有一个“数据管理器”类，它包含某种对象类型的列表 然后，当我开始升级代码时，我需要一种不同类型的管理器，它有一些相似之处-

loadData（…）、saveData（…）、add（…）、remove（…）

但也存在一些差异，这是每种管理者所独有的，取决于其“管理”的类型。 因此，我决定采用以下结构： 为每个子级实现Singleton的泛型类（起初，我的管理器是静态的，因为它没有成为多个实例的感觉）：

公共抽象类GenericDataManager{
受保护名单；
受保护的void saveData（上下文，字符串文件路径）{..}
受保护的void loadData（上下文，字符串文件路径）{..}
..
}

我的两位经理如下：

public class ManagerA extends GenericDataManager<A> {
private static ManagerA instance = null;

    protected ManagerA() { }
    public static ManagerA getInstance() {
        if (instance == null)
            instance = new ManagerA();
        return instance;
    }

     private void saveData(Context context) {
        saveData(context, "fileA");
    }

    private void loadData(Context context) {
        loadData(context, "fileA");
    }
}

public class ManagerB extends GenericDataManager<B> {
private static ManagerB instance = null;

    protected ManagerB() { }
    public static ManagerB getInstance() {
        if (instance == null)
            instance = new ManagerB();
        return instance;
    }

     private void saveData(Context context) {
        saveData(context, "fileB");
    }

    private void loadData(Context context) {
        loadData(context, "fileB");
    }
}

公共类管理器扩展了GenericDataManager{
私有静态管理器实例=null；
受保护的ManagerA（）{}
公共静态管理器getInstance（）{
if（实例==null）
instance=newmanagera（）；
返回实例；
}
私有void saveData（上下文）{
保存数据（上下文，“文件A”）；
}
私有void loadData（上下文）{
加载数据（上下文，“文件A”）；
}
}
公共类管理器B扩展了GenericDataManager{
私有静态ManagerB实例=null；
受保护的ManagerB（）{}
公共静态管理器b getInstance（）{
if（实例==null）
instance=newmanagerb（）；
返回实例；
}
私有void saveData（上下文）{
保存数据（上下文，“文件B”）；
}
私有void loadData（上下文）{
加载数据（上下文，“文件B”）；
}
}

我在这里只展示了两个管理器的相似代码片段，您已经看到了问题所在——尽管我设法使我的相似代码片段只实现了一个，并使用泛型和继承机制为每个特定实现重用，但我仍然需要唯一的特定信息，即要使用的数据文件

泛型父类是否有办法从其子类请求该信息，这样我就不需要子类中的冗余实现

这样让我觉得我错过了什么。

怎么样：

public abstract class GenericDataManager<T> {
    protected abstract String getFilePath();
    protected List<T> list;
    protected void saveData(Context context) {
        String filePath = getFilePath();
        ..
    }
    protected void loadData(Context context) {
        String filePath = getFilePath();
        ..
    }
    ..
}

公共抽象类GenericDataManager{
受保护的抽象字符串getFilePath（）；
受保护名单；
受保护的void saveData（上下文）{
字符串filePath=getFilePath（）；
..
}
受保护的void loadData（上下文）{
字符串filePath=getFilePath（）；
..
}
..
}

然后：

public class ManagerA extends GenericDataManager<A> {
    private static ManagerA instance = null;

    protected ManagerA() { }
    public static ManagerA getInstance() {
        if (instance == null)
            instance = new ManagerA();
        return instance;
    }

    protected String getFilePath() { return "fileA" );
}

public class ManagerB extends GenericDataManager<A> {
    private static ManagerB instance = null;

    protected ManagerB() { }
    public static ManagerB getInstance() {
        if (instance == null)
            instance = new ManagerB();
        return instance;
    }

    protected String getFilePath() { return "fileB" );
}

公共类管理器扩展了GenericDataManager{
私有静态管理器实例=null；
受保护的ManagerA（）{}
公共静态管理器getInstance（）{
if（实例==null）
instance=newmanagera（）；
返回实例；
}
受保护的字符串getFilePath（）{return“fileA”）；
}
公共类管理器B扩展了GenericDataManager{
私有静态ManagerB实例=null；
受保护的ManagerB（）{}
公共静态管理器b getInstance（）{
if（实例==null）
instance=newmanagerb（）；
返回实例；
}
受保护的字符串getFilePath（）{return“fileB”）；
}

那么：

public abstract class GenericDataManager<T> {
    protected abstract String getFilePath();
    protected List<T> list;
    protected void saveData(Context context) {
        String filePath = getFilePath();
        ..
    }
    protected void loadData(Context context) {
        String filePath = getFilePath();
        ..
    }
    ..
}

公共抽象类GenericDataManager{
受保护的抽象字符串getFilePath（）；
受保护名单；
受保护的void saveData（上下文）{
字符串filePath=getFilePath（）；
..
}
受保护的void loadData（上下文）{
字符串filePath=getFilePath（）；
..
}
..
}

然后：

public class ManagerA extends GenericDataManager<A> {
    private static ManagerA instance = null;

    protected ManagerA() { }
    public static ManagerA getInstance() {
        if (instance == null)
            instance = new ManagerA();
        return instance;
    }

    protected String getFilePath() { return "fileA" );
}

public class ManagerB extends GenericDataManager<A> {
    private static ManagerB instance = null;

    protected ManagerB() { }
    public static ManagerB getInstance() {
        if (instance == null)
            instance = new ManagerB();
        return instance;
    }

    protected String getFilePath() { return "fileB" );
}

公共类管理器扩展了GenericDataManager{
私有静态管理器实例=null；
受保护的ManagerA（）{}
公共静态管理器getInstance（）{
if（实例==null）
instance=newmanagera（）；
返回实例；
}
受保护的字符串getFilePath（）{return“fileA”）；
}
公共类管理器B扩展了GenericDataManager{
私有静态ManagerB实例=null；
受保护的ManagerB（）{}
公共静态管理器b getInstance（）{
if（实例==null）
instance=newmanagerb（）；
返回实例；
}
受保护的字符串getFilePath（）{return“fileB”）；
}

那么：

public abstract class GenericDataManager<T> {
    protected abstract String getFilePath();
    protected List<T> list;
    protected void saveData(Context context) {
        String filePath = getFilePath();
        ..
    }
    protected void loadData(Context context) {
        String filePath = getFilePath();
        ..
    }
    ..
}

公共抽象类GenericDataManager{
受保护的抽象字符串getFilePath（）；
受保护名单；
受保护的void saveData（上下文）{
字符串filePath=getFilePath（）；
..
}
受保护的void loadData（上下文）{
字符串filePath=getFilePath（）；
..
}
..
}

然后：

public class ManagerA extends GenericDataManager<A> {
    private static ManagerA instance = null;

    protected ManagerA() { }
    public static ManagerA getInstance() {
        if (instance == null)
            instance = new ManagerA();
        return instance;
    }

    protected String getFilePath() { return "fileA" );
}

public class ManagerB extends GenericDataManager<A> {
    private static ManagerB instance = null;

    protected ManagerB() { }
    public static ManagerB getInstance() {
        if (instance == null)
            instance = new ManagerB();
        return instance;
    }

    protected String getFilePath() { return "fileB" );
}

公共类管理器扩展了GenericDataManager{
私有静态管理器实例=null；
受保护的ManagerA（）{}
公共静态管理器getInstance（）{
if（实例==null）
instance=newmanagera（）；
返回实例；
}
受保护的字符串getFilePath（）{return“fileA”）；
}
公共类管理器B扩展了GenericDataManager{
私有静态ManagerB实例=null；
受保护的ManagerB（）{}
公共静态管理器b getInstance（）{
if（实例==null）
instance=newmanagerb（）；
返回实例；
}
受保护的字符串getFilePath（）{return“fileB”）；
}

那么：

public abstract class GenericDataManager<T> {
    protected abstract String getFilePath();
    protected List<T> list;
    protected void saveData(Context context) {
        String filePath = getFilePath();
        ..
    }
    protected void loadData(Context context) {
        String filePath = getFilePath();
        ..
    }
    ..
}

公共抽象类GenericDataManager{
受保护的抽象字符串getFilePath（）；
受保护名单；
受保护的void saveData（上下文）{
字符串filePath=getFilePath（）；
..
}
受保护的void loadData（上下文）{
字符串filePath=getFilePath（）；
..
}
..
}

然后：

public class ManagerA extends GenericDataManager<A> {
    private static ManagerA instance = null;

    protected ManagerA() { }
    public static ManagerA getInstance() {
        if (instance == null)
            instance = new ManagerA();
        return instance;
    }

    protected String getFilePath() { return "fileA" );
}

public class ManagerB extends GenericDataManager<A> {
    private static ManagerB instance = null;

    protected ManagerB() { }
    public static ManagerB getInstance() {
        if (instance == null)
            instance = new ManagerB();
        return instance;
    }

    protected String getFilePath() { return "fileB" );
}

公共类管理器扩展了GenericDataManager{
私有静态管理器实例=null；
受保护的