我有一个基类，它捕获了两个类共有的一些功能。换句话说，我可以创建一个基类并使这两个类成为该基类的子类。但是，对于这些子类中的每一个，可以创建的实例数为 1（即每个子类必须是单例）。 我在谷歌上搜索，发现对此进行了合理的辩论。尽管有多种解决方案可用，但我不确定它们是否适合我的情况。
谁能告诉我应该如何设计这个？
【问题讨论】：
标签： java design-patterns inheritance singleton
您可以将每个类单独设为单例，并使基类抽象。不知道争论的焦点是什么——一般来说，单例不是一个好主意吗？
【讨论】：
使用Abstract factory pattern。有一个单独的类，其中包含检索单例的方法，并让它在实例变量或映射中保存对单例的引用。
您可能不希望增加复杂性，但创建了像 Spring 这样的框架来解决这类问题（以及其他问题）。
似乎Pico Container 还活着，而且它可能是最简单但仍然可靠的解决方案。查看控制反转主题，让框架在您需要的地方注入单例。
简而言之，不要试图让单身人士管理自己的访问权限。把它委托给别的东西。
具有复杂继承的单例类本身并没有错。事实上，具有私有构造函数（无实例）的类层次结构在许多情况下都非常有用。您只需决定如何管理单例的两个重要方面：创建和访问。
【讨论】：
我不知道你是否需要一个例子，但我试了一下。在不知道您的任何详细信息的情况下，此示例非常模糊。我也是来学习的，所以让我们知道你最终实现了什么。
基类：
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");
}
}
【讨论】：
我有一个类似的要求：我有多个具有重复方法和成员的缓存映射，所以我创建了一个抽象类，例如：
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"));
}
【讨论】：
我不是 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
}
【讨论】：
继承并不是重用通用功能的唯一方法。在一般情况下，遏制可能更可取。 考虑以下解决方案，其中 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”的文件，那么您的两个单例都将执行此代码，即使它只打算执行一次，并且当稍后执行它将清除前者创建的文件。
因此，一般来说，这里描述的解决方案不使用继承，并确保单例封装了常用功能以及使用它的单例类。
【讨论】：