如何将方法限制为仅接受具有特定限制的参数？

Question

I have the following Duple class, and I'm trying to write methods to perform math over both of its "cells" ((new Duple(1,2)).plus(new Duple(2,6) == new Duple(3,8)) :

final class Duple<T,U> {
    final T a;
    final U b;
            public Duple(T a, U b) { this.a = a; this.b = b; }

    public String toString() {
        return "(" + a + ", " + b + ")";
    }

    /*public Duple<T,U> plus(Duple <T,U> otherDuple) {
        return Duple(a + otherDuple.a, b + otherDuple.b);
    }*/

The commented-out code gives an error because it can't guarantee that T or U will support + . Is there a way to have it do a compile time check on the parameters?

I tried:

public Duple<T,U> plus(Duple <T extends Number,U extends Number> otherDuple) { ... }

But the compiler complains for me to delete extends . I saw an example using a user defined interfaces, but for what I need it for, that seems extreme.

Basically I'm trying to emulate:

plus :: (Num t, Num u) => Duple t u -> Duple t u -> Duple t u
(x1,y1) `plus` (x2,y2) = (x1 + x2,y1 + y2)

If it were written in Haskell

Answer 1

You cannot have a method that only exists on some instantiations of your class.

Instead, you can put the constraints on the class's type parameters.

Answer 2

There really isn't a good way to do this in Java; the language doesn't support any kind of "add" or "plus" function that will work on any arbitrary subclass of Number .

However, I've found a rather hack-ish way to work around it. It requires that you set up a map that maps each numeric class you're interested in to a function that will add two numbers of that class, and then looking up the function at runtime. This uses Java 8:

final class Duple<T,U> {
    final T a;
    final U b;
    public Duple(T a, U b) { this.a = a; this.b = b; }

    public String toString() {
        return "(" + a + ", " + b + ")";
    }

    private static Map<Class,BinaryOperator> adders = new HashMap<>();

    private static <T> void setAdder(Class<T> forClass, BinaryOperator<T> adder) {
        adders.put(forClass, adder);
    }

    private static void setAdders() {
        setAdder(Integer.class, (x, y) -> x + y);
        setAdder(Long.class, (x, y) -> x + y);
        setAdder(Float.class, (x, y) -> x + y);
        setAdder(Double.class, (x, y) -> x + y);
        setAdder(BigInteger.class, (x, y) -> x.add(y));
        // add more as desired
    }

    static {
        setAdders();
    }

    private static <T1> T1 add(T1 x, T1 y) {
        BinaryOperator adder = adders.get(x.getClass());
        if (adder == null) {
            throw new RuntimeException("No plus operation defined for class");
        }
        return (T1)adder.apply(x, y);
    }

    public Duple<T,U> plus(Duple <T,U> otherDuple) {
        return new Duple(add(this.a, otherDuple.a), add(this.b, otherDuple.b));
    }

}

My test program:

public static void main(String[] args) {
    Duple<Long,Double> x1, x2, x3;
    Duple<Float,BigInteger> x4, x5, x6;
    x1 = new Duple<>(3L, 4.0);
    x2 = new Duple<>(6L, 2.2);
    x3 = x1.plus(x2);
    System.out.println(x3);

    x4 = new Duple<>(1.7F, BigInteger.valueOf(15));
    x5 = new Duple<>(3.1F, BigInteger.valueOf(22));
    x6 = x4.plus(x5);
    System.out.println(x6);
}

and the output is what you'd expect:

(9, 6.2)
(4.8, 37)

(This uses some raw types, but I don't know of a way around that.)