Geek Answers Handbook

Why are generics in Java? How is it different from overload?

I want to encode one method add()in Java that can add as integers, strings, etc. Is Generics.

I could not understand the ultimate goal of Generics. I'm so confused.

Generics versus overload?

public Integer add(Integer i, Integer j){return i+j;}
public String add(String i, String j){return i+j;}
public <T> T add(T i, T j){return i+j;} //this gives me error.

Please spare me that.

Thank.

+5
source share
8 answers

Justification can help, the problem is that the operation is +defined only for java primitives and String, but not for types in general. And in Java we cannot overload operators (for example, we can do in C ++, for example).

A practical solution without generics would be:

public Integer add(Integer a, Integer b) { return a + b; }    // sum of a and b
public String add(String a, String b) { return a + b; }      // concatenate operation!
public MyType add(MyType a, MyType b) { return a.add(b); }   // requires add operation
+5
source

, . , , , Java. , ++ C macro, , .

. , , , , , . , , , .

, . , , "int", "float" , ++, . , , , , int, - float. - . "" - , .

+5

add() Java, , .. Generics .

.

List<String> lst;

String, String [, ]

+4
public Integer add(Integer i, Integer j){return i+j;}
public String add(String i, String j){return i+j;}
public <T> T add(T i, T j){return i+j;} //this gives me error.

, . :

public <T> T add(T i, T j){return i+j;}
...
add(new Object(), new Object());

Object ? , + Object , T.

<T> T add(T i, T j) , T, , Object. / +, , Object.

, String Integer, , . XXXXX, +, :

public <T extends XXXXX> T add(T i, T j) { return i+j; }

XXXXX, , (+), .

+3

, , , , . .

, , . , , . , , , , , , .

+2

. , . ,

add(Object obj)

, , ... . , . , add, , 2 :

add(String s);
add(int i);

boolean to add(): .

<T> void add(T arg);

: this.<String>add("hello"); this.<Integer>add(123);

this.<String>add(123); .

+1

:

interface Adder<T> {
    T add(T first, T second);
}

:

public class AdderManager{

    public <T> AdderManager putAdder(final Class<T> clazz,
        final Adder<? extends T> adder){
        adders.put(clazz, adder);
        return this;
    }

    @SuppressWarnings("unchecked")
    public <T> Adder<T> getAdder(final Class<T> clazz){
        return (Adder<T>) adders.get(clazz);
    }

    private final Map<Class<?>, Adder<?>> adders =
        new HashMap<Class<?>, Adder<?>>();

}

:

final AdderManager manager = new AdderManager();
manager
.putAdder(String.class, new Adder<String>(){

    @Override
    public String add(final String first, final String second){
        return first.concat(second);
    }
})
.putAdder(Integer.class, new Adder<Integer>(){

    @Override
    public Integer add(final Integer first, final Integer second){
        return first + second;
    }
})
.putAdder(List.class, new Adder<List<?>>(){

    @Override
    public List<?> add(final List<?> first, final List<?> second){
        final List<Object> newList = new ArrayList<Object>();

        return newList;
        }
});

, :

String addedString = manager.getAdder(String.class).add("abc", "def");

@SuppressWarnings("unchecked") // this is necessary because of
                               // the generic <Integer> type
List<Integer> addedList = manager
                            .getAdder(List.class)
                            .add(
                                Arrays.asList(1,2,3),
                                Arrays.asList(4,5,6)
                             );
+1

A generalization in java only adds casting to bytecode.

The code will be the same except casting.

So, two constructions:

List list1 = new ArrayList();
List<String list2 = new ArrayList<String>();
....
String string1 = (String) list1.get(0);
String string2 = list2.get(0);

Do the same thing.

+1
source

More articles:


All Articles