Sintaxis de Java

This article includes a list of general references, but it lacks sufficient corresponding inline citations. Please help to improve this article by introducing more precise citations. (January 2014) (Learn how and when to remove this message)

La sintaxis de Java es el conjunto de reglas que definen cómo se escribe e interpreta un programa Java .

La sintaxis se deriva principalmente de C y C++ . A diferencia de C++, Java no tiene funciones o variables globales, pero tiene miembros de datos que también se consideran variables globales . Todo el código pertenece a clases y todos los valores son objetos . La única excepción son los tipos de datos primitivos , que no se consideran objetos por razones de rendimiento (aunque se pueden convertir automáticamente en objetos y viceversa mediante autoboxing). Algunas características como la sobrecarga de operadores o los tipos de datos enteros sin signo se omiten para simplificar el lenguaje y evitar posibles errores de programación.

La sintaxis de Java se ha ampliado gradualmente a lo largo de numerosas versiones importantes del JDK y ahora admite funciones como programación genérica y funciones anónimas (literales de función, denominadas expresiones lambda en Java). Desde 2017, se publica una nueva versión del JDK dos veces al año y cada versión mejora el lenguaje de forma incremental.

Un identificador es el nombre de un elemento en el código . Existen ciertas convenciones de nomenclatura estándar que se deben seguir al seleccionar nombres para los elementos. Los identificadores en Java distinguen entre mayúsculas y minúsculas .

Un identificador puede contener:

• Cualquier carácter Unicode que sea una letra (incluidas letras numéricas como los números romanos ) o un dígito.
• Signo de moneda (como ¥).
• Caracteres de puntuación de conexión (como _ ).

Un identificador no puede:

• Comience con un dígito.
• Ser igual a una palabra clave reservada, un literal nulo o un literal booleano .

Los literales enteros son de inttipo por defecto a menos que longse especifique el tipo añadiendo un sufijo Lo lun número al literal, p. ej 367L. Desde Java SE 7, es posible incluir guiones bajos entre los dígitos de un número para aumentar la legibilidad; por ejemplo, un número 145608987 se puede escribir como 145_608_987 .

Las variables son identificadores asociados a valores. Se declaran escribiendo el tipo y el nombre de la variable y, opcionalmente, se inicializan en la misma declaración asignándoles un valor.

int count ; //Declarar una variable no inicializada llamada 'count', de tipo 'int' count = 35 ; //Inicializar la variable int count = 35 ; //Declarar e inicializar la variable al mismo tiempo         

Se pueden declarar e inicializar varias variables del mismo tipo en una sola declaración utilizando una coma como delimitador.

int a , b ; //Declarar múltiples variables del mismo tipo int a = 2 , b = 3 ; //Declarar e inicializar múltiples variables del mismo tipo          

Desde Java 10, es posible inferir tipos de variables automáticamente mediante el uso de var.

// el flujo tendrá el tipo FileOutputStream como se infiere de su inicializador var stream = new FileOutputStream ( "file.txt" );    // Una declaración equivalente con un tipo explícito FileOutputStream stream = new FileOutputStream ( "file.txt" );    

Los separadores { y } indican un bloque de código y un nuevo alcance. Los miembros de clase y el cuerpo de un método son ejemplos de lo que puede estar dentro de estas llaves en varios contextos.

Dentro de los cuerpos de los métodos, se pueden usar llaves para crear nuevos ámbitos, de la siguiente manera:

