Java 如何在枚举中定义泛型成员变量？

我想引用一个枚举方法来检索算法的类，这样我就可以延迟加载算法的一个新实例，以便在策略设计模式中使用

在本例中，我使用一个枚举来引用计算斐波那契数的三个不同策略类：

RecursiveFibonacciGenerator

、

IterativeFibonacciGenerator

、和

memorizedFibonaccigenerator

（所有这些都继承自

FibonacciGenerator

）

代码（生成错误的行带有注释）如下所示：

package com.example.strategy;

public class Fibonacci {
    private enum Algorithm {
        RECURSIVE (RecursiveFibonacciGenerator.class),
        ITERATIVE (IterativeFibonacciGenerator.class),
        MEMOIZED (MemoizedFibonacciGenerator.class);

        private final Class<T> algorithmClass; // Declare class of same type as constructor
        private final T instance; // Declare instance of class defined in constructor
        private <T extends FibonacciGenerator> Algorithm(Class<T> algorithmClass) {
            this.algorithmClass = algorithmClass;
        }

        public T getInstance() {
            if (this.instance == null) {
                this.instance = this.algorithmClass.newInstance();
            }
            return this.instance;
        }
    }

    public Integer getTerm(Integer termNumber) {
        profileGenerator(termNumber, Algorithm.RECURSIVE);
        profileGenerator(termNumber, Algorithm.ITERATIVE);
        return profileGenerator(termNumber, Algorithm.MEMOIZED);
    }

    private Integer profileGenerator(Integer termNumber, Algorithm algorithm) {
        System.out.print("Computing term using " + algorithm.toString() + " algorithm... ");
        Long startTimeMilliseconds = System.currentTimeMillis();
        Integer term = algorithm.getInstance().generateTerm(termNumber);
        Long endTimeMilliseconds = System.currentTimeMillis();
        Long computationTimeMilliseconds = endTimeMilliseconds - startTimeMilliseconds;
        System.out.println("term computed in " + computationTimeMilliseconds + " milliseconds");
    }
}

package com.example.strategy；
公共类斐波那契{
私有枚举算法{
递归（RecursiveFibonacciGenerator.class），
迭代（IterativeFibonacciGenerator.class），
MEMOIZED（MemoizedFibonacciGenerator.class）；
私有最终类algorithmClass；//声明与构造函数类型相同的类
private final T instance；//声明构造函数中定义的类的实例
私有算法（类algorithmClass）{
this.algorithmClass=算法类；
}
公共T getInstance（）{
if（this.instance==null）{
this.instance=this.algorithmClass.newInstance（）；
}
返回此.instance；
}
}
公共整数getTerm（整数termNumber）{
profileGenerator（术语编号、算法、递归）；
轮廓生成器（术语编号、算法、迭代）；
返回配置文件生成器（术语编号、算法、记忆）；
}
专用整数配置文件生成器（整数termNumber、算法）{
System.out.print（“使用“+algorithm.toString（）+”algorithm…”计算术语）；
Long starttimemillesons=System.currentTimeMillis（）；
整数项=算法.getInstance（）.generateTerm（termNumber）；
Long-EndTimeMillions=System.currentTimeMillis（）；
长计算时间毫秒=结束时间毫秒-开始时间毫秒；
System.out.println（“以“+computationTimeMillimes+”毫秒计算的术语”）；
}
}

我想知道如何使用这个

enum

构造函数来存储

类

类型的成员变量

---

编辑：添加了完整代码以澄清意图

尝试提供真实实例而不是类：

public enum Algorithm {
    RECURSIVE (new RecursiveFibonacciGenerator()),
    ITERATIVE (new IterativeFibonacciGenerator()),
    MEMOIZED (new MemoizedFibonacciGenerator());

    private <T extends FibonacciGenerator> Algorithm(T algorithm) {}
}

公共枚举算法{
递归（新的递归fibonaccigenerator（）），
迭代（新的迭代fibonaccigenerator（）），
MEMOIZED（新的MemoizedFibonacciGenerator（））；
私有算法（T算法）{}
}

