如何允许泛型类方法仅由某些类型的参数执行？

Question

I am trying to add a method to an existing class BinaryTree<T> to simple add the values of all the elements in the tree. The problem is that being the class a generic one, not all the types that can be send at the time of creating a tree can be added. I mean, for example It wouldn't make any sense to try to add the values of a class people .

So my question is, how do I make a method public T addAllElements() that only allows T to be an specific kind of type, in this case, only the types that is possible to add it's value, like Integer , Float , Long , etc? I guess there have to be some kind of numerical interface or maybe some kind of declaration provided by the language to do something like that.

By the way, it seems to be a solution without having to create a child class, in case that it could help in anything, because I was asked to solve a similar problem and the instructions says that the method have to be in the same class.

Trying to be more clear, I'll ask another question , because I think that both of them have the same answer.

I found that the method sort() in java.util.Arrays class can be used by a class if the class implements the interface Comparable<T> . So if I hava a class, lets say

public class People {
    implements Comparable<People>
    private String name;
    public int compareTo(People o) {
        ...
    }
    ...
}

This class can be sorted with the sort() method from the Arrays class, but if the class dind't implement the Comparable<T> interface it couldn't. So what is making this restriction in the Arrays class definition? Is it what I need to solve the first problem I asked?

Answer 1

So my question is, how do I make a method public T addAllElements() that only allows T to be an specific kind of type, in this case, only the types that is possible to add it's value, like int , float , long , etc? I guess there have to be some kind of numerical interface or maybe some kind of declaration provided by the language to do something like that.

You're looking for Number .

So your declaration would look something like this, if the class is generic:

public BinaryTree<T extends Number> {
  // ...
}

or if you want to make just the method generic:

public <T extends Number> T addAllElements() {
  // ...
}

That said, for better or for worse Number does not define arithmetic operations in terms of methods. To my knowledge there is no such built-in type which does.

Do note that the types you listed are all primitives, which mean they're not compatible with generics at all. Subtypes of Number (and types that can be used with generics) will all be wrapper types: Integer , Float , Long , etc.

Answer 2

Your examples are related , but they're not the same.

To address the latter concern first, the reason that Arrays.sort with a specific signature requires that things be Comparable is because it needs to sort them based on that natural ordering. There is another signature that you could provide to the method which allows you to pass a custom Comparator to it, to sort on whatever other property of the class you liked.

To your main concern, you need to have an upper-bound generic, specifically one of type T extends Number . The reason for this is that Number is the parent class to all of the numeric wrapper classes, as well as BigDecimal and BigInteger .

There's two things you'd want to be sure of before you did this:

• Your generic type was bound at the class level. Since we're dealing with a tree, it makes no sense to have non-homogeneous data throughout.
• You did a math operation according to a specific data type ( int , long , or double ).

You would then declare your method(s) as such:

public int addAsInteger() {}
public double addAsDouble() {}
public long addAsLong() {}

You'd make use of Number 's methods : intValue , longValue and doubleValue for your respective methods.

You wouldn't be able to simply return T since you can't guarantee what kind of Number you're getting back, or what T is specifically bound to (it can't be Number since it's an abstract class, so it is a non-inclusive upper bound).