Java中的单例和继承

Question

我有一个基类，它捕获了两个类共有的一些功能。 换句话说，我可以创建一个基类，并使这两个类成为该基类的子类。 但是，对于这些子类中的每一个，可以创建的实例数为1（即，每个子类必须为单例）。 我搜寻了一下，发现对此进行了合理的辩论。 尽管有几种解决方案可用，但我不确定它们是否适合我的情况。

谁能告诉我该如何设计？

Answer 1

您可以使每个类单独成为一个单例，并使基类抽象。 不确定辩论是什么-通常来说，单例不是一个好主意吗？

Answer 2

使用抽象工厂模式 。 有一个单独的类，其类具有检索单例的方法，并使其在实例变量或映射中保存对单例的引用。

您可能不希望增加复杂性，但是创建了像Spring这样的框架来解决这类问题（以及其他问题）。

似乎Pico容器还可以正常使用，并且可能是最简单而又可靠的解决方案。 查看控制主题的反转 ，然后让框架在您需要的地方注入单例。

简而言之，不要试图让单身人士管理对自己的访问。 将其委托给其他人。

具有复杂继承的单例类没有内在的错误。 实际上，在许多情况下，具有私有构造函数（无实例）的类层次结构非常有用。 您只需要决定如何管理单例的两个重要方面：创建和访问。

Answer 3

我有一个类似的要求：我有多个具有重复方法和成员的缓存映射，因此我创建了一个抽象类，如：

public abstract class AbstractCache<T> {

    protected final Map<String, T> cache;

    protected AbstractCache() {
        this.cache = getDefaultExpiringMap(TimeUnit.HOURS.toMillis(4));
    }

    public Map<String, T> getCache() {
        return cache;
    }

    public T getAll(String id) {
        return cache.get(id);
    }
}

然后，我扩展了此类并创建了一个单例实例：

public final class FooCache extends AbstractCache<Set<Integer>> {

    public static final FooCache INSTANCE = new FooCache();

    private FooCache() {
        super();
    }

    public void add(String fooId, Integer value) {
        cache.computeIfAbsent(fooId, k -> new HashSet<>()).add(value);
    }
}

以及用法：

public static void main(String[] args) {
    FooCache.INSTANCE.add("a", 1);
    System.out.println(FooCache.INSTANCE.getAll("a"));
}

Answer 4

我不知道您是否需要一个示例，但我尝试了一下。 在不知道您的任何细节的情况下，该示例非常模糊。 我也在这里学习，所以让我们知道您最终实现了什么。

基类：

  public abstract class BaseClass {

        public void someMethod() {
            System.out.println("base class hello: " + this);
        }

        public abstract void someOtherMethod(String value);
    }

子类之一：

public class SubClassOne extends BaseClass {

    private static SubClassOne instance;

    private SubClassOne() {}

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

    public void someOtherMethod(String value) {
        someMethod();
        System.out.println("sub class hello: " + value + " " + this);
    }

    public static void main(String[] args) {
        SubClassOne one = SubClassOne.getInstance();
        SubClassOne two = SubClassOne.getInstance();
        SubClassOne three = SubClassOne.getInstance();
        SubClassOne four = SubClassOne.getInstance();
        one.someOtherMethod("one");
        two.someOtherMethod("two");
        three.someOtherMethod("three");
        four.someOtherMethod("four");
    }
}

Answer 5

继承不是重用通用功能的唯一方法。 在通常情况下，围堵可能更可取。 考虑以下解决方案，其中A类和B类是单例，并且通用功能在AB类中，但是A和B都使用AB实例（本身是单例）来代替AB的扩展。

class AB { //common functionality of A and B
   //singleton pattern here
   //common data and functionality here
}
class A {
   private AB ab = AB.getInstance();
   //singleton pattern here
   //unique functionality and data of A

   //to use any of the functionality in AB delegate to member ab
}

B类类似于A。

在此解决方案中，A和B（以及AB）的每个数据和功能都只有一个实例

请注意，如果A和B的客户需要访问AB中的通用公共方法，则AB，A和B应该实现这些公共方法的接口，而A和B的实现应该将调用委托给ab。

---

下面的欧内斯特（Ernest）提出的解决方案在某些情况下可能是捷径，但总的来说是错误的解决方案。

为了解释为什么欧内斯特的解决方案可能是错误的，让我们以另一种方式来描述该解决方案。 假设我有一个单例类A，并且发现需要编写另一个单例类B，但是我需要B中的A的某些功能。因此，我将A的通用数据和功能分解为抽象类AB，然后A和B都延伸AB。 一般来说，之所以会出错，是因为该解决方案采用了应该只存在一次的数据和功能的子集，并将其放在子类（AB）中，从而有效地并有可能在每个子类中复制它。将创建的类。 现在，在获得一个A实例和一个B实例之后，在AB中有两个子集数据和功能实例。

例如，如果放置在基类中的通用功能将一些初始数据写入名为“ myData”的文件，那么您的两个单例都将执行此代码，即使该代码仅打算执行一次，并在以后执行时也是如此。它将清除前者创建的文件。

因此，通常，此处描述的解决方案不使用继承，并确保单例封装通用功能以及使用它的单例类。

Answer 6

我不是Java方面的专家，所以我不知道这在技术上是否是合法的Java代码（也许其他张贴者可以发表评论）：

使基类从通用类Singleton继承。

例：

class Singleton<T> {

    protected Singleton(); //constructor

    private static T _instance;

}

class DerivedOne extends Singleton<DerivedOne>{

    protected DerivedOne(){} //constructor
}

class DerivedTwo extends Singleton<DerivedTwo>{

    protected DerivedTwo(){} //constructor
}