Java - Clases genéricas

Mi duda es que es una clase genérica en java, he leido pero aun no capto bien que es, ya medio que comprendí que es una clase que contiene (por asi decirlo) características similares de otros objetos; por ejemplo si quisiéramos calcular el área de diferentes figuras geométricas, realizaríamos una clase que se llamaría figGeometrica por que todas las figuras geométricas contienen un lado, pero tendría como hijos a diferentes figuras como por ejemplo polígonos, círculos; puesto que cada figura se dibuja de diferente forma.
¿Estoy bien o no he comprendido? por lo que sea me gustaría que me alguien me aclarara bien que es una clases genérica o un método.
Por su ayuda muchas gracias.

Tal vez te estas confundiendo con cgenerics de java que con templates de c++ ambos usan la notación < Type > la que mencionas se acerca más al concepto de los templates

Te pongo la principal diferencia entre los dos (extraido de la doc de SUN)

Java Generics vs. C++ Templates

While generics look like the C++ templates, it is important to note that they are not the same. Generics simply provide compile-time type safety and eliminate the need for casts. The main difference is encapsulation: errors are flagged where they occur and not later at some use site, and source code is not exposed to clients. Generics use a technique known as type erasure as described above, and the compiler keeps track of the generics internally, and all instances use the same class file at compile/run time.

A C++ template on the other hand is just a fancy macro processor; whenever a template class is instantiated with a new class, the entire code for the class is reproduced and recompiled for the new class.

Saludos comunidad open source

Neos Software Inc. 2007
http://www.geocities.com/neos_software/

Gracias por la respuesta pero aun no me queda claro que es una clase genérica en java,

Una idea aproximada de las clases y métodos genéricos es pensar que reciben, además de los parámetros normales, "parámetros de tipo".

Por poner el típico ejemplo:

Imagina que quieres una lista que guarde sólo objetos de tipo Usuario, para garantizar que no se mezclan con otros objetos. Podrías hacer algo como:

class ListaDeUsuarios {
····public void anadir(Usuario usuario) {
········//... guardar un Usuario
····}
····public Usuario leer(int i) {
········//...devolver el usuario i
····}
}

Imagina ahora que quieres otra lista que sólo pueda guardar objetos de tipo Cuenta. Harías...

class ListaDeCuentas {
····public void anadir(Cuenta cuenta) {
········//... guardar una Cuenta
····}
····public Cuenta leer(int i) {
········//...devolver el usuario i
····}
}

Y ahora otra que pueda guardar sólo... etc, etc. Al cabo del rato resulta que tienes un montón de listas muy parecidas, que en lo único que se diferencian es en el tipo de objetos que manejan. Es decir, un montón de código casi repetido.

Pero tú no quieres una única lista en la que pueda haber cualquier cosa. Tú quieres que en una lista determinada sólo pueda haber objetos de un tipo. Si pudieras pasarle al constructor de la clase ese tipo como parámetro... que le pudieras decir "new ListaDe(Usuario)" y "new ListaDe(Cuenta)"... eso estaría bien, no?

Pues exactamente eso es lo que ofrecen los generics. Puedes hacer algo como:

class ListaDe<Tipo> {
····public void anadir(<Tipo> elemento) {
········//... guardar un elemento
····}
····public <Tipo> leer(int i) {
········//...devolver el usuario i
····}
}

Ahora podrías decir "new ListaDe<Usuario>()" y en esa lista sólo puedes hacer anadir(usuario), o "new ListaDe<Cuenta>()" y en esa sólo puedes añadir objetos de tipo Cuenta.

Esto es sólo el principio y de forma muy breve. Los generics permiten hacer cosas más elaboradas.

OHHH
no pues ahora si me a quedado muchísimo mas claro muchas gracias.