CODEWITHSUNDEEP
javaoopgenerics
Zar
Zar

Reputation: 6882

Why/when should generic methods be used?

Studying Java, I've come across generic methods.

public <T> void foo(T variable) { }

That is, a method which takes a parameter with an undecided type (á la PHP?). I'm however unable to see how this would be a good solution - especially since I've come to fall in love with a strongly typed languages after coming from a loose ones.

Is there any reason to use generic methods? If so, when?

Upvotes: 5

Views: 1430

Answers (4)

Manvendra Priyadarshi
Manvendra Priyadarshi

Reputation: 255

The main objective of Generic concepts are :

  • To provide type safety to the Collections so that they can hold only one particular type of object.
  • To resolve typecasting problems.

To hold only String type of object a Generic version of ArrayList can be declare as follows :

ArrayList l = new ArrayList ();

To know more : http://algovalley.com/java/generics.php

Upvotes: 0

hvgotcodes
hvgotcodes

Reputation: 120258

Generics, among other things, give you a way to provide a template -- i.e. you want to do the same thing, and the only difference is the type.

For example, look at the List API, you will see the methods

add(E e)

For every list of the same type you declare, the only thing different about the add method is the type of the thing going into the list. This is a prime example of where generics are useful. (Before generics were introduced to Java, you would declare a list, and you could add anything to the list, but you would have to cast the object when you retrieved it)

More specifically, you might want 2 ArrayList instances, one that takes type1 and one that takes type2. The list code for add is going to do the same thing, execute the same code, for each list (since the two lists are both ArrayList instances), right? So the only thing different is what's in the lists.

(As @michael points out, add isn't a true example of a generic method, but there are true generic methods in the API linked, and the concept is the same)

Upvotes: 3

Mehdi
Mehdi

Reputation: 4406

Those who are coming from prior to Java 5 background knows that how inconvenient it was to store object in Collection and then cast it back to correct Type before using it. Generics prevents from those. it provides compile time type-safety and ensures that you only insert correct Type in collection and avoids ClassCastException in runtime.

So it provides compile time type-safety and casting. When you want to write complex APIs with complex method signatures it will save you a lot both when writing the API and when using the API and prevents writing lots of code for casting part and catch your errors at compile time. just take a look at java.util.Collection package and see the source code.

As a developer I always want compiler to catch my error at compile time and inform me when I want to compile it then i will fix my errors and at runtime there won't be many errors related to type-safety.

for more info see :

Upvotes: 4

David M
David M

Reputation: 72890

There's nothing non-strongly typed about generic functions in general. The type is resolved and checked at compile time. It's not an undecided type, it's one of a range of possible types (these can be constrained, in your example they are not). At compile time it is known and decided.

As hvgotcodes says, the Collections API contains a number of good examples of this in use.

Upvotes: 1

Related Questions