Sintaxis de Java

Las siguientes palabras son palabras clave y no pueden utilizarse como identificadores bajo ninguna circunstancia; hay 47.

Las siguientes palabras son palabras clave contextuales y solo están restringidas a ciertos contextos, de los cuales hay 16.

Las siguientes palabras se refieren a valores literales utilizados por el idioma, de los cuales hay 3.

Las siguientes palabras están reservadas como palabras clave, pero actualmente no tienen ningún uso ni propósito, de las cuales hay 4.

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

import java.io.FileOutputStream ;// 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" );

java.lang.Systemes una de las clases más fundamentales en Java. Es una clase de utilidad para interactuar con el sistema, que contiene flujos estándar de entrada, salida y error, propiedades del sistema y variables de entorno, tiempo y más.

java.lang.Objectes el tipo principal de Java . Es implícitamente la superclase de todas las clases que no declaran ninguna clase padre (por lo tanto, todas las clases en Java heredan de Object). Todos los valores se pueden convertir a este tipo, aunque para los valores primitivos esto implica autoboxing .

Todos los registros extienden implícitamente java.lang.Record. Por lo tanto, un record, aunque se trate como un class, no puede extender ninguna otra clase.

Todos los tipos enumerados (enums) en Java extienden implícitamente java.lang.Enum<E>. Por lo tanto, un enum, aunque se trata como un class, no puede extender ninguna otra clase. El parámetro de tipo Eestá restringido como .Enum<EextendsEnum<E>>

java.lang.Class<T>es una clase que representa un classo interfaceen la aplicación en tiempo de ejecución. No se puede construir mediante instanciación directa, sino que la crea la JVM cuando una clase se deriva de los bytes de un .classarchivo . Se puede obtener un literal de clase a través de X.classen dicha clase X. Por ejemplo, String.classdevuelve Class<String>. Una clase desconocida que se está modelando se puede representar como Class<?>(donde ?denota un comodín ).

Aunque X.classparece estar accediendo a un campo llamado " class ", en realidad no existe tal campo con ese nombre ; de ​​hecho, está ejecutando la instrucción , que inserta una constante del grupo de constantes de tiempo de ejecución de la clase en la pila de operandos. ^{[ 1 ]}ldc

java.lang.Stringes el tipo de cadena básico de Java. Es inmutable . No implementa Iterable<Character>, por lo que no se puede iterar sobre él en un bucle for-each, pero se puede convertir a char[]. Algunos métodos tratan cada unidad de código UTF-16 como un , pero también hay charmétodos disponibles para convertirlo a un int[]que es efectivamente UTF-32String . implementa java.lang.CharSequence, por lo que se puede acceder a charlos en el Stringmediante el método charAt().

java.lang.Throwablees el supertipo de todo lo que se puede lanzar o capturar con las sentencias throwy de Java catch. Sus subclases directas conocidas son java.lang.Error(para errores graves irrecuperables) y java.lang.Exception(para excepciones que pueden ocurrir naturalmente en la ejecución de un programa).

java.lang.Mathes una clase de utilidad que contiene funciones matemáticas y constantes matemáticas (como Math.sin(), Math.pow(), y Math.PI).

java.lang.IOes una clase introducida en Java 25 (anteriormente ubicada en java.iocomo java.io.IO). Permite un acceso más sencillo a los flujos de entrada y salida estándar a través de System.iny System.out.

Cada tipo primitivo tiene una clase contenedora asociada (ver tipos primitivos ).

Una declaración de importación de tipo permite que un tipo con nombre se referencie mediante un nombre simple en lugar del nombre completo que incluye el paquete. Las declaraciones de importación pueden ser de un solo tipo o de importación bajo demanda . Deben colocarse al principio del archivo de código, después de la declaración del paquete.

paquete org.wikipedia.examples ;import java.util.Random ; // Declaración de un solo tipopublic class ImportsTest { public static void main ( String [] args ) { /* La siguiente línea es equivalente a  * java.util.Random random = new java.util.Random();  * Habría sido incorrecto sin la importación.  */ Random random = new Random (); } }

