how to write a generic method for adding numbers

Question

I want to define a method to make sums between different type numbers:

<T> void add (T one, T two)
{
    T res = one + two; 
}

the above method not work because type erasure convert T into Object and thus the + operator is not defined on Object...

How can do that?

Thanks.

score 20 · Accepted Answer · edited Aug 16 '13 at 02:53

20

You'll have to use a bounded type parameter:

public <T extends Number> double add (T one, T two)
{
    return one.doubleValue() + two.doubleValue(); 
}

Note that it uses double as return type because that's the primitive numeric type that covers the largest range of values - and one or both parameters could be double too. Note that Number also has BigDecimal and BigInteger as subclasses, which can represent values outside the range of double. If you want to handle those cases correctly, it would make the method a lot more complex (you'd have to start handling different types differenty).

edited Aug 16 '13 at 02:53

Paul Bellora

54,340
18
130
181

answered Aug 12 '11 at 09:19

Michael Borgwardt

342,105
78
482
720

Hmm... What about `BigDecimal` and `BigInteger` ? – Lukas Eder Aug 12 '11 at 09:25
2

@Lukas: good point; but to correctly handle them would complicate the method enormously. – Michael Borgwardt Aug 12 '11 at 09:35
3

actually, that is equivalent to `public double add (Number one, Number two)`. the generics has no effect here – newacct Aug 12 '11 at 22:01
@newacct: you're right; I started out having it return T, but then there way no way to produce a T as result. – Michael Borgwardt Aug 12 '11 at 22:44
2

`Long` covers the largest **range** of values, while `Double` covers the largest **domain**. The range `Double` covers is non-monotonic (aka discontinuous), meaning that you use exponents to reach larger values than `Long` will allow, but not all of the intermediate values between any two arbitrary `Double` values. For example, with a `Double` you can reach +/- infinity, but almost none of the values between 2^65 and 2^66 (as a random choice). You should think carefully before using this snippet. – EntangledLoops Oct 24 '16 at 20:48

Lukas Eder · Answer 2 · 2011-08-12T09:23:12.757

13

The "simplest" solution I can think of is this (excuse the casting and auto-boxing/unboxing):

@SuppressWarnings("unchecked")
<T> T add(T one, T two) {
    if (one.getClass() == Integer.class) {
        // With auto-boxing / unboxing
        return (T) (Integer) ((Integer) one + (Integer) two);
    }
    if (one.getClass() == Long.class) {
        // Without auto-boxing / unboxing
        return (T) Long.valueOf(((Long) one).longValue() + 
                                ((Long) two).longValue());
    }

    // ...
}

Add as many types you want to support. Optionally, you could handle null as well...

edited Aug 12 '11 at 09:23

answered Aug 12 '11 at 09:16

Lukas Eder

211,314
129
689
1,509

You probably mean return (T) Integer.valueOf(((Integer) one).intValue() + ((Integer) two).intValue()) – JB Nizet Aug 12 '11 at 09:19
Yes, that would be the same, without auto-boxing / unboxing. Thanks for the input. That's more complete now – Lukas Eder Aug 12 '11 at 09:22
Why the casting? Why not use a bounded wild as suggested by Michael Borgwardt? – Hovercraft Full Of Eels Aug 12 '11 at 10:22
Yes, but I don't want to manually create if/else statements because overloading is a sort of polymorphism so the compiler should automatically understand what to do. – xdevel2000 Aug 12 '11 at 10:23
@Hovercraft: true. However, this approach could also add Strings, or Date, etc – Lukas Eder Aug 12 '11 at 10:29
2

If that's what the original poster wants, then his desires are *bad programming practice* (tm) as it's asking the method to do too much. Java is not a duck typed language. – Hovercraft Full Of Eels Aug 12 '11 at 10:32
@xdevel2000: I think this is as good as it gets with Java generics. They're not as powerful as in C++. See Michael's answer involving doubles for less code... – Lukas Eder Aug 12 '11 at 10:33
@Hovercraft: why? Any expression language implenentation contains such code, to name an example – Lukas Eder Aug 12 '11 at 10:36
+1 for "duck typed", though :D – Lukas Eder Aug 12 '11 at 10:37

score 0 · Answer 3 · edited May 23 '17 at 12:17

0

Look at this discussion on SO: How to add two java.lang.Numbers?

It's about the same as your problem. Either way, you should not use generics for this, why? Simple: because with generics you couldn't add a Float and a Double, which in general you should be able to do!

edited May 23 '17 at 12:17

Community

1
1

answered Aug 12 '11 at 09:17

Dorpsidioot

474
2
7

With generics, you can know the resulting type, though... – Lukas Eder Aug 12 '11 at 09:19
Yeah you can, but I feel it requires too much boilerplate code to make it work efficiently. – Dorpsidioot Aug 12 '11 at 09:22
That depends on how you use it. With `java.lang.Number`, the boiler-plate code would be outside of the method. With generics, it's inside of the method... – Lukas Eder Aug 12 '11 at 09:27
1

Yeps, you're right about that. And anyways, it's write once and should work all the time, except when new types of numbers arrive =) – Dorpsidioot Aug 12 '11 at 09:57
I guess we'd all be in trouble when there are new types of numbers :) – Lukas Eder Aug 12 '11 at 10:22

score -3 · Answer 4 · answered Aug 12 '11 at 09:16

-3

template <class A>
A add (A a, A b)
{
    return (a+b);

}
int main()
{
    int x =10, y =20;
    cout <<"The Integer Addition is " << add(x,y);
    return 0;
}

answered Aug 12 '11 at 09:16

Shadow

6,161
3
20
14

2

This is about Java, not C++... ;-) – Lukas Eder Aug 12 '11 at 09:17
1

According to the tag, the poster is looking for a solution in Java, not in C++. – ddso Aug 12 '11 at 09:17
Seriously sorry for the blooper – Shadow Aug 12 '11 at 09:19
3

Well it shows how C++ has more powerful generics than Java. I wish there was no type erasure in Java :-/ – Lukas Eder Aug 12 '11 at 09:24

how to write a generic method for adding numbers

4 Answers4

Linked