Java 泛型、单例和静态方法

Question

所以我有一些“经理”类，例如 GroupManager。所有这些经理都是单身人士。

使用此方法进行实例化：

private static GroupManager groupManager = null;

private GroupManager()
{

}

public static GroupManager Instance()
{
    if (groupManager == null)
    {
        groupManager = new GroupManager();
    }
    return groupManager;
}

我想我应该开始使用一些继承，因为它们有很多复制的方法。

每个 Manager 的 Instance() 方法都是相同的。

所以对于继承我可以这样做（显然）：

GroupManager extends Manager

是否可以使用泛型为所有管理器使用相同的实例方法，例如：

public class Manager<E>
{
    private static E instance = null;

    public static E Instance()
    {
        if (instance == null)
        {
            instance = new E();
        }
        return instance;
    }

}

我认为这是有道理的:)

那么你会像往常一样执行 GroupManager.Instance()。

Answer 1

你不明白泛型和静态是如何工作的。如果您有一个静态字段或方法（例如“instance”或 instance()），可以在不实例化类管理器的情况下调用它，您如何期望 JVM（甚至编译器）知道 E 应该是什么类型是吗？

这是一个例子，按照 G_H 的建议：

GeneralManager 和 AreaManager 都扩展了 Manager

Manager 类是唯一具有 getInstance() 静态方法的类：

    public class Manager {

        private static Map<Class<? extends Manager>,Manager> INSTANCES_MAP = new java.util.HashMap<Class<? extends Manager>, Manager>();

//Also, you will want to make this method synchronized if your application is multithreaded,
//otherwise you mihgt have a race condition in which multiple threads will trick it into
//creating multiple instances
        public static <E extends Manager> E getInstance(Class<E> instanceClass) throws InstantiationException, IllegalAccessException {
            if(INSTANCES_MAP.containsKey(instanceClass)) {
                return (E) INSTANCES_MAP.get(instanceClass);
            } else {
                E instance = instanceClass.newInstance();
                INSTANCES_MAP.put(instanceClass, instance);
                return instance;
            }
        }
    }

Answer 2

不，这行不通。 Java 在编译时使用泛型进行类型检查，但不会在运行时生成额外的类或保留有关类型参数的信息。

当您使用该类型参数E 声明Manager<E> 时，这只会在实际实例中发挥作用。你可以有一个像GroupManager extends Manager<String> 这样的子类，但这不会神奇地生成各种静态方法。

静态方法和成员属于一个类，而不是一个实例。所以尝试在那里使用泛型，用于键入实例，是行不通的。

Answer 3

如果您按如下方式创建组管理器类，那么您可以调用您的实例方法。

public class GroupManager extends Manager<GroupManager>{}

在你的 Manager 课上试试这个...

public class Manager<E>
{
private static E instance = null;

public static E Instance()
{
                  try {
            return instance.newInstance();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return null;  
}

或者，如果您知道要为其创建实例的对象，只需将方法设为通用

public static <T> T getInstance(Class<T> t){
             try {
            return t.newInstance();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return null;
    }

我还没有尝试过，所以不确定它是否会起作用。

Answer 4

在通用上下文中注入构造函数。现金不是线程安全的，但只在静态上下文中使用，所以如果你不错过使用它就可以了

public class Example {

    public static class MySingletonClass {
    }

    public interface Provider<T> {
        T get();
    }

    static final Provider<MySingletonClass> myClassInstanceProvider = new Cash<MySingletonClass>(new Provider<MySingletonClass>() {
            @Override
            public MySingletonClass get() {
                return new MySingletonClass();
            }
        }); 


    public static class Cash<T> implements Provider<T> {
        private Provider<T> provider;

        public Cash(Provider<T> provider) {
            this.provider = provider;
        }

        @Override
        public T get() {

            final T t = provider.get();
            provider = new Provider<T>() {

                @Override
                public T get() {
                    return t;
                }
            };
            return t;
        }
    }
}

Answer 5

public class Manager<E>{

private static Object instance = null;

    public static E Instance() {
       if (instance == null)
       {
        instance = new E();
       }
       return (E)instance;
   }
}