En el código se mencionan las declaraciones de importación bajo demanda. Una "importación comodín" (o "importación glob") importa todos los tipos del paquete. Una "importación estática" importa los miembros del paquete.

/** * Esta forma de importar clases hace que todas las clases * del paquete java.util estén disponibles por nombre, podría usarse en lugar de la * declaración de importación del ejemplo anterior. */ import java.util.* ;

Una importación con comodín puede no importar nada si no existen símbolos en ese paquete. Por ejemplo, las instrucciones como son válidas, pero no hacen nada, ya que todas las clases residen en paquetes dentro del paquete ; dicha importación no importaría recursivamente todas las clases del paquete.importjava.*;java

Este tipo de declaración está disponible desde J2SE 5.0 . Las declaraciones de importación estática permiten acceder 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.Systempublic 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:

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

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

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

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

import org.wikipedia.screen.ColorName ; import static org.wikipedia.screen.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 ; } } }

Desde Java 25, los módulos se pueden usar en las declaraciones de importación para importar automáticamente todos los paquetes exportados por el módulo. ^{[ 5 ]} Esto se hace usando import module. Por ejemplo, es equivalente aimportmodulejava.sql;

import java.sql.* ; import javax.sql.* ; // Exportaciones indirectas restantes de java.logging, java.transaction.xa y java.xml

De manera similar, , de manera similar, importa los 54 paquetes pertenecientes a .importmodulejava.base;java.base

import module java . base ;/** * La importación del módulo java.base nos permite evitar la importación manual de la mayoría de las clases . * Se utilizan las siguientes clases (fuera de java.lang): * java.text.MessageFormat * java.util.Date * java.util.List * java.util.concurrent.ThreadLocalRandom */ public class Example { public static void main ( String [] args ) { List < String > colours = List . of ( "Red" , "Orange" , "Yellow" , "Green" , "Blue" , ​​"Indigo" , "Violet" ); IO . println ( MessageFormat . format ( "My favorite colour is {0} and today is {1,date,long}" , colours . get ( ThreadLocalRandom . current (). nextInt ( colours . size ())), new Date () )); } }

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

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

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

if ( i == 3 ) { hacerAlgo (); } else { hacerAlgoMás (); }

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

if ( i == 3 ) { hacerAlgo (); } else if ( i == 2 ) { hacerAlgoMás (); } else { hacerAlgoDiferente (); }

Además, se puede usar el operador ?: en lugar de una simple sentencia if, por ejemplo

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

Las sentencias switch en Java pueden usar tipos de datos primitivos byte, short, char, y int(no long) o sus tipos envoltorio correspondientes. A partir de J2SE 5.0, es posible usar tipos enum . A partir de Java SE 7, es posible usar cadenas. ^{[ 7 ]} Otros tipos de referencia no se pueden usar en switchsentencias.

Los valores posibles se indican mediante caseetiquetas. En Java, estas etiquetas solo pueden contener constantes (incluidas las constantes de enumeración y las constantes de cadena). La ejecución comenzará después de la etiqueta que corresponda a la expresión entre corchetes. Opcionalmente, defaultpuede incluirse una etiqueta para indicar 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 finaliza con la breakpalabra clave. Es posible omitirla, lo que provoca que la ejecución continúe con la siguiente etiqueta; sin embargo, normalmente se mostrará una advertencia durante la compilación.

