En algunas interfaces que escribí, me gustaría nombrar parámetros de tipo genérico con más de un carácter para que el código sea más legible.

Algo como....

Map<Key,Value>

En lugar de esto...

Map<K,V>

Pero cuando se trata de métodos, los parámetros de tipo se parecen a las clases java, lo que también es confuso.

public void put(Key key, Value value)

Esto parece que Key y Value son clases. Encontré o pensé en algunas anotaciones, pero nada como una convención de Sun o una mejor práctica general.

Alternativas que adiviné o encontré ...

Map<KEY,VALUE>
Map<TKey,TValue>

Oracle recomienda lo siguiente en Tutoriales de Java> Genéricos> Tipos genéricos :

Convenciones de nomenclatura de parámetros de tipo

Por convención, los nombres de parámetros de tipo son letras mayúsculas individuales. Esto contrasta fuertemente con el nombre variable convenciones de que ya conoce, y con una buena razón: sin esta convención, sería difícil distinguir entre una variable de tipo y una clase ordinaria o nombre de interfaz.

Los nombres de parámetros de tipo más utilizados son:

• E - Elemento (utilizado ampliamente por el marco de colecciones de Java)
• K - Clave
• N - Número
• T - Tipo
• V - Valor
• S, U, V etc. - 2do, 3ro, 4to tipos

Verá estos nombres utilizados en la API Java SE y el resto de esta lección.

Me apegaría a ello para evitar la confusión entre los desarrolladores y posibles mantenedores.

Adjuntar Type

Se puede encontrar una buena discusión en los comentarios en la página DZone, Convenciones de nomenclatura para tipos parametrizados .

Ver el comentario de Erwin Mueller. Su sugerencia tiene mucho sentido para mí: anexar la palabraType .

Llame a una manzana una manzana, un auto un auto El nombre en cuestión es el nombre de un tipo de datos, ¿verdad? (En OOP , una clase esencialmente define un nuevo tipo de datos). Así que llámelo "Tipo".

El ejemplo de Mueller, extraído del artículo de la publicación original:

public interface ResourceAccessor < ResourceType , ArgumentType , ResultType > {
    public ResultType run ( ResourceType resource , ArgumentType argument );
}

Adjuntar T

Una pregunta duplicada proporciona esta respuesta por Andy Thomas. Tenga en cuenta el extracto de la guía de estilo de Google que sugiere que un nombre de tipo de varios caracteres debe terminar en mayúscula T.

La razón por la cual la convención oficial de nombres recomienda el uso de una sola letra es la siguiente:

Sin esta convención, sería difícil distinguir entre una variable de tipo y una clase ordinaria o nombre de interfaz.

Creo que con los IDE modernos esa razón ya no es válida, por ejemplo. IntelliJ Idea muestra parámetros de tipo genérico con diferentes colores que las clases regulares.

Código con tipo genérico como se muestra en IntelliJ Idea 2016.1

Debido a esa distinción , uso nombres descriptivos más largos para mis tipos genéricos, con la misma convención que los tipos normales. Evito agregar prefijos y sufijos como T o Type porque los considero ruidos innecesarios y ya no necesito distinguir visualmente los tipos genéricos.

Nota: Como no soy usuario de Eclipse o Netbeans, no sé si ofrecen una función similar.

Sí, puede usar nombres de varios caracteres para las variables de tipo, siempre que se distingan claramente de los nombres de clase.

Esto difiere de la convención sugerida por Sun con la introducción de genéricos en 2004. Sin embargo:

• Existe más de una convención.
• Los nombres de varios caracteres son consistentes con otros estilos de Java, como el estilo de Google para Java .
• Los nombres legibles son (¡sorpresa!) Más legibles.

Legibilidad

En algunas interfaces que escribí, me gustaría nombrar un parámetro de tipo genérico con más de un carácter para que el código sea más legible.

La legibilidad es buena.

Comparar:

    public final class EventProducer<L extends IEventListener<E>,E> 
            implements IEventProducer<L,E> {

a:

    public final class EventProducer<LISTENER extends IEventListener<EVENT>,EVENT> 
           implements IEventProducer<LISTENER, EVENT> {

o, con la convención de caracteres múltiples de Google:

    public final class EventProducer<ListenerT extends IEventListener<EventT>,EventT> 
           implements IEventProducer<ListenerT, EventT> {

    public final class EventProducer<ListenerT extends IEventListener<EventT>,EventT> 
           implements IEventProducer<ListenerT, EventT> {

Estilo de Google

La Guía de estilo de Java de Google permite nombres de una sola letra y nombres de clase de varios caracteres que terminan en T.

5.2.8 Escriba nombres de variables

Cada variable de tipo se nombra en uno de dos estilos:

• Una letra mayúscula solo, seguido opcionalmente por un solo número (tales como E, T, X, T2)

• Un nombre en la forma utilizada para las clases (ver Sección 5.2.2, nombres de clase ), seguido de la letra mayúscula (por ejemplo: RequestT, FooBarT).

Cuestiones

"Sin esta convención, sería difícil distinguir entre una variable de tipo y un nombre de clase o interfaz ordinario". - de los tutoriales de Oracle, "Tipos genéricos"

Los nombres de un solo carácter no son la única forma de distinguir los parámetros de tipo de los nombres de clase, como hemos visto anteriormente.

¿Por qué no simplemente documentar el significado del parámetro de tipo en JavaDoc?

Es cierto que los @paramelementos JavaDoc pueden proporcionar una descripción más larga. Pero también es cierto que los JavaDocs no son necesariamente visibles. (Por ejemplo, hay un asistente de contenido en Eclipse que muestra los nombres de los parámetros de tipo).

¡Los nombres de parámetros de tipo de caracteres múltiples no siguen la convención de Oracle!

Muchas de las convenciones originales de Sun se siguen casi universalmente en la programación Java.

Sin embargo, esta convención particular no lo es.

La mejor opción entre las convenciones en competencia es una cuestión de opinión. Las consecuencias de elegir una convención diferente a la de Oracle en este caso son menores. Usted y su equipo pueden elegir la convención que mejor satisfaga sus necesidades.

Puede usar javadoc para dar al menos una pista a los usuarios de su clase genérica. Todavía no me gusta (estoy de acuerdo con @ chaper29) pero los documentos ayudan.

p.ej,

/**
 * 
 * @param <R> - row
 * @param <C> - column
 * @param <E> - cell element
 */
public class GenericTable<R, C, E> {

}

La otra cosa que he sabido hacer es usar mi IDE para refactorizar una clase que rompe la convención. Luego trabaje en el código y refactorice a letras individuales. De todos modos, me resulta más fácil si se utilizan muchos parámetros de tipo.