公共枚举算法{
递归（FibonacciGenerator.RecursiveFibonacciGenerator.class），
迭代（FibonacciGenerator.IterativeFibonacciGenerator.class），
memorized（FibonacciGenerator.memorizedFibonaccigenerator.class）；
private final Class我不确定我是否理解这个问题，但如果您只是想将策略作为成员变量：

public enum Algorithm {
  RECURSIVE (RecursiveFibonacciGenerator.class),
  ITERATIVE (IterativeFibonacciGenerator.class),
  MEMOIZED (MemoizedFibonacciGenerator.class);

  private Class<? extends FibonacciGenerator> strategy;

  private Algorithm(Class<? extends FibonacciGenerator> algorithmClass) {
    this.strategy = algorithmClass;
  }

  Class<? extends FibonacciGenerator> getStrategy() {
    return strategy;
  }
}

公共枚举算法{
递归（RecursiveFibonacciGenerator.class），
迭代（IterativeFibonacciGenerator.class），
MEMOIZED（MemoizedFibonacciGenerator.class）；
private ClassPlouh是正确的。您可以声明和初始化成员变量，就像它是类而不是枚举一样：

private final FibonacciGenerator _instance;

private Algorithm(FibonacciGenerator instance) {
    _instance = instance;
}

然后通过公共getFibonacciGenerator（）方法返回。请注意，如果存储实例而不是类，则无需使用泛型。请记住将字段声明为“final”
我最终得到以下代码：

package com.example.strategy;

public class Fibonacci {
    private enum Algorithm {
        UNDEFINED (null),
        RECURSIVE (RecursiveFibonacciGenerator.class),
        ITERATIVE (IterativeFibonacciGenerator.class),
        MEMOIZED (MemoizedFibonacciGenerator.class);

        private final Class<? extends FibonacciGenerator> algorithmClass;
        private FibonacciGenerator instance;
        private <T extends FibonacciGenerator> Algorithm(Class<T> algorithmClass) {
            this.algorithmClass = algorithmClass;
        }

        public FibonacciGenerator getInstance() {
            if (this.instance == null) {
                try {
                    this.instance = this.algorithmClass.newInstance();
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
            return this.instance;
        }
    }

    public Integer getTerm(Integer termNumber) {
        return profileGenerator(termNumber, Algorithm.MEMOIZED);
    }

    private Integer profileGenerator(Integer termNumber, Algorithm algorithm) {
        System.out.print("Computing term using " + algorithm.toString() + " algorithm... ");
        Long startTimeMilliseconds = System.currentTimeMillis();
        Integer term = algorithm.getInstance().generateTerm(termNumber);
        Long endTimeMilliseconds = System.currentTimeMillis();
        Long computationTimeMilliseconds = endTimeMilliseconds - startTimeMilliseconds;
        System.out.println("term computed in " + computationTimeMilliseconds + " milliseconds");
        return term;
    }
}

package com.example.strategy；
公共类斐波那契{
私有枚举算法{
未定义（空），
递归（RecursiveFibonacciGenerator.class），
迭代（IterativeFibonacciGenerator.class），
MEMOIZED（MemoizedFibonacciGenerator.class）；
private final Classplouh是对的，类的真实实例比反射式创建要好。将字段设为final，您将得到+1:）我认为plouh是对的，实例可能是更好的方法…您是否可以修改代码以引用实例而不是类（请和谢谢）？实际上，进一步考虑，我根本不明白这个枚举的意义，只需使用类的一个实例，它就完成了相同的工作。如果您想对实例使用这种方法，那么plouh的解决方案是正确的（您只需要声明注释中提到的私有成员）很酷，但是我如何声明引用泛型实例的私有成员变量呢？请参见下面@ignis的答案，这应该可以通过相关的get方法实现。您在这里使用enum是为了做一些您确实不应该做的事情。我会扔掉enum，直接在profileGenerator中使用FibonacciGenerator接口。您不需要从枚举中增加复杂性。
package com.example.strategy;

public class Fibonacci {
    private enum Algorithm {
        UNDEFINED (null),
        RECURSIVE (RecursiveFibonacciGenerator.class),
        ITERATIVE (IterativeFibonacciGenerator.class),
        MEMOIZED (MemoizedFibonacciGenerator.class);

        private final Class<? extends FibonacciGenerator> algorithmClass;
        private FibonacciGenerator instance;
        private <T extends FibonacciGenerator> Algorithm(Class<T> algorithmClass) {
            this.algorithmClass = algorithmClass;
        }

        public FibonacciGenerator getInstance() {
            if (this.instance == null) {
                try {
                    this.instance = this.algorithmClass.newInstance();
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
            return this.instance;
        }
    }

    public Integer getTerm(Integer termNumber) {
        return profileGenerator(termNumber, Algorithm.MEMOIZED);
    }

    private Integer profileGenerator(Integer termNumber, Algorithm algorithm) {
        System.out.print("Computing term using " + algorithm.toString() + " algorithm... ");
        Long startTimeMilliseconds = System.currentTimeMillis();
        Integer term = algorithm.getInstance().generateTerm(termNumber);
        Long endTimeMilliseconds = System.currentTimeMillis();
        Long computationTimeMilliseconds = endTimeMilliseconds - startTimeMilliseconds;
        System.out.println("term computed in " + computationTimeMilliseconds + " milliseconds");
        return term;
    }
}