Question

我有一个类，我希望使用String或int值进行实例化，并将相应的实例变量value定义为泛型类型T：

public class MathValue<T extends Object> {
    private boolean isOperand, isOperator;

    // a generic-typed instance variable:
    private T value;

    // constructor:
    public MathValue(int operand) {

        // compile-error -- "Incompatible types: required T, found Integer"
        this.value = new Integer(operand);

        this.isOperand = true;
        this.isOperator = false;
    }

    // constructor:
    public MathValue(String operator) {

        // compile-error -- "Incompatible types: required T, found String"
        this.value = operand;

        this.isOperand = false;
        this.isOperator = true;
    }
}

我可以很好地拥有一个构造函数，使用类型为T的形式参数，但我想用String或{{1}强制执行类实例化参数：

int

因此，尽管想要使通用类型类“不那么通用”的逻辑错误，是否可以实例化具有特定类型值的泛型变量？

Answer 1

您可以创建工厂方法。现在可能看起来像了：

public class MathValue<T extends Object> {

    public static MathValue<String> from(String s) {
        MathValue<String> mv = new MathValue<String>();

        mv.setValue(s);
        mv.setIsOperand(true);
        return mv;
    }

     public static MathValue<Integer> from(Integer s) {
        MathValue<Integer> mv = new MathValue<Integer>();

        mv.setValue(i);
        mv.setIsOperand(false);
        return mv;
    }

    // Rest of your class below
}

如果你绝对需要一个构造函数（例如，你不知道你提前创建的类型），那么我无法看到@RohitJain的建议。

Answer 2

您可以使用子类。定义一个抽象类来实际存储值，通常是：

abstract class MathValue<T> {
        private final T value;

        MathValue(T value) {
                this.value = value;
        }

        abstract boolean isOperator();

        boolean isOperand() {
                return !isOperator();
        }
}

然后一个子类强制将值类型作为整数。

class OperandValue extends MathValue<Integer> {

        OperandValue(int operand) {
                super(new Integer(operand));
        }

        @Override
        public boolean isOperator() {
                return false;
        }
}

和另一个强制它成为String的子类型。

class OperatorValue extends MathValue<String> {

        OperatorValue(String operator) {
                super(operator);
        }

        @Override
        boolean isOperator() {
                return true;
        }
}

通过这种设计，您实际上不需要存储布尔值。

（注意，为简单起见，我省略了可见性关键字。）

是否可以使用特定类型的值初始化通用变量？

2 个答案: