Java Generics - 关于 Greater Than Method with Objects 的快速问题

Question

我在 Java 课上有一个作业，我们正在学习泛型，我查看了我的笔记、我的类(class)，甚至在互联网上，但我仍然无法弄清楚最后一个作业问题要我做什么，哪个是:

编写一个通用的“大于”函数，它接受两个对象作为参数，每个对象都有一个返回整数的“值”方法，并返回其“值”方法返回较大整数的参数。您的泛型函数应该限制其类型参数，以便不能使用没有“值”方法的类型。

引号中的“值”是否有原因以及方法如何限制其类型参数，以便不能使用没有“值”方法的类型。我主要是要求澄清或者可能是一个小例子。我是在创建一个 Value 类然后做这样的事情吗:

public static <T> int greaterThan(Value obj1, Value obj2){ // Value will have the "value" method?
    // do I compare the objects here or in the Value class?
}

Answer 1

他们显然要求您实现一个通用的 maxByValue 方法。由于 greater-than 包含连字符，因此无论如何都是无效的 Java 标识符，我将坚持使用 maxByValue。

value 方法的要求被提到了几次，所以让我们将它编码为一个接口(interface):

interface Value {
    int value();
}

现在，这里使用泛型参数的要点是确保 maxByValue 的返回类型足够具体以供使用。我们称这种类型为 T。为了使参数具有可比性，T 必须是 Value 的子类型。获取返回类型的唯一有意义的来源是参数类型。综合三点:

• 类型参数T子类型值
• 从参数中推断出的类型
• 结果类型为T

给你签名:

    public static <T extends Value> T maxByValue(T a, T b)

基本上只有两种有意义的实现方式。让我们采用偏左的一个(即，如果值相同，则返回左参数):

public static <T extends Value> T maxByValue(T a, T b) {
    if (a.value() < b.value()) {
        return b;
    } else {
        return /* left as an exercise */;
    }
}

让我们在一个简单的整数示例上尝试一下:

    class IntValue implements Value {
        final int v;
        public IntValue(int v) {
            this.v = v;
        }
        public int value() {
            return v;
        }
        @Override
        public String toString() {
            return "" + v;
        }
    }
    
    IntValue a = new IntValue(42);
    IntValue b = new IntValue(58);
    IntValue c = max(a, b);
    System.out.println(c); // prints "58"

到目前为止一切顺利。让我们看看类型推断有多精确:

static interface Vehicle extends Value {
    String doGenericVehicleSound();
}
static abstract class Car implements Vehicle {
    public abstract String doCarSpecificSound();
    public String doGenericVehicleSound() {
        return doCarSpecificSound();
    }
}
static class Train implements Vehicle {
    public String doGenericVehicleSound() {
        return "tk-tk-------tk-tk--tk-tk--------------tk-tk";
    }
    public int value() {
        return 10000000;
    }
}
static class Ferrari extends Car {
    public String doCarSpecificSound() {
        return "rr-rrr-rrrr-rrrrrrr-rrrrrrrrrrrrrrrrrrrr-RRRRRRRRRR";
    }
    public int value() {
        return 222000;
    }
}
static class Tesla extends Car {
    public String doCarSpecificSound() {
        return "...        ...           ¯\\_(ツ)_/¯";
    }
    public int value() {
        return 50000;
    }
}

public static void main(String []args){
    System.out.println(maxByValue(new Ferrari(), new Tesla()).doCarSpecificSound());
    System.out.println(maxByValue(new Tesla(), new Train()).doGenericVehicleSound());
    // System.out.println(maxByValue(new Tesla(), new Train()).doCarSpecificSound());
        
}

这里要看的点如下。我们有以下子类型关系:

Train   extends Vehicle
Car     extends Vehicle
Ferrari extends Car
Tesla   extends Car

以及具体实例的以下最小上限:

LUB(Train, Train) = Train
LUB(Train, Ferrari) = Vehicle
LUB(Train, Tesla) = Vehicle
LUB(Ferrari, Ferrari) = Ferrari
LUB(Ferrari, Tesla) = Car
LUB(Tesla, Tesla) = Tesla

(以及所有对称情况)。

现在，当我们

• 将两辆车放入maxByValue，我们得到一辆车(第一个例子)，但是
• 当我们将汽车和火车放入maxByValue时，我们得到一个更通用的Vehicle，以便特定于汽车的方法变得不可用(示例二和三；第三个不编译 - 正确的是，因为火车没有汽车方法)。