Java单例枚举编程到接口？

Question

这是我在这里的第一篇文章，所以我会尽量准确。这是一个大学项目，我们必须在我们单独制作的 OO 架构之上创建一个鱼缸模拟。我正在探索单例的用途并发现它们非常有用，但是在线阅读我目前实现它的方式并不是线程安全的。

我目前实现的方式（认为是惰性方法）注意：我们必须通过接口

public interface myInterface
{
  void foo();
}

public class myClass implements myInterface
{
  private static myInterface instance;

  private myClass(){}

  private static myInterface Instance()
  {
     if(instance == null)
       instance = new myClass();

     return instance;
  }

  public void foo()
  {
    //Do stuff
  }

  public void bar()
  {
   //Do More Stuff
  }
}

这很好用，但是它不是线程安全的

private synchronized static myInterface Instance()
{
  if(instance == null)
    instance = new myClass();

  return instance;
} 

然后我转向一个枚举单例，它是线程安全的并且对系统来说并不繁重，但是我不确定如何将它编程到接口。

public enum myClass implements myInterface
{
  INSTANCE;
  private myClass(){}

  public void foo()
  {
    //Do stuff
  }

  public void bar()
  {
   //Do More Stuff
  }
}

在对接口进行编程时，我的意思是当我调用单例时，我只能访问接口中的方法（如果我指错了，请纠正我）。这就是我完成枚举单例的方式失败的地方。例如：对于惰性单例，我不能将其称为不在界面中：

 myClass.Instance().bar();

但是它可以调用这个是正确的，因为它是在界面中。

myClass.Instance().foo();

但是我可以使用枚举调用它，而不是对接口进行编程

myClass.INSTANCE.bar();

我理解为什么它作为类是一个枚举，所以它可以调用该枚举类中的所有内容。所以在我道歉的这篇长文之后，主要问题是：我可以让枚举版本只调用接口中声明的方法吗？

如果系统上的同步方法不能有多重，我会拥有大约 4-6 个？

请注意：尽管这是针对大学项目的，但我们只在一个线程上运行模拟，因此它甚至不需要是线程安全的。我不太了解多线程，但我认为这将是一个很好的学习机会。

Answer 1

如果您更喜欢 enum 路由，您也可以随时隐藏您的 enum 实现：

public interface Singleton {
    void foo();
}

public final class SingletonAccessor {

    public static Singleton getInstance() {
        return SingletonImpl.INSTANCE;
    }

    private SingletonAccessor() {
    }

    private enum SingletonImpl implements Singleton {
        INSTANCE;
        public void foo() {
            // ...
        }
        public void bar() {
            // ...
        }
    }

}

编辑

正如 Peter Lawrey 在 cmets 中所指出的，您甚至可以为 SingletonAccessor 使用枚举 :)

public enum SingletonAccessor {

    SINGLETON;

    public Singleton get() {
        return SingletonImpl.INSTANCE;
    }

    private enum SingletonImpl implements Singleton {
        INSTANCE;
        public void foo() {
            // ...
        }
        public void bar() {
            // ...
        }
    }

}

Answer 2

您可以将其投射到界面或

myInterface my = myClass.INSTANCE;
my.foo();

你仍然可以使用类似的方法

myClass.getInstance().foo();

但这不是一个真正的解决方案恕我直言。

我可以让枚举版本只调用接口中声明的方法吗？

最终，您必须决定要在实例上使用哪些方法，即public。如果您将方法或字段设为公开，则可以访问它，如果您不想访问，请将其设为私有。

在某些时候，您必须相信自己知道自己在做什么，并且做事是有原因的。您不必想办法阻止自己调用您编写的代码。

Answer 3

只需以这种方式更改您的单例类：

public class myClass implements myInterface
{
  private static myInterface instance = new myClass();

  private myClass(){}

  private static myInterface Instance()
  {
     return instance;
  }

  public void foo()
  {
    //Do stuff
  }

  public void bar()
  {
   //Do More Stuff
  }
}

这将确保在类加载时创建单例对象，您无需担心Instance() 方法中的竞争条件

Answer 4

尝试查看 java.util.concurrent.atomic.AtomicReference。特别是 compareAndSet。

instance.compareAndSet(null, new MyClass());

即如果你的实例字段为空，则设置为新对象，如果不为空，则保持原样。应该不那么重。