switch ( ch ) { case 'A' : hacerAlgo (); // Se activa si ch == 'A' break ; case 'B' : case 'C' : hacerAlgoMás (); // Se activa si ch == 'B' o ch == 'C' break ; default : hacerAlgoDiferente (); // Se activa en cualquier otro caso break ; }

enum Resultado { GRANDE , BIEN , // más valores de enum }Resultado resultado = switch ( ch ) { case 'A' -> Resultado . GREAT ; case 'B' , 'C' -> Resultado . FINE ; default -> throw new Exception (); };

Resultado resultado = switch ( ch ) { case ' A' : yield Resultado . GREAT ; case 'B' : case 'C' : yield Resultado . FINE ; default : throw new Exception (); };

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

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

En el bucle do- while, la prueba se realiza después de cada iteración. Por lo tanto, el código siempre se ejecuta al menos una vez.

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

forEn Java, los bucles incluyen un inicializador, una condición y una expresión de contador. 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 ++ ) { hacerAlgo (); } // Un bucle más complejo usando dos variables for ( int i = 0 , j = 9 ; i < 10 ; i ++ , j -= 3 ) { hacerAlgo (); }

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

para (;;) { hacerAlgo (); }

Los bucles `foreach` 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. Cada elemento se devuelve y es accesible dentro del contexto del bloque de código. Cuando se ejecuta el bloque, se devuelve el siguiente elemento hasta que no queden más. Este bucle `for` de Java se incorporó posteriormente a C++11 . A diferencia de C# , este tipo de bucle no utiliza una palabra clave especial, sino una notación diferente.

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

Las etiquetas se asignan a puntos en el código utilizados por breaklas continuesentencias. Si bien gotoes una palabra clave reservada en Java, no se puede usar para saltar a puntos específicos en el código (de hecho, no tiene ninguna utilidad).

inicio : algúnMétodo ();

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 que finalizó, si la hay.

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

Es posible salir del bucle exterior utilizando etiquetas:

exterior : para ( int i = 0 ; i < 10 ; i ++ ) { mientras ( verdadero ) { romper exterior ; } } // Se detendrá en 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 ; // Salta el resto del bucle while }// Resto del bucle while, no se alcanzará si ch == ' ' doSomething (); }

Las etiquetas se pueden especificar en continuedeclaraciones y breakdeclaraciones:

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

La returninstrucció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 distinto de void, debe utilizar la returninstrucción para devolver algún valor.

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

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

void doSomething ( boolean streamClosed ) { try { if ( streamClosed ) { return ; } readFromStream (); } finally { // Se llamará al final incluso si readFromStream() no se llamó freeResources (); } }

Las excepciones se gestionan dentro de los bloques try- catch.

try { // Instrucciones que pueden lanzar excepciones methodThrowingExceptions (); } catch ( Exception e ) { // Excepción capturada y manejada aquí reportException ( e ); } finally { // Instrucciones 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, la ejecución del bloque se interrumpe y la excepción se gestiona catch. Puede haber varios catchbloques; en ese caso, se ejecuta el primer bloque que contenga una variable de excepción cuyo tipo coincida con el tipo de la excepción generada.

Java SE 7 también introdujo cláusulas multicatch, además de las cláusulas unicatch. Este tipo de cláusulas catch permite a Java gestionar diferentes tipos de excepciones en un único bloque, siempre que no sean subclases entre sí. Si bien se asemeja a un tipo de unión , en realidad es el supertipo común más específico de las alternativas.

import java.net.HttpRetryException ; import java.net.http.HttpTimeoutException ;void makeRequest () throws HttpRetryException , HttpTimeoutException { // ... }void main ( String [] args ) { try { methodThrowingExceptions (); } catch ( HttpRetryException | HttpTimeoutException e ) { // Tanto HttpRetryException como HttpTimeoutException serán capturadas y manejadas aquí // Esto, de hecho, se reduce a simplemente java.io.IOException. reportException ( e ); } }

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 propaga hacia arriba, fuera del bloque (o método) contenedor. 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. 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 la salida estándar.catchcatchmaincatch

Las instrucciones dentro del finallybloque se ejecutan siempre después de los bloques try`and` catch, independientemente de si se produjo una excepción o incluso si returnse llegó a una instrucción. Estos bloques son útiles para proporcionar código de limpieza que se ejecuta siempre con seguridad.

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

tryLas sentencias -with-resources son un tipo especial de sentencias try- catch- finallyintroducidas como una implementación del patrón dispose en Java SE 7. En una trysentencia -with-resources, la palabra clave va seguida de la inicialización de uno o más recursos que se liberan automáticamente cuando finaliza tryla ejecución del bloque. Los recursos deben implementar . Las sentencias -with-resources no requieren un bloque o a diferencia de las sentencias - - normales .tryjava.lang.AutoCloseabletrycatchfinallytrycatchfinally

import java.beans.XMLEncoder ; import java.io.FileOutputStream ; import java.io.IOException ; import java.util.logging.Level ; import java.util.logging.Logger ;try ( FileOutputStream fos = new FileOutputStream ( "filename" ); XMLEncoder xEnc = new XMLEncoder ( fos )) { xEnc . writeObject ( object ); } catch ( IOException e ) { Logger . getLogger ( Serializer . class . getName ()). log ( Level . SEVERE , null , e ); }

Desde Java 9 es posible utilizar variables ya declaradas:

import java.beans.XMLEncoder ; import java.io.FileOutputStream ; import java.io.IOException ; import java.util.logging.Level ; import java.util.logging.Logger ;FileOutputStream fos = new FileOutputStream ( " filename " ) ; XMLEncoder xEnc = new XMLEncoder ( fos ) ; try ( fos ; xEnc ) { xEnc.writeObject ( object ) ; } catch ( IOException e ) { Logger.getLogger ( Serializer.class.getName ( ) ) . log ( Level.SEVERE , null , e ) ; }​

Esta throwinstrucción se utiliza para lanzar una excepción y finalizar la ejecución del bloque o método. La instancia de la excepción lanzada se escribe después de la throwinstrucción.

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

En Java, los arreglos multidimensionales se representan como arreglos de arreglos. Técnicamente, se representan mediante arreglos de referencias a otros arreglos.

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

Debido a la naturaleza de los arreglos multidimensionales, los subarreglos pueden variar en longitud, por lo que los arreglos multidimensionales no están obligados a ser rectangulares a diferencia de C:

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

Los miembros no estáticos de una clase definen los tipos de las variables de instancia y los métodos, que están relacionados con los objetos creados a partir de esa clase. Para crear estos objetos, la clase debe instanciarse utilizando el newoperador `instance()` 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 mediante 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.

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

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

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

Los modificadores son palabras clave que se utilizan para modificar las declaraciones de tipos y miembros de tipo. Cabe destacar que existe un subgrupo que contiene los modificadores de acceso.

• abstract- Especifica que una clase solo sirve como clase base y no puede ser instanciada.
• static- Se utiliza únicamente 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 conformidad con la norma IEEE 754 y prohíbe el uso de precisión mejorada para almacenar resultados intermedios.

// Por defecto, todos los métodos en todas las clases son concretos, a menos que se utilice la palabra clave abstract. 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 ; } }// Por defecto, todos los métodos en todas las interfaces son abstractos, a menos que se utilice la palabra clave default. interface DemoInterface { int getLength (); // La palabra clave abstract se puede usar aquí, aunque es completamente inútil // La palabra clave default 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 Final { // ... }// Clase prohibida Derived extiende Final { // ... }

Modificadores de acceso

Los modificadores de acceso , o modificadores de herencia , establecen la accesibilidad de las clases, los métodos y otros miembros. Los miembros marcados como publicaccesibles pueden ser accedidos desde cualquier lugar. Si una clase o uno de sus miembros no tiene modificadores, se asume el acceso predeterminado.

clase pública Foo { int baz () { 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 para la clase o miembro de clase al que se accede:

Un constructor es un bloque especial similar a un método 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 de forma similar a un método, pero se nombran según la clase y no se especifica ningún tipo de retorno; para una clase X, un constructor es X(...); en particular, un constructor predeterminado no tiene parámetros, X().

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

Un constructor parece asemejarse a un método, pero en realidad son bloques de inicialización de instancia y no pueden ser invocados directamente por una llamada a método (a diferencia de C++ , donde los constructores se consideran funciones miembro especiales ). ^{[ 16 ]} A pesar de esto, en el bytecode de la JVM , un constructor aparece con el nombre <init>y se denomina "método de inicialización de instancia", y están marcados void(y, por lo tanto, no colocan ningún objeto resultante en la pila de operandos de la JVM al finalizar la ejecución). ^{[ 17 ]}

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: inicializadores estáticos e inicializadores de instancia .

Los inicializadores estáticos inicializan los campos estáticos cuando se crea la clase. Se declaran utilizando 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. En cambio, 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 aceptar argumentos y, por lo general, no pueden lanzar excepciones comprobadas (salvo en algunos casos especiales). Los inicializadores de instancia se declaran en un bloque sin palabras clave.

clase Foo { { // Inicialización } }

Dado que Java se basa en un mecanismo de recolección de basura, no existen destructores~X() ni deleteoperadores. Sin embargo, cada objeto tiene un finalize()método que se llama antes de la recolección de basura, el cual puede ser sobrescrito para implementar la finalización. No obstante, no hay garantías de qué hilo invocará el finalize()método para un objeto dado, ni siquiera de que se invoque en absoluto. Los finalizadores no son deterministas (a diferencia de los destructores en C++), y liberar recursos críticos en una finalize()llamada puede conducir a un comportamiento impredecible. ^{[ 18 ]} Otra clase, java.lang.ref.Cleanerintroducida en Java 9, se proporciona adicionalmente para redes de seguridad de nivel inferior para recuperar recursos que no son de memoria, como punteros nativos, descriptores de archivos o sockets. ^{[ 19 ]}

En Java, todas las instrucciones deben estar 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 al ser llamado con ciertos argumentos. Al igual que en C++, los métodos que no devuelven nada tienen un tipo de retorno declarado como `delete` void. A diferencia de C++, en Java los métodos no pueden tener valores de argumento predeterminados y, en su lugar, suelen sobrecargarse.

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

Se llama a un método utilizando .una notación sobre un objeto o, en el caso de un método estático, también sobre el nombre de una clase.

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

La throwspalabra clave indica que un método lanza una excepción. Todas las excepciones comprobadas deben aparecer en una lista separada por comas.

import java.io.File ; import java.io.IOException ; import java.util.zip.DataFormatException ;// Indica que se pueden lanzar IOException y DataFormatException void operateOnFile ( File f ) throws IOException , DataFormatException { // ... }

public class Base { public void foo () { // ... }public final void bar () { // ... }public static void baz () { // ... }public static final void qux () { // ... } }public class Derived extends Base { // OK, sobrescribiendo Base::foo() @Override public void foo () { // ... }// prohibido @Override public void bar () { // ... }// OK, sobrescribiendo Base::baz() @Override public static void baz () { // ... }// prohibido @Override public static void qux () { // ... } }

// numbers representa argumentos variables void printReport ( String header , int ... numbers ) { // numbers aparece como int[] System . out . println ( header ); for ( int num : numbers ) { System . out . println ( num ); } }// Llamando al método varargs printReport ( "Datos del informe" , 74 , 83 , 25 , 96 );

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

clase Foo { doble barra ; }

Los campos se pueden inicializar directamente al declararlos.

clase Foo { doble barra = 2.3 ; }

En Java, las clases solo pueden heredar de una única clase. Una clase puede derivarse de cualquier clase que no esté marcada como ` <inherit> final`. La herencia se declara mediante la extendspalabra clave `<herit>`. Una clase puede referenciarse a sí misma mediante la thispalabra clave `<herit>` y a su superclase directa mediante la superpalabra clave `<herit>`.

clase Foo {}clase Foobar extiende Foo {}

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

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 { público Foo ( int n ) { // Hacer algo con n } }clase Foobar extiende Foo { private int number ; // La superclase no tiene constructor sin parámetros // por lo que tenemos que especificar qué constructor de nuestra superclase usar y cómopublic Foobar ( int number ) { super ( number ); this . number = number ; } }

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

paquete org.wikipedia.examples ;public class MyAbstractClass { private static final String hola ;static { System.out.printf ( " % s : tiempo de ejecución del bloque estático%n" , MyAbstractClass.class.getName ( ) ) ; hello = String.format ( " hola desde %s" , MyAbstractClass.class.getName ( ) ); }{ System.out.printf ( "%s: tiempo de ejecución del bloque de instancia %n " , MyAbstractClass.class.getName ( ) ) ; }public AbstractClass ( ) { System.out.printf ( " % s : constructor runtime%n " , MyAbstractClass.class.getName ( ) ) ; }public static void hello () { System . out . println ( hello ); } }

paquete org.wikipedia.examples ;clase pública MyCustomClass extiende MyAbstractClass {static { System.out.printf ( "% s : tiempo de ejecución del bloque estático%n" , MyCustomClass.class.getName ( ) ) ; }{ System.out.printf ( "%s: tiempo de ejecución del bloque de instancia %n " , MyCustomClass.class.getName ( ) ) ; }public CustomClass ( ) { System.out.printf ( " % s : constructor runtime%n " , MyCustomClass.class.getName ( ) ) ; }public static void main ( String [] args ) { MyCustomClass nc = new MyCustomClass (); hello (); MyAbstractClass . hello (); // también válido } }

org.wikipedia.examples.MyAbstractClass: tiempo de ejecución de bloque estático org.wikipedia.examples.MyCustomClass: tiempo de ejecución de bloque estático org.wikipedia.examples.MyAbstractClass: tiempo de ejecución del bloque de instancia org.wikipedia.examples.MyAbstractClass: tiempo de ejecución del constructor org.wikipedia.examples.MyCustomClass: tiempo de ejecución del bloque de instancia org.wikipedia.examples.MyCustomClass: tiempo de ejecución del constructor Hola desde org.wikipedia.examples.MyAbstractClass 

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 otro lugar que no sea la propia clase de enumeración.

enum Temporada { INVIERNO , PRIMAVERA , VERANO , OTOÑO , }

Las constantes de enumeración pueden tener constructores, que se llaman cuando se carga la clase:

public enum Season { WINTER ( "Frío" ), SPRING ( "Más cálido" ), SUMMER ( "Calor" ), AUTUMN ( "Más fresco" );Temporada ( Cadena descripción ) { esta . descripción = descripción ; }Descripción privada final de cadena ;public String getDescription () { return description ; } }

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

public enum Season { WINTER { @Override String getDescription () { return "frío" } }, SPRING { @Override String getDescription () { return "cálido" ; } }, SUMMER { @Override String getDescription () { return "caliente" ; } }, FALL { @Override String getDescription () { return "fresco" ; } };cadena abstracta obtenerDescripción (); }

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

interfaz RequestListener { int requestReceived (); }class ActionHandler implements ActionListener , RequestListener { public void actionSelected ( int action ) { // ... }public int requestReceived () { // ... } }// Llamada al método definido por la interfaz // ActionHandler puede representarse como RequestListener... RequestListener listener = new ActionHandler (); // ...y por lo tanto se sabe que implementa el método requestReceived() listener . 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 un solo método (excluyendo aquellos que se heredan de java.lang.Object). 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 pueden anotarse opcionalmente con la java.lang.FunctionalInterfaceanotación , que le indicará al compilador que verifique si la interfaz se ajusta a la definición de una interfaz funcional.

// Una interfaz funcional @FunctionalInterface interface Calculation { int calculate ( int someNumber , int someOtherNumber ); }// Un método que acepta esta interfaz como parámetro int runCalculation ( Calculation calculation ) { return calculation . calculate ( 1 , 2 ); }// Usando una expresión lambda para llamar al método runCalculation (( número , otroNúmero ) -> número + otroNúmero );// Código equivalente que utiliza una clase anónima en su lugar runCalculation ( new Calculation () { @Override public int calculate ( int someNumber , int someOtherNumber ) { return someNumber + someOtherNumber ; } })

Los tipos de parámetros de una expresión lambda no tienen que especificarse completamente y pueden inferirse de la interfaz que implementa, pero no hay lugar para especificar explícitamente el tipo de retorno de la expresión lambda (que se infiere). El cuerpo de la expresión lambda puede escribirse sin un bloque body ni una returninstrucción si es solo una expresión. Además, para aquellas interfaces que solo tienen un parámetro en el método, se pueden omitir los paréntesis. ^{[ 24 ]}

// 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 ); }// Inicializando una variable de este tipo usando una expresión lambda StringExtender extensor = input -> input + " Extended" ;

Las expresiones lambda no pueden especificar throwscláusulas. Las expresiones lambda implementan alguna interfaz funcional de destino (como java.lang.Runnable, etc.). Las expresiones lambda en sí mismas no son expresiones completas de tipos concretos, sino más bien expresiones polimórficas, cuyo tipo está influenciado por el tipo de destino circundante en lugar de estar completamente influenciado por su propio contenido. ^{[ 25 ]}

import java.util.function.Function ;// Inválido, ya que las expresiones lambda en sí mismas no tienen un tipo independiente var f = ( int x ) -> x + 1 ; // En su lugar debería ser: Function < Integer , Integer > f = x -> x + 1 ;

Si una lambda implementa una interfaz funcional que extiende java.lang.Serializable, entonces cuando la lambda se serializa, se convierte en un java.lang.invoke.SerializedLambda^{[ 26 ]} , que captura información sobre la lambda misma, llamada su "forma serializada". ^{[ 27 ]} Esto es necesario, porque las clases de implementación de lambda son sintéticas y específicas de la JVM, y por lo tanto deben reconstruirse exactamente en otra invocación de la JVM. Al igual que en C++, los nombres de los tipos de lambda son sintéticos y generados por el compilador con detalles de implementación no especificados.

Runnable r = () -> System . out . println ( "Hola" );// Podría imprimir algo como: // class org.wikipedia.examples.Main$$Lambda$1/0x0000000800b00440 System . out . println ( r . getClass ());

Las expresiones lambda no generan archivos de clase , sino que emiten una invokedynamicinstrucción en la JVM, que el entorno de ejecución utiliza para crear una clase de implementación adecuada.

Las expresiones lambda de captura suelen ser objetos distintos, debido a que requieren un estado capturado almacenado; sin embargo, las expresiones lambda que no son de captura pueden ser potencialmente singletons .

Runnable r1 = () -> {}; Runnable r2 = () -> {};System.out.println ( r1 == r2 ) ; // Puede imprimir verdadero o falso; lo determina la JVM

Sin embargo, a diferencia de C++, los tipos lambda no forman parte del modelo de lenguaje; no se puede depender de nada de su clase de tiempo de ejecución, mientras que en C++ el tipo lambda aún se puede extraer decltypepara obtener un tipo de cierre único real; el de una lambda java.lang.Class<?>no se puede referenciar en el código.

Java permite referencias a métodos mediante el operador ::(no está relacionado con el operador de calificación de espacio de nombres de C++ ::). No es necesario usar expresiones lambda cuando ya existe un método con nombre compatible con la interfaz. Este método se puede pasar en lugar de una expresión lambda mediante una referencia a método. Existen varios tipos de referencias a métodos:

El código anterior que realiza llamadas runCalculationpodría reemplazarse con el siguiente utilizando las referencias de método:

ejecutarCálculo ( Entero :: suma );

Tenga en cuenta que en Java, los constructores no se consideran métodos y, por lo tanto, X::Xno existen; una referencia a un constructor se obtiene con X::new.

Las interfaces pueden heredar de otras interfaces, al igual que las clases. A diferencia de las clases, pueden 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 tanto de ActionListener como de RequestListener */ interface EventListener extends ActionListener , RequestListener { }

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

interface StringManipulator { String extendString ( String input ); // Un método que es opcional implementar por defecto 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 String . format ( "%s Extended" , input ); } }

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

interface StringUtils { static String shortenByOneSymbol ( String input ) { return input . substring ( 1 ); } }StringUtils.shortenByOneSymbol ( "Test " ) ;

Los métodos privados se añadieron en la versión Java 9. Una interfaz puede tener un método cuyo cuerpo esté marcado como privado, en cuyo caso no será visible para las clases que hereden de ella. Se puede llamar desde métodos predeterminados para reutilizar el código.

interface Logger { default void logError () { log ( Level . ERROR ); }default void logInfo () { log ( Level . INFO ); }private void log ( Level level ) { SystemLogger . log ( level . 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 .

@interface BlockingOperations {}

@interface BlockingOperations { boolean fileSystemOperations (); boolean networkOperations () default false ; }

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

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

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