vacío hacerAlgo () { int a ;     { entero b ; a = 1 ; }       a = 2 ; b = 3 ; // Ilegal porque la variable b está declarada en un ámbito interno.. }      

Java tiene tres tipos de comentarios : comentarios tradicionales , comentarios de final de línea y comentarios de documentación .

Los comentarios tradicionales, también conocidos como comentarios en bloque, comienzan con /*y terminan con */y pueden extenderse a lo largo de varias líneas. Este tipo de comentario se derivó de C y C++.

/* Este es un comentario de varias líneas. Puede ocupar más de una línea. */

Los comentarios de final de línea comienzan con //el final de la línea actual y se extienden hasta el final. Este tipo de comentario también está presente en C++ y en C moderno.

// Este es un comentario de final de línea.

La herramienta Javadoc procesa los comentarios de documentación en los archivos fuente para generar la documentación. Este tipo de comentario es idéntico a los comentarios tradicionales, excepto que comienza con /**las convenciones definidas por la herramienta Javadoc y las sigue. Técnicamente, estos comentarios son un tipo especial de comentario tradicional y no están definidos específicamente en la especificación del lenguaje.

/** * Este es un comentario de documentación. * * @author John Doe */

Las clases del paquete java.lang se importan de forma implícita en todos los programas, siempre que ningún tipo importado explícitamente tenga el mismo nombre. Entre las más importantes se incluyen:

java.lang.Objectes el tipo superior de Java . Superclase de todas las clases que no declaran una clase padre. Todos los valores se pueden convertir a este tipo, aunque para los valores primitivos esto implica el autoboxing .

java.lang.Stringes el tipo de cadena básico de Java. Inmutable . Algunos métodos tratan cada unidad de código UTF-16 como un "carácter", pero también hay métodos disponibles para convertir a un int[]que sea efectivamente UTF-32 .

java.lang.Throwablees un supertipo de todo lo que se puede lanzar o capturar con las declaraciones throwy de Java catch.

Las aplicaciones Java constan de colecciones de clases. Las clases existen en paquetes, pero también pueden estar anidadas dentro de otras clases.

Toda aplicación Java debe tener un punto de entrada. Esto es así tanto para las aplicaciones de interfaz gráfica como para las de consola. El punto de entrada es el mainmétodo. Puede haber más de una clase con un mainmétodo, pero la clase principal siempre se define externamente (por ejemplo, en un archivo de manifiesto ). El mainmétodo junto con la clase principal deben declararse public. El método debe ser staticy se le pasan argumentos de línea de comandos como una matriz de cadenas. A diferencia de C++ o C# , nunca devuelve un valor y debe devolver void.

public static void principal ( cadena [] argumentos ) { }     

Los paquetes son parte de un nombre de clase y se utilizan para agrupar o distinguir entidades nombradas de otras. Otro propósito de los paquetes es controlar el acceso al código junto con los modificadores de acceso. Por ejemplo, java.io.InputStreames un nombre de clase completamente calificado para la clase InputStreamque se encuentra en el paquete java.io.

Un paquete se declara al inicio del archivo con la packagedeclaración:

paquete miaplicacion.mibiblioteca ; clase pública MiClase { }   

Las clases con el publicmodificador deben ubicarse en los archivos con el mismo nombre y extensión java y colocarse en carpetas anidadas correspondientes al nombre del paquete. La clase anterior tendrá la siguiente ruta: .myapplication.mylibrary.MyClassmyapplication/mylibrary/MyClass.java

Una declaración de importación de tipo permite hacer referencia a un tipo con nombre mediante un nombre simple en lugar del nombre completo que incluye el paquete. Las declaraciones de importación pueden ser declaraciones de importación de un solo tipo o declaraciones de importación a pedido . Las declaraciones de importación deben colocarse en la parte superior de un archivo de código después de la declaración del paquete.

paquete miPaquete ; import java.util.Random ; // Declaración de tipo único  public class ImportsTest { public static void main ( String [] args ) { /* La siguiente línea es equivalente a  * java.util.Random random = new java.util.Random();  * Hubiera sido incorrecto sin la importación.  */ Random random = new Random (); } }                

Las declaraciones de importación a pedido se mencionan en el código. Una "importación de tipo" importa todos los tipos del paquete. Una "importación estática" importa los miembros del paquete.

import java.util.* ; /*Esta forma de importar clases hace que todas las clases  del paquete java.util estén disponibles por nombre, y se puede usar en lugar de la  declaración de importación del ejemplo anterior. */ import java.* ; /*Esta declaración es legal, pero no hace nada, ya que  no hay clases directamente en el paquete java. Todas ellas están en paquetes  dentro del paquete java. Esto no importa todas las clases disponibles.*/    

Este tipo de declaración está disponible desde J2SE 5.0 . Las declaraciones de importación estática permiten el acceso a miembros estáticos definidos en otra clase, interfaz, anotación o enumeración sin especificar el nombre de la clase:

import static java.lang.System.out ; //'out' es un campo estático en java.lang.System  public class HelloWorld { public static void main ( String [] args ) { /* La siguiente línea es equivalente a  System.out.println("¡Hola mundo!");  y habría sido incorrecta sin la declaración de importación. */ out . println ( "¡Hola mundo!" ); } }            

Las declaraciones de importación bajo demanda permiten importar todos los campos del tipo:

import static java.lang.System.* ; /* Esta forma de declaración hace que todos  los campos de la clase java.lang.System estén disponibles por nombre y puede utilizarse en lugar  de la declaración de importación del ejemplo anterior. */  

Las constantes de enumeración también se pueden usar con la importación estática. Por ejemplo, esta enumeración se encuentra en el paquete llamado screen:

enumeración pública ColorName { ROJO , AZUL , VERDE };      

Es posible utilizar declaraciones de importación estáticas en otra clase para recuperar las constantes de enumeración:

importar pantalla.ColorName ; importar pantalla estática.ColorName .* ;  public class Dots { /* La siguiente línea es equivalente a 'ColorName foo = ColorName.RED',  y habría sido incorrecta sin la importación estática. */ ColorName foo = RED ;         void shift () { /* La siguiente línea es equivalente a  if (foo == ColorName.RED) foo = ColorName.BLUE; */ if ( foo == RED ) foo = BLUE ; } }           

Los operadores en Java son similares a los de C++ . Sin embargo, no hay deleteoperadores debido a los mecanismos de recolección de basura en Java, y no hay operaciones sobre punteros ya que Java no los admite. Otra diferencia es que Java tiene un operador de desplazamiento a la derecha sin signo ( >>>), mientras que el operador de desplazamiento a la derecha de C depende del tipo. Los operadores en Java no se pueden sobrecargar .

Las declaraciones if en Java son similares a las de C y utilizan la misma sintaxis:

si ( i == 3 ) { hacerAlgo (); }     

ifLa declaración puede incluir elseun bloque opcional, en cuyo caso se convierte en una declaración if-then-else:

si ( i == 3 ) { hacerAlgo (); } de lo contrario { hacerAlgoMás (); }        

Al igual que en C, la construcción else-if no involucra ninguna palabra clave especial, se forma como una secuencia de instrucciones if-then-else separadas:

si ( i == 3 ) { hacerAlgo (); } de lo contrario si ( i == 2 ) { hacerAlgoMás (); } de lo contrario { hacerAlgoDiferente (); }               

Además, se puede utilizar un operador ?: en lugar de una simple declaración if, por ejemplo

int a = 1 ; int b = 2 ; int minVal = ( a < b ) ? a : b ;               

Las sentencias Switch en Java pueden utilizar los tipos de datos primitivos byte, short, chary int(no long) o sus tipos de contenedor correspondientes. A partir de J2SE 5.0, es posible utilizar tipos de enumeración . A partir de Java SE 7, es posible utilizar cadenas. ^[2] No se pueden utilizar otros tipos de referenciaswitch en sentencias.

Los valores posibles se enumeran mediante caseetiquetas. Estas etiquetas en Java pueden contener solo constantes (incluidas constantes de enumeración y constantes de cadena). La ejecución comenzará después de la etiqueta correspondiente a la expresión dentro de los corchetes. defaultPuede haber una etiqueta opcional para declarar que el código que la sigue se ejecutará si ninguna de las etiquetas de caso corresponde a la expresión.

El código de cada etiqueta termina con la breakpalabra clave. Es posible omitirla y hacer que la ejecución continúe con la siguiente etiqueta; sin embargo, normalmente se informará una advertencia durante la compilación.

switch ( ch ) { case 'A' : doSomething (); // Se activa si ch == 'A' break ; case 'B' : case 'C' : doSomethingElse (); // Se activa si ch == 'B' o ch == 'C' break ; default : doSomethingDifferent (); // Se activa en cualquier otro caso break ; }                  

Desde Java 14 es posible utilizar expresiones switch, que utilizan la nueva sintaxis de flecha:

var resultado = switch ( ch ) { caso 'A' -> Resultado . EXCELENTE ; caso 'B' , 'C' -> Resultado . BIEN ; predeterminado -> lanzar nueva ThisIsNoGoodException (); };                   

Alternativamente, existe la posibilidad de expresar lo mismo con la yielddeclaración, aunque se recomienda preferir la sintaxis de flecha porque evita el problema de caídas accidentales.

var resultado = switch ( ch ) { caso 'A' : rendimiento Resultado . EXCELENTE ; caso 'B' : caso 'C' : rendimiento Resultado . BIEN ; predeterminado : generar nueva ThisIsNoGoodException (); };                   

Las sentencias de iteración son sentencias que se ejecutan repetidamente cuando una condición dada se evalúa como verdadera. Desde J2SE 5.0 , Java tiene cuatro formas de dichas sentencias. La condición debe tener tipo booleano o Boolean, es decir, C

mientras ( 1 ) { hacerAlgo (); }   

da como resultado un error de compilación.

En el whilebucle, la prueba se realiza antes de cada iteración.

mientras ( i < 10 ) { hacerAlgo (); }     

En el do ... whilebucle, la prueba se realiza después de cada iteración, por lo que el código siempre se ejecuta al menos una vez.

// doSomething() se llama al menos una vez do { doSomething (); } while ( i < 10 );      

forLos bucles en Java incluyen un inicializador, una condición y una contraexpresión. Es posible incluir varias expresiones del mismo tipo utilizando la coma como delimitador (excepto en la condición). Sin embargo, a diferencia de C, la coma es solo un delimitador y no un operador.

for ( int i = 0 ; i < 10 ; i ++ ) { doSomething (); } // Un bucle más complejo que utiliza dos variables for ( int i = 0 , j = 9 ; i < 10 ; i ++ , j -= 3 ) { doSomething (); }                           

Al igual que en C, las tres expresiones son opcionales. El siguiente bucle es infinito:

para (;;) { hacerAlgo (); }   

forLos bucles mejorados están disponibles desde J2SE 5.0 . Este tipo de bucle utiliza iteradores integrados sobre matrices y colecciones para devolver cada elemento de la colección dada. Se devuelve cada elemento y se puede acceder a él en el contexto del bloque de código. Cuando se ejecuta el bloque, se devuelve el siguiente elemento hasta que no queden elementos. A diferencia de C# , este tipo de bucle no implica una palabra clave especial, sino que utiliza un estilo de notación diferente.

para ( int i : intArray ) { hacerAlgo ( i ); }      

Las etiquetas son puntos asignados en el código que utilizan las instrucciones breaky continue. La palabra clave Java gotono se puede utilizar para saltar a puntos específicos en el código.

inicio : algunMetodo ();

La breakinstrucción sale del bucle o switchinstrucción más cercana. La ejecución continúa en la instrucción posterior a la instrucción finalizada, si la hubiera.

for ( int i = 0 ; i < 10 ; i ++ ) { while ( true ) { break ; } // Se romperá hasta este punto }               

Es posible salir del bucle externo utilizando etiquetas:

exterior : for ( int i = 0 ; i < 10 ; i ++ ) { while ( true ) { break exterior ; } } // Se romperá hasta este punto               

La continueinstrucción interrumpe la iteración actual de la instrucción de control actual y comienza la siguiente iteración. El siguiente whilebucle en el código a continuación lee caracteres llamando a getChar(), omitiendo las instrucciones en el cuerpo del bucle si los caracteres son espacios:

int ch ; while ( ch == getChar ()) { if ( ch == ' ' ) { continue ; // Omite el resto del bucle while }              // Resto del bucle while, no se alcanzará si ch == ' ' doSomething (); } 

Las etiquetas se pueden especificar en continuedeclaraciones y breakenunciados:

exterior : for ( String str : stringsArr ) { char [] strChars = str . toCharArray (); for ( char ch : strChars ) { if ( ch == ' ' ) { /* Continúa el ciclo externo y la siguiente  cadena se recupera de stringsArr */ continue exterior ; } doSomething ( ch ); } }                          

La returndeclaración se utiliza para finalizar la ejecución del método y devolver un valor. El valor devuelto por el método se escribe después de la returnpalabra clave. Si el método devuelve algo que no sea void, debe utilizar la returndeclaración para devolver algún valor.

void doSomething ( boolean streamClosed ) { // Si streamClosed es verdadero, la ejecución se detiene if ( streamClosed ) { return ; } readFromStream (); }          int calculateSum ( int a , int b ) { int resultado = a + b ; devolver resultado ; }             

returnLa declaración finaliza la ejecución inmediatamente, excepto en un caso: si la declaración se encuentra dentro de un trybloque y se complementa con un finally, el control pasa al finallybloque.

void doSomething ( boolean streamClosed ) { try { if ( streamClosed ) { return ; } readFromStream (); } finally { /* Se llamará en último lugar incluso si  no se llamó a readFromStream() */ freeResources (); } }                 

Las excepciones se gestionan dentro de try... catchbloques.

try { // Declaraciones que pueden generar excepciones methodThrowingExceptions (); } catch ( Exception ex ) { // Excepción capturada y manejada aquí reportException ( ex ); } finally { // Declaraciones que siempre se ejecutan después de los bloques try/catch freeResources (); }             

Las instrucciones dentro del trybloque se ejecutan y, si alguna de ellas genera una excepción, se interrumpe la ejecución del bloque y el catchbloque se encarga de gestionar la excepción. Puede haber varios catchbloques, en cuyo caso se ejecuta el primer bloque con una variable de excepción cuyo tipo coincida con el tipo de la excepción generada.

Java SE 7 también introdujo cláusulas multi-catch además de cláusulas uni-catch. Este tipo de cláusulas catch permite a Java manejar distintos tipos de excepciones en un único bloque, siempre que no sean subclases entre sí.

try { methodThrowingException (); } catch ( IOException | IllegalArgumentException ex ) { //Tanto IOException como IllegalArgumentException se detectarán y manejarán aquí reportException ( ex ); }          

Si ningún bloque coincide con el tipo de la excepción lanzada, se interrumpe catchla ejecución del bloque (o método) externo que contiene la instrucción try... y la excepción se transmite hacia arriba y fuera del bloque (o método) que la contiene. La excepción se propaga hacia arriba a través de la pila de llamadas hasta que se encuentra un bloque coincidente dentro de uno de los métodos activos actualmente. Si la excepción se propaga hasta el método superior sin que se encuentre un bloque coincidente, se escribe una descripción textual de la excepción en el flujo de salida estándar.catchcatchmaincatch

Las instrucciones dentro del finallybloque siempre se ejecutan después de los bloques tryy catch, independientemente de si se generó o no una excepción e incluso si returnse alcanzó una instrucción. Estos bloques son útiles para proporcionar código de limpieza cuya ejecución está garantizada.

Los bloques catchy finallyson opcionales, pero al menos uno u otro debe estar presente después del trybloque.

tryLas instrucciones -with-resources son un tipo especial de try-catch-finallyinstrucciones introducidas como una implementación del patrón dispose en Java SE 7. En una tryinstrucción -with-resources, la trypalabra clave va seguida de la inicialización de uno o más recursos que se liberan automáticamente cuando tryfinaliza la ejecución del bloque. Los recursos deben implementar java.lang.AutoCloseable. tryNo es necesario que las instrucciones -with-resources tengan un bloque catcho finallya diferencia de las instrucciones normales try-catch-finally.

try ( FileOutputStream fos = new FileOutputStream ( "nombre_archivo" ); XMLEncoder xEnc = new XMLEncoder ( fos )) { xEnc . writeObject ( objeto ); } catch ( IOException ex ) { Logger . getLogger ( Serializer . class . getName () . log ( Level . SEVERE , null , ex ); }                   

Desde Java 9 es posible utilizar variables ya declaradas:

FileOutputStream fos = new FileOutputStream ( " nombre_archivo " ) ; XMLEncoder xEnc = new XMLEncoder ( fos ) ; try ( fos ; xEnc ) { xEnc.writeObject ( objeto ) ; } catch ( IOException ex ) { Logger.getLogger ( Serializer.class.getName ( ) ) . log ( Level.SEVERE , null , ex ) ; }​                   

La throwdeclaración se utiliza para generar una excepción y finalizar la ejecución del bloque o método. La instancia de la excepción generada se escribe después de la throwdeclaración.

void methodThrowingExceptions ( Object obj ) { if ( obj == null ) { // Lanza una excepción del tipo NullPointerException throw new NullPointerException (); } // No se llamará si el objeto es nulo doSomethingWithObject ( obj ); }               

Java tiene herramientas integradas para programación multihilo . Para fines de sincronización de subprocesos, la synchronizeddeclaración se incluye en el lenguaje Java.

Para sincronizar un bloque de código, se le antepone la synchronizedpalabra clave seguida del objeto de bloqueo dentro de los corchetes. Cuando el subproceso en ejecución llega al bloque sincronizado, adquiere un bloqueo de exclusión mutua , ejecuta el bloque y luego libera el bloqueo. Ningún subproceso puede ingresar a este bloque hasta que se libere el bloqueo. Cualquier tipo de referencia no nulo puede usarse como bloqueo.

/* Adquiere el bloqueo en someObject. Debe ser de un tipo de referencia y no debe ser nulo */ sincronizado ( someObject ) { // Declaraciones sincronizadas }   

assertLas declaraciones están disponibles desde J2SE 1.4 . Este tipo de declaraciones se utilizan para realizar afirmaciones en el código fuente, que se pueden activar y desactivar durante la ejecución para clases o paquetes específicos. Para declarar una afirmación, assertse utiliza la palabra clave seguida de una expresión condicional. Si se evalúa como falsecuando se ejecuta la declaración, se genera una excepción. Esta declaración puede incluir dos puntos seguidos de otra expresión, que actuará como el mensaje de detalle de la excepción.

// Si n es igual a 0, se lanza AssertionError assert n != 0 ; /* Si n es igual a 0, se lanzará AssertionError con el mensaje después de los dos puntos */ assert n != 0 : "n era igual a cero" ;        

Los tipos primitivos en Java incluyen tipos enteros, números de punto flotante, unidades de código UTF-16 y un tipo booleano. No hay tipos sin signo en Java, excepto charel tipo , que se utiliza para representar unidades de código UTF-16. La falta de tipos sin signo se compensa con la introducción de la operación de desplazamiento a la derecha sin signo ( >>>), que no está presente en C++. Sin embargo, se han formulado críticas sobre la falta de compatibilidad con C y C++ que esto provoca. ^[3]

charno necesariamente corresponde a un solo carácter. Puede representar una parte de un par sustituto , en cuyo caso el punto de código Unicode se representa mediante una secuencia de dos charvalores.

Esta característica del lenguaje se introdujo en J2SE 5.0 . El encasillado es la operación de convertir un valor de un tipo primitivo en un valor de un tipo de referencia correspondiente, que sirve como contenedor para este tipo primitivo en particular. El desempaquetado es la operación inversa de convertir un valor de un tipo de referencia (anteriormente encasillado) en un valor de un tipo primitivo correspondiente. Ninguna de las operaciones requiere una conversión explícita.

Ejemplo:

int foo = 42 ; // Tipo primitivo Integer bar = foo ; /* foo está encapsulado en bar, bar es de tipo Integer,  que sirve como contenedor para int */ int foo2 = bar ; // Desempaquetado de nuevo al tipo primitivo            

Los tipos de referencia incluyen tipos de clase, tipos de interfaz y tipos de matriz. Cuando se llama al constructor, se crea un objeto en el montón y se asigna una referencia a la variable. Cuando una variable de un objeto queda fuera del ámbito, la referencia se rompe y, cuando no quedan referencias, el objeto se marca como basura. El recolector de basura luego lo recolecta y lo destruye algún tiempo después.

Una variable de referencia es nullcuando no hace referencia a ningún objeto.

Las matrices en Java se crean en tiempo de ejecución, al igual que las instancias de clase. La longitud de la matriz se define en el momento de la creación y no se puede modificar.

int [] números = new int [ 5 ] ; números [ 0 ] = 2 ; números [ 1 ] = 5 ; int x = números [ 0 ] ;           

// Sintaxis larga int [] números = new int [] { 20 , 1 , 42 , 15 , 34 }; // Sintaxis corta int [] números2 = { 20 , 1 , 42 , 15 , 34 };                

En Java, las matrices multidimensionales se representan como matrices de matrices. Técnicamente, se representan mediante matrices de referencias a otras matrices.

int [][] números = new int [ 3 ][ 3 ] ; números [ 1 ][ 2 ] = 2 ;      int [][] números2 = {{ 2 , 3 , 2 }, { 1 , 2 , 6 }, { 2 , 4 , 5 }};           

Debido a la naturaleza de las matrices multidimensionales, las submatrices pueden variar en longitud, por lo que las matrices multidimensionales no están obligadas a ser rectangulares a diferencia de C:

int [][] números = new int [ 2 ][] ; //Inicialización de la primera dimensión únicamente     números [ 0 ] = nuevo int [ 3 ] ; números [ 1 ] = nuevo int [ 2 ] ;      

Las clases son los fundamentos de un lenguaje orientado a objetos como Java. Contienen miembros que almacenan y manipulan datos. Las clases se dividen en clases de nivel superior y clases anidadas . Las clases anidadas son clases ubicadas dentro de otra clase que pueden acceder a los miembros privados de la clase que las contiene. Las clases anidadas incluyen clases miembro (que pueden definirse con el modificador static para una anidación simple o sin él para clases internas), clases locales y clases anónimas .

clase  Foo { // Miembros de la clase }  

clase  Foo { // Clase de nivel superior clase Bar { // Clase interna } }       

clase  Foo { // Clase de nivel superior static class Bar { // Clase anidada } }        

clase  Foo { void bar () { clase Foobar { // Clase local dentro de un método } } }         

clase  Foo { void bar () { new Object () { // Creación de una nueva clase anónima que extiende Object }; } }         

Los miembros no estáticos de una clase definen los tipos de las variables y métodos de instancia, que están relacionados con los objetos creados a partir de esa clase. Para crear estos objetos, se debe crear una instancia de la clase mediante el newoperador y llamando al constructor de la clase.

Foo foo = nuevo Foo ();    

Se accede a los miembros de las instancias y de las clases estáticas con el .operador (punto).

Acceso a un miembro de instancia
Se puede acceder a los miembros de instancia a través del nombre de una variable.

Cadena foo = "Hola" ; Cadena bar = foo . toUpperCase ();      

Acceso a un miembro de clase estático
Se accede a los miembros estáticos utilizando el nombre de la clase o cualquier otro tipo. Esto no requiere la creación de una instancia de clase. Los miembros estáticos se declaran utilizando el staticmodificador.

clase pública Foo { public static void doSomething () { } }         // Llamar al método estático Foo.doSomething ();

Los modificadores son palabras clave que se utilizan para modificar las declaraciones de tipos y miembros de tipos. En particular, existe un subgrupo que contiene los modificadores de acceso.

• abstract- Especifica que una clase solo sirve como clase base y no se puede instanciar.
• static- Se utiliza solo para clases miembro, especifica que la clase miembro no pertenece a una instancia específica de la clase contenedora.
• final- Las clases marcadas como finalno se pueden extender y no pueden tener subclases.
• strictfp- Especifica que todas las operaciones de punto flotante deben realizarse de acuerdo con IEEE 754 y prohíbe el uso de precisión mejorada para almacenar resultados intermedios.

De manera predeterminada, todos los métodos de todas las clases son concretos, a menos que se utilice la palabra clave abstract. Una clase abstracta puede incluir métodos abstractos, que no tienen implementación. De manera predeterminada, todos los métodos de todas las interfaces son abstractos, a menos que se utilice la palabra clave default. La palabra clave default se puede utilizar para especificar un método concreto en una interfaz.

//De forma predeterminada, todos los métodos en todas las clases son concretos, a menos que se use la palabra clave abstracta. public abstract class Demo { // Una clase abstracta puede incluir métodos abstractos, que no tienen implementación. public abstract int sum ( int x , int y );             // Una clase abstracta también puede incluir métodos concretos. public int product ( int x , int y ) { return x * y ; } }            //De manera predeterminada, todos los métodos en todas las interfaces son abstractos, a menos que se use la palabra clave predeterminada. interface  DemoInterface { int getLength (); //La palabra clave abstracta se puede usar aquí, aunque es completamente inútil //La palabra clave predeterminada se puede usar en este contexto para especificar un método concreto en una interfaz default int product ( int x , int y ) { return x * y ; } }                  

clase final pública MiClaseFinal {...}    clase pública ThisIsWrong extiende MyFinalClass {...} // prohibido      

Los modificadores de acceso , o modificadores de herencia , establecen la accesibilidad de las clases, métodos y otros miembros. Los miembros marcados como publicpueden accederse desde cualquier lugar. Si una clase o su miembro no tiene ningún modificador, se asume el acceso predeterminado.

clase pública Foo { int go () { return 0 ; }          clase privada Bar { } }    

La siguiente tabla muestra si el código dentro de una clase tiene acceso a la clase o al método dependiendo de la ubicación de la clase que accede y del modificador de la clase o el miembro de clase al que se accede:

Un constructor es un método especial que se llama cuando se inicializa un objeto. Su propósito es inicializar los miembros del objeto. Las principales diferencias entre los constructores y los métodos ordinarios son que los constructores se llaman solo cuando se crea una instancia de la clase y nunca devuelven nada. Los constructores se declaran como métodos comunes, pero se nombran como la clase y no se especifica ningún tipo de retorno:

clase  Foo { Cadena str ;    Foo () { // Constructor sin argumentos   // Inicialización }  Foo ( String str ) { // Constructor con un argumento this . str = str ; } }       

Los inicializadores son bloques de código que se ejecutan cuando se crea una clase o una instancia de una clase. Hay dos tipos de inicializadores: los inicializadores estáticos y los inicializadores de instancia .

Los inicializadores estáticos inicializan los campos estáticos cuando se crea la clase. Se declaran mediante la staticpalabra clave:

clase  Foo { static { // Inicialización } }     

Una clase se crea solo una vez. Por lo tanto, los inicializadores estáticos no se llaman más de una vez. Por el contrario, los inicializadores de instancia se llaman automáticamente antes de la llamada a un constructor cada vez que se crea una instancia de la clase. A diferencia de los constructores, los inicializadores de instancia no pueden tomar ningún argumento y, por lo general, no pueden lanzar ninguna excepción comprobada (excepto en varios casos especiales). Los inicializadores de instancia se declaran en un bloque sin ninguna palabra clave:

clase  Foo { { // Inicialización } }    

Dado que Java tiene un mecanismo de recolección de basura, no hay destructores . Sin embargo, cada objeto tiene un finalize()método llamado antes de la recolección de basura, que se puede anular para implementar la finalización.

Todas las instrucciones en Java deben residir dentro de métodos . Los métodos son similares a las funciones, excepto que pertenecen a clases. Un método tiene un valor de retorno, un nombre y, por lo general, algunos parámetros que se inicializan cuando se lo llama con algunos argumentos. De manera similar a C++, los métodos que no devuelven nada tienen el tipo de retorno declarado como void. A diferencia de C++, en Java no se permite que los métodos tengan valores de argumento predeterminados y, en su lugar, los métodos suelen estar sobrecargados.

clase  Foo { int bar ( int a , int b ) { return ( a * 2 ) + b ; }             /* Método sobrecargado con el mismo nombre pero diferente conjunto de argumentos */ int bar ( int a ) { return a * 2 ; } }       

Un método se llama utilizando .la notación de un objeto o, en el caso de un método estático, también del nombre de una clase.

Foo foo = new Foo (); int result = foo . bar ( 7 , 2 ); // Se llama al método no estático en foo         int finalResult = Math . abs ( resultado ); // Llamada al método estático    

La throwspalabra clave indica que un método genera una excepción. Todas las excepciones verificadas deben incluirse en una lista separada por comas.

void openStream () lanza IOException , myException { // Indica que se puede lanzar una IOException }      

• abstract- Los métodos abstractos solo pueden estar presentes en clases abstractas , dichos métodos no tienen cuerpo y deben ser reemplazados por una subclase a menos que sean abstractos en sí mismos.
• static- Hace que el método sea estático y accesible sin crear una instancia de clase. Sin embargo, los métodos estáticos no pueden acceder a miembros no estáticos de la misma clase.
• final- Declara que el método no se puede anular en una subclase.
• native- Indica que este método se implementa a través de JNI en código dependiente de la plataforma. La implementación real ocurre fuera del código Java y dichos métodos no tienen cuerpo.
• strictfp- Declara estricta conformidad con IEEE 754 al realizar operaciones de punto flotante.
• synchronized- Declara que un subproceso que ejecuta este método debe adquirir el monitor. En el caso de synchronizedlos métodos, el monitor es la instancia de la clase o java.lang.Classsi el método es estático.
• Modificadores de acceso: idénticos a los utilizados con las clases.

clase pública Base { void público m1 () {...} void público final m2 () {...}            público estático void m3 () {...} público estático final void m4 () {...} }          clase pública Derived extiende Base { public void m1 () {...} // OK, anulando Base#m1() public void m2 () {...} // prohibido               public static void m3 () {...} // OK, ocultando Base#m3() public static void m4 () {...} // prohibido }           

Esta característica del lenguaje se introdujo en J2SE 5.0 . El último argumento del método puede declararse como un parámetro de aridad variable, en cuyo caso el método se convierte en un método de aridad variable (a diferencia de los métodos de aridad fija) o simplemente en un método varargs . Esto permite pasar una cantidad variable de valores, del tipo declarado, al método como parámetros, incluso sin parámetros. Estos valores estarán disponibles dentro del método como una matriz.

void printReport ( String header , int ... numbers ) { // numbers representa variables System.out.println ( header ) ; for ( int num : numbers ) { System.out.println ( num ) ; } }​​​               // Llamar al método varargs printReport ( "Reportar datos" , 74 , 83 , 25 , 96 );    

Los campos, o variables de clase , se pueden declarar dentro del cuerpo de la clase para almacenar datos.

clase  Foo { doble barra ; }   

Los campos se pueden inicializar directamente cuando se declaran.

clase  Foo { doble barra = 2.3 ; }     

• static- Convierte el campo en un miembro estático.
• final- Permite que el campo se inicialice solo una vez en un constructor o dentro del bloque de inicialización o durante su declaración, lo que ocurra primero.
• transient- Indica que este campo no se almacenará durante la serialización .
• volatile- Si se declara un campo volatile, se garantiza que todos los subprocesos vean un valor consistente para la variable.

Las clases en Java solo pueden heredar de una clase. Una clase puede derivarse de cualquier clase que no esté marcada como final. La herencia se declara utilizando la extendspalabra clave. Una clase puede hacer referencia a sí misma utilizando la thispalabra clave y a su superclase directa utilizando la superpalabra clave.

clase  Foo { }la clase  Foobar extiende Foo {   }

Si una clase no especifica su superclase, hereda implícitamente de java.lang.Objectla clase. Por lo tanto, todas las clases en Java son subclases de Objectla clase.

Si la superclase no tiene un constructor sin parámetros, la subclase debe especificar en sus constructores qué constructor de la superclase utilizar. Por ejemplo:

clase  Foo { public Foo ( int n ) { // Hacer algo con n } }       clase  Foobar extiende Foo { private int number ; // La superclase no tiene constructor sin parámetros // así que tenemos que especificar qué constructor de nuestra superclase usar y cómo         public Foobar ( int numero ) { super ( numero ) ; this.numero = numero ; } }​        

A diferencia de C++, todos finallos métodos no binarios en Java son virtuales y pueden ser reemplazados por las clases heredadas.

clase  Operación { public int doSomething () { return 0 ; } }        clase  NewOperation extiende Operation { @Override public int doSomething () { return 1 ; } }           

Una clase abstracta es una clase que está incompleta o debe considerarse incompleta y, por lo tanto, no puede instanciarse.

Una clase C tiene métodos abstractos si se cumple alguna de las siguientes condiciones:

• C contiene explícitamente una declaración de un método abstracto.
• Cualquiera de las superclases de C tiene un método abstracto y C no declara ni hereda un método que lo implemente.
• Una superinterfaz directa de C declara o hereda un método (que, por lo tanto, es necesariamente abstracto) y C no declara ni hereda un método que lo implemente.
• Se puede crear una subclase de una clase abstracta que no es en sí misma abstracta, lo que da como resultado la ejecución de un constructor para la clase abstracta y, por lo tanto, la ejecución de los inicializadores de campo para las variables de instancia de esa clase.

paquete org.dwwwp.test ; /** * @author jcrypto */ clase pública AbstractClass { cadena final estática privada hola ;         static { System . out . println ( AbstractClass . class . getName () + ": tiempo de ejecución del bloque estático" ); hola = "hola desde " + AbstractClass . class . getName (); }           { System . out . println ( AbstractClass . class . getName () + ": instancia bloque tiempo de ejecución" ); }     public AbstractClass ( ) { System.out.println ( AbstractClass.class.getName ( ) + " : tiempo de ejecución del constructor " ) ; }       public static void hola ( ) { System.out.println ( hola ) ; } }​​      

paquete org.dwwwp.test ; /** * @author jcrypto */ clase pública CustomClass extiende AbstractClass {      static { System . out . println ( CustomClass . class . getName () + ": tiempo de ejecución del bloque estático" ); }      { System . out . println ( CustomClass . class . getName () + ": tiempo de ejecución del bloque de instancia" ); }     public CustomClass ( ) { System.out.println ( CustomClass.class.getName ( ) + " : tiempo de ejecución del constructor " ) ; }       public static void main ( String [] args ) { CustomClass nc = new CustomClass (); hola (); //AbstractClass.hello();//también válido } }             

Producción:

org.dwwwp.test.AbstractClass: tiempo de ejecución de bloque estáticoorg.dwwwp.test.CustomClass: tiempo de ejecución de bloque estáticoorg.dwwwp.test.AbstractClass: tiempo de ejecución del bloque de instanciaorg.dwwwp.test.AbstractClass: tiempo de ejecución del constructororg.dwwwp.test.CustomClass: tiempo de ejecución del bloque de instanciaorg.dwwwp.test.CustomClass: tiempo de ejecución del constructorHola desde org.dwwwp.test.AbstractClass

Esta característica del lenguaje se introdujo en J2SE 5.0 . Técnicamente, las enumeraciones son un tipo de clase que contiene constantes de enumeración en su cuerpo. Cada constante de enumeración define una instancia del tipo de enumeración. Las clases de enumeración no se pueden instanciar en ningún lugar excepto en la propia clase de enumeración.

enumeración Temporada { INVIERNO , PRIMAVERA , VERANO , OTOÑO }      

Se permite que las constantes de enumeración tengan constructores, que se llaman cuando se carga la clase:

enumeración pública Temporada { INVIERNO ( "Frío" ), PRIMAVERA ( "Más cálido" ), VERANO ( "Caliente" ), OTOÑO ( "Más fresco" );        Temporada ( String description ) { this . description = description ; }       descripción de cadena final privada ;    public String getDescription () { devolver descripción ; } }      

Las enumeraciones pueden tener cuerpos de clase, en cuyo caso se tratan como clases anónimas que extienden la clase de enumeración:

public enum Temporada { INVIERNO { String getDescription () { return "frío" ;} }, PRIMAVERA { String getDescription () { return "más cálido" ;} }, VERANO { String getDescription () { return "caliente" ;} }, OTOÑO { String getDescription () { return "más fresco" ;} }; }                               

Las interfaces son tipos que no contienen campos y normalmente definen una serie de métodos sin una implementación real. Son útiles para definir un contrato con cualquier número de implementaciones diferentes. Cada interfaz es implícitamente abstracta. Los métodos de interfaz pueden tener un subconjunto de modificadores de acceso según la versión del lenguaje, strictfplo que tiene el mismo efecto que para las clases, y también staticdesde Java SE 8.

interfaz  ActionListener { int ACTION_ADD = 0 ; int ACTION_REMOVE = 1 ; void actionSelected ( int acción ); }             

Una interfaz se implementa mediante una clase que utiliza la implementspalabra clave. Se permite implementar más de una interfaz, en cuyo caso se escriben después de implementsla palabra clave en una lista separada por comas. Una clase que implementa una interfaz debe anular todos sus métodos, de lo contrario debe declararse como abstracta.

interfaz  RequestListener { int requestReceived (); }   la clase  ActionHandler implementa ActionListener , RequestListener { public void actionSelected ( int action ) { }           público int solicitudRecibida () { } }    //Método de llamada definido por la interfaz RequestListener listener = new ActionHandler (); /*ActionHandler se puede  representar como RequestListener...*/ listener . requestReceived (); /*...y por lo tanto se sabe que implementa  el método requestReceived()*/      

Estas características se introdujeron con el lanzamiento de Java SE 8. Una interfaz se convierte automáticamente en una interfaz funcional si define solo un método. En este caso, una implementación se puede representar como una expresión lambda en lugar de implementarla en una nueva clase, lo que simplifica enormemente la escritura de código en el estilo funcional . Las interfaces funcionales se pueden anotar opcionalmente con la @FunctionalInterfaceanotación, que le indicará al compilador que verifique si la interfaz realmente se ajusta a una definición de una interfaz funcional.

// Una interfaz funcional @FunctionalInterface interfaz  Cálculo { int calcular ( int algúnNumero , int algúnOtroNumero ); }      // Un método que acepta esta interfaz como parámetro int runCalculation ( Calculation cálculo ) { return cálculo . calcular ( 1 , 2 ); }      // Usando una lambda para llamar al método runCalculation (( number , otherNumber ) -> number + otherNumber );     // Código equivalente que utiliza una clase anónima en lugar de runCalculation ( new Calculation () { @Override public int calculate ( int someNumber , int someOtherNumber ) { return someNumber + someOtherNumber ; } })               

Los tipos de parámetros de Lambda no tienen que especificarse completamente y pueden inferirse de la interfaz que implementa. El cuerpo de Lambda puede escribirse sin un bloque de cuerpo y una returndeclaración si es solo una expresión. Además, para aquellas interfaces que solo tienen un único parámetro en el método, se pueden omitir los corchetes. ^[8]

// La misma llamada que la anterior, pero con tipos completamente especificados y un bloque de cuerpo runCalculation (( int number , int otherNumber ) -> { return number + otherNumber ; });         // Una interfaz funcional con un método que tiene un solo parámetro interface  StringExtender { String extendString ( String input ); }    // Inicializar una variable de este tipo mediante un lambda StringExtender extender = input -> input + " Extended" ;       

No es necesario utilizar lambdas cuando ya existe un método nombrado compatible con la interfaz. Este método se puede pasar en lugar de una lambda mediante una referencia de método. Existen varios tipos de referencias de método:

El código anterior que llama runCalculationse puede reemplazar con el siguiente usando las referencias del método:

ejecutarCalculation ( Entero :: suma );

Las interfaces pueden heredar de otras interfaces al igual que las clases. A diferencia de las clases, se permite heredar de múltiples interfaces. Sin embargo, es posible que varias interfaces tengan un campo con el mismo nombre, en cuyo caso se convierte en un único miembro ambiguo, al que no se puede acceder.

/* La clase que implementa esta interfaz debe implementar métodos de ActionListener y RequestListener */ interface  EventListener extends ActionListener , RequestListener { }     

Java SE 8 introdujo métodos predeterminados para las interfaces, lo que permite a los desarrolladores agregar nuevos métodos a las interfaces existentes sin romper la compatibilidad con las clases que ya implementan la interfaz. A diferencia de los métodos de interfaz habituales, los métodos predeterminados tienen un cuerpo que se llamará en caso de que la clase que los implementa no lo anule.

interfaz  StringManipulator { String extendString ( String input ); // Un método que es opcional para implementar el valor predeterminado String shortenString ( String input ) { return input . substring ( 1 ); } }              // Esta es una clase válida a pesar de no implementar todos los métodos class  PartialStringManipulator implements StringManipulator { @Override public String extendString ( String input ) { return input + " Extended" ; } }              

Los métodos estáticos son otra característica del lenguaje introducida en Java SE 8. Se comportan exactamente de la misma manera que en las clases.

interfaz  StringUtils { static String shortenByOneSymbol ( String entrada ) { return entrada.substring ( 1 ) ; } }​         StringUtils .shortenByOneSymbol ( "Prueba" ) ;

Los métodos privados se agregaron en la versión Java 9. Una interfaz puede tener un método con un cuerpo marcado como privado, en cuyo caso no será visible para las clases heredadas. Se puede llamar desde métodos predeterminados con el fin de reutilizar el código.

interfaz  Logger { valor predeterminado void logError () { log ( Level . ERROR ); }        valor predeterminado void logInfo () { log ( Level . INFO ); }      void privado log ( Nivel nivel ) { SystemLogger . log ( nivel . id ); } }      

Las anotaciones en Java son una forma de incorporar metadatos al código. Esta característica del lenguaje se introdujo en J2SE 5.0 .

Java tiene un conjunto de tipos de anotaciones predefinidos, pero se permite definir otros nuevos. Una declaración de tipo de anotación es un tipo especial de una declaración de interfaz. Se declaran de la misma manera que las interfaces, excepto que la interfacepalabra clave está precedida por el @signo. Todas las anotaciones se extienden implícitamente desde java.lang.annotation.Annotationy no se pueden extender desde ninguna otra cosa.

@interface Operaciones de bloqueo { }  

Las anotaciones pueden tener las mismas declaraciones en el cuerpo que las interfaces comunes, además se les permite incluir enumeraciones y anotaciones. La principal diferencia es que las declaraciones de métodos abstractos no deben tener parámetros ni generar excepciones. También pueden tener un valor predeterminado, que se declara utilizando la defaultpalabra clave después del nombre del método:

@interface BlockingOperations { booleano fileSystemOperations (); booleano networkOperations () predeterminado falso ; }        

Las anotaciones se pueden utilizar en cualquier tipo de declaración, ya sea de paquete, clase (incluidas las enumeraciones), interfaz (incluidas las anotaciones), campo, método, parámetro, constructor o variable local. También se pueden utilizar con constantes de enumeración. Las anotaciones se declaran utilizando el @signo que precede al nombre del tipo de anotación, después del cual se escriben los pares elemento-valor entre corchetes. A todos los elementos sin valor predeterminado se les debe asignar un valor.

@BlockingOperations ( /*obligatorio*/ fileSystemOperations , /*opcional*/ networkOperations = true ) void openOutputStream () { //Método anotado }       

Además de la forma genérica, existen otras dos formas de declarar una anotación, que son abreviaturas. La anotación de marcador es una forma abreviada y se utiliza cuando no se asignan valores a los elementos:

@Unused // Abreviatura de @Unused() void travelToJupiter () { }   

La otra forma corta se denomina anotación de un solo elemento . Se utiliza con tipos de anotaciones que contienen solo un elemento o en el caso en que hay varios elementos, pero solo uno de ellos carece de un valor predeterminado. En la forma de anotación de un solo elemento, se omite el nombre del elemento y solo se escribe el valor en su lugar:

/* Equivalente para @BlockingOperations(fileSystemOperations = true). networkOperations tiene un valor predeterminado y no es necesario asignarle un valor */@BlockingOperations ( verdadero ) void openOutputStream () { }  

Los genéricos , o tipos parametrizados, o polimorfismo paramétrico , son una de las principales características introducidas en J2SE 5.0 . Antes de que se introdujeran los genéricos, era necesario declarar todos los tipos explícitamente. Con los genéricos, se hizo posible trabajar de manera similar con diferentes tipos sin declarar los tipos exactos. El propósito principal de los genéricos es garantizar la seguridad de los tipos y detectar errores en tiempo de ejecución durante la compilación. A diferencia de C#, la información sobre los parámetros utilizados no está disponible en tiempo de ejecución debido al borrado de tipos . ^[9]

Las clases se pueden parametrizar añadiendo una variable de tipo dentro de corchetes angulares ( <y >) después del nombre de la clase. Esto hace posible el uso de esta variable de tipo en los miembros de la clase en lugar de los tipos reales. Puede haber más de una variable de tipo, en cuyo caso se declaran en una lista separada por comas.

Es posible limitar una variable de tipo a un subtipo de una clase específica o declarar una interfaz que debe ser implementada por el tipo. En este caso, la variable de tipo se adjunta con la extendspalabra clave seguida del nombre de la clase o la interfaz. Si la variable está restringida tanto por la clase como por la interfaz o si hay varias interfaces, el nombre de la clase se escribe primero, seguido de los nombres de las interfaces con & el signo como delimitador.

/* Esta clase tiene dos variables de tipo, T y V. T debe ser un subtipo de ArrayList e implementar la interfaz Formattable */ public class Mapper < T extends ArrayList & Formattable , V > { public void add ( T array , V item ) { // la matriz tiene el método add porque es una subclase de ArrayList array . add ( item ); } }                  

Cuando se declara una variable de un tipo parametrizado o se crea una instancia, su tipo se escribe exactamente en el mismo formato que en el encabezado de la clase, excepto que el tipo real se escribe en el lugar de la declaración de la variable de tipo.

/* Mapper se crea con CustomList como T y Integer como V. CustomList debe ser una subclase de ArrayList e implementar Formattable */ Mapper < CustomList , Integer > mapper = new Mapper < CustomList , Integer > ();      

Desde Java SE 7, es posible utilizar un rombo ( <>) en lugar de argumentos de tipo, en cuyo caso se inferirá este último. El siguiente código en Java SE 7 es equivalente al código del ejemplo anterior:

Mapper < CustomList , Integer > mapper = nuevo Mapper <> ();     

Al declarar una variable para un tipo parametrizado, es posible utilizar comodines en lugar de nombres de tipo explícitos. Los comodines se expresan escribiendo ?el signo en lugar del tipo real. Es posible limitar los tipos posibles a las subclases o superclases de alguna clase específica escribiendo la extendspalabra clave o la superpalabra clave correspondiente seguida del nombre de la clase.

/* Cualquier instancia de Mapper con CustomList como primer parámetro puede usarse independientemente del segundo.*/ Mapper < CustomList , ?> mapper ; mapper = new Mapper < CustomList , Boolean > (); mapper = new Mapper < CustomList , Integer > ();          /* No se aceptarán tipos que utilicen nada más que una subclase de Number como segundo parámetro */ void addMapper ( Mapper <? , ? extends Number > mapper ) { }      

El uso de genéricos puede estar limitado a algunos métodos particulares; este concepto también se aplica a los constructores. Para declarar un método parametrizado, las variables de tipo se escriben antes del tipo de retorno del método en el mismo formato que para las clases genéricas. En el caso del constructor, las variables de tipo se declaran antes del nombre del constructor.

clase  Mapper { // La clase en sí no es genérica, el constructor es < T , V > Mapper ( T array , V item ) { } }          /* Este método aceptará únicamente matrices del mismo tipo que el tipo de elemento buscado o su subtipo*/ static < T , V extends T > boolean contains ( T item , V [] arr ) { for ( T currentItem : arr ) { if ( item . equals ( currentItem )) { return true ; } } return false ; }                         

Las interfaces se pueden parametrizar de manera similar a las clases.

interfaz  Expandable < T extiende Número > { void addItem ( T item ); }      // Esta clase es una clase parametrizada  Array < T extiende Number > implementa Expandable < T > { void addItem ( T item ) { } }          // Y esto no es así y utiliza un tipo explícito en su lugar class  IntegerArray implements Expandable < Integer > { void addItem ( Integer item ) { } }        

• Plataforma Java, edición estándar

Wikilibros tiene un libro sobre el tema: Programación/Sintaxis de Java

• Especificación del lenguaje Java, tercera edición Descripción autorizada del lenguaje Java
• Javadocs de la API de Java SE 19