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:
Un identificador no puede:
Los literales enteros son de inttipo por defecto a menos que longse especifique el tipo añadiendo un sufijo Lo lun carácter 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 ; { int 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 //y se extienden hasta el final de la línea actual. 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 podría 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 .
ifdeclaraciónLas 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 ; switchdeclaraciónLas 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 ; } switchexpresionesDesde 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.
whilebucleEn el whilebucle, la prueba se realiza antes de cada iteración.
mientras ( i < 10 ) { hacerAlgo (); } do ... whilebucleEn 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 ); forbucleforLos 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 (); } forBucle mejoradoforLos 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 ();breakdeclaraciónLa 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 continuedeclaraciónLa 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 ); } } returndeclaraciónLa 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 (); } } try-catch-finallydeclaracionesLas 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.
try-declaraciones con recursostryLas 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. tryLas instrucciones -with-resources no necesitan tener un bloque catcho a diferencia de las instrucciones normales.finallytry-catch-finally
intentar ( FileOutputStream fos = new FileOutputStream ( "nombre_archivo" ); XMLEncoder xEnc = new XMLEncoder ( fos )) { xEnc . writeObject ( objeto ); } atrapar ( IOException ex ) { Registrador . getLogger ( Serializador . class . getName () . log ( Nivel . 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 ) ; } throwdeclaraciónLa 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 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 .
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 ; } } 
Una clase final no puede subclasificarse. Como esto puede brindar beneficios de seguridad y eficiencia, muchas de las clases de la biblioteca estándar de Java son finales, como java.lang.Systemy java.lang.String.
Ejemplo:
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. publicSe puede acceder a los miembros marcados como 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 según 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 comprobadas 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 mediante 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.Un método final no puede ser anulado u oculto por subclases. [5] Esto se utiliza para evitar un comportamiento inesperado de una subclase que altere un método que puede ser crucial para la función o la consistencia de la clase. [6]
Ejemplo:
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 } Un error muy común es creer que declarar un método como finalmejora la eficiencia al permitir que el compilador inserte directamente el método donde sea que se lo llame (ver expansión en línea ). Debido a que el método se carga en tiempo de ejecución , los compiladores no pueden hacer esto. Solo el entorno de ejecución y el compilador JIT saben exactamente qué clases se han cargado, y por lo tanto solo ellos pueden tomar decisiones sobre cuándo incluir en línea, si el método es final o no. [7]
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:
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() + ": static block runtime"); } { System.out.println(CustomClass.class.getName() + ": instance block runtime"); } public CustomClass() { System.out.println(CustomClass.class.getName() + ": constructor runtime"); } public static void main(String[] args) { CustomClass nc = new CustomClass(); hello(); //AbstractClass.hello();//also valid }}Output:
org.dwwwp.test.AbstractClass: static block runtimeorg.dwwwp.test.CustomClass: static block runtimeorg.dwwwp.test.AbstractClass: instance block runtimeorg.dwwwp.test.AbstractClass: constructor runtimeorg.dwwwp.test.CustomClass: instance block runtimeorg.dwwwp.test.CustomClass: constructor runtimehello from org.dwwwp.test.AbstractClassThis language feature was introduced in J2SE 5.0. Technically enumerations are a kind of class containing enum constants in its body. Each enum constant defines an instance of the enum type. Enumeration classes cannot be instantiated anywhere except in the enumeration class itself.
enum Season { WINTER, SPRING, SUMMER, AUTUMN}Enum constants are allowed to have constructors, which are called when the class is loaded:
public enum Season { WINTER("Cold"), SPRING("Warmer"), SUMMER("Hot"), AUTUMN("Cooler"); Season(String description) { this.description = description; } private final String description; public String getDescription() { return description; }}Enumerations can have class bodies, in which case they are treated like anonymous classes extending the enum class:
public enum Season { WINTER { String getDescription() {return "cold";} }, SPRING { String getDescription() {return "warmer";} }, SUMMER { String getDescription() {return "hot";} }, FALL { String getDescription() {return "cooler";} };}Interfaces are types which contain no fields and usually define a number of methods without an actual implementation. They are useful to define a contract with any number of different implementations. Every interface is implicitly abstract. Interface methods are allowed to have a subset of access modifiers depending on the language version, strictfp, which has the same effect as for classes, and also static since Java SE 8.
interface ActionListener { int ACTION_ADD = 0; int ACTION_REMOVE = 1; void actionSelected(int action);}An interface is implemented by a class using the implements keyword. It is allowed to implement more than one interface, in which case they are written after implements keyword in a comma-separated list. A class implementing an interface must override all its methods, otherwise it must be declared as abstract.
interface RequestListener { int requestReceived();}class ActionHandler implements ActionListener, RequestListener { public void actionSelected(int action) { } public int requestReceived() { }}//Calling method defined by interfaceRequestListener listener = new ActionHandler(); /*ActionHandler can be represented as RequestListener...*/listener.requestReceived(); /*...and thus is known to implement requestReceived() method*/These features were introduced with the release of Java SE 8. An interface automatically becomes a functional interface if it defines only one method. In this case an implementation can be represented as a lambda expression instead of implementing it in a new class, thus greatly simplifying writing code in the functional style. Functional interfaces can optionally be annotated with the @FunctionalInterface annotation, which will tell the compiler to check whether the interface actually conforms to a definition of a functional interface.
// A functional interface@FunctionalInterfaceinterface Calculation { int calculate(int someNumber, int someOtherNumber);}// A method which accepts this interface as a parameterint runCalculation(Calculation calculation) { return calculation.calculate(1, 2);}// Using a lambda to call the methodrunCalculation((number, otherNumber) -> number + otherNumber);// Equivalent code which uses an anonymous class insteadrunCalculation(new Calculation() { @Override public int calculate(int someNumber, int someOtherNumber) { return someNumber + someOtherNumber; }})Lambda's parameters types don't have to be fully specified and can be inferred from the interface it implements. Lambda's body can be written without a body block and a return statement if it is only an expression. Also, for those interfaces which only have a single parameter in the method, round brackets can be omitted.[8]
// Same call as above, but with fully specified types and a body blockrunCalculation((int number, int otherNumber) -> { return number + otherNumber;});// A functional interface with a method which has only a single parameterinterface StringExtender { String extendString(String input);}// Initializing a variable of this type by using a lambdaStringExtender extender = input -> input + " Extended";It is not necessary to use lambdas when there already is a named method compatible with the interface. This method can be passed instead of a lambda using a method reference. There are several types of method references:
The code above which calls runCalculation could be replaced with the following using the method references:
runCalculation(Integer::sum);Interfaces can inherit from other interfaces just like classes. Unlike classes it is allowed to inherit from multiple interfaces. However, it is possible that several interfaces have a field with the same name, in which case it becomes a single ambiguous member, which cannot be accessed.
/* Class implementing this interface must implement methods of bothActionListener and RequestListener */interface EventListener extends ActionListener, RequestListener { }Java SE 8 introduced default methods to interfaces which allows developers to add new methods to existing interfaces without breaking compatibility with the classes already implementing the interface. Unlike regular interface methods, default methods have a body which will get called in the case if the implementing class doesn't override it.
interface StringManipulator { String extendString(String input); // A method which is optional to implement default String shortenString(String input) { return input.substring(1); }}// This is a valid class despite not implementing all the methodsclass PartialStringManipulator implements StringManipulator { @Override public String extendString(String input) { return input + " Extended"; }}Static methods is another language feature introduced in Java SE 8. They behave in exactly the same way as in the classes.
interface StringUtils { static String shortenByOneSymbol(String input) { return input.substring(1); }}StringUtils.shortenByOneSymbol("Test");Private methods were added in the Java 9 release. An interface can have a method with a body marked as private, in which case it will not be visible to inheriting classes. It can be called from default methods for the purposes of code reuse.
interface Logger { default void logError() { log(Level.ERROR); } default void logInfo() { log(Level.INFO); } private void log(Level level) { SystemLogger.log(level.id); }}Annotations in Java are a way to embed metadata into code. This language feature was introduced in J2SE 5.0.
Java has a set of predefined annotation types, but it is allowed to define new ones. An annotation type declaration is a special type of an interface declaration. They are declared in the same way as the interfaces, except the interface keyword is preceded by the @ sign. All annotations are implicitly extended from java.lang.annotation.Annotation and cannot be extended from anything else.
@interface BlockingOperations {}Annotations may have the same declarations in the body as the common interfaces, in addition they are allowed to include enums and annotations. The main difference is that abstract method declarations must not have any parameters or throw any exceptions. Also they may have a default value, which is declared using the default keyword after the method name:
@interface BlockingOperations { boolean fileSystemOperations(); boolean networkOperations() default false;}Annotations may be used in any kind of declaration, whether it is package, class (including enums), interface (including annotations), field, method, parameter, constructor, or local variable. Also they can be used with enum constants. Annotations are declared using the @ sign preceding annotation type name, after which element-value pairs are written inside brackets. All elements with no default value must be assigned a value.
@BlockingOperations(/*mandatory*/ fileSystemOperations,/*optional*/ networkOperations = true)void openOutputStream() { //Annotated method}Besides the generic form, there are two other forms to declare an annotation, which are shorthands. Marker annotation is a short form, it is used when no values are assigned to elements:
@Unused // Shorthand for @Unused()void travelToJupiter() {}The other short form is called single element annotation. It is used with annotations types containing only one element or in the case when multiple elements are present, but only one elements lacks a default value. In single element annotation form the element name is omitted and only value is written instead:
/* Equivalent for @BlockingOperations(fileSystemOperations = true).networkOperations has a default value anddoes not have to be assigned a value */@BlockingOperations(true)void openOutputStream() {}Generics, or parameterized types, or parametric polymorphism, is one of the major features introduced in J2SE 5.0. Before generics were introduced, it was required to declare all the types explicitly. With generics, it became possible to work in a similar manner with different types without declaring the exact types. The main purpose of generics is to ensure type safety and to detect runtime errors during compilation. Unlike C#, information on the used parameters is not available at runtime due to type erasure.[9]
Classes can be parameterized by adding a type variable inside angle brackets (< and >) following the class name. It makes possible the use of this type variable in class members instead of actual types. There can be more than one type variable, in which case they are declared in a comma-separated list.
It is possible to limit a type variable to a subtype of some specific class or declare an interface that must be implemented by the type. In this case the type variable is appended by the extends keyword followed by a name of the class or the interface. If the variable is constrained by both class and interface or if there are several interfaces, the class name is written first, followed by interface names with & sign used as the delimiter.
/* This class has two type variables, T and V. T must be a subtype of ArrayList and implement Formattable interface */public class Mapper<T extends ArrayList & Formattable, V> { public void add(T array, V item) { // array has add method because it is an ArrayList subclass array.add(item); }}When a variable of a parameterized type is declared or an instance is created, its type is written exactly in the same format as in the class header, except the actual type is written in the place of the type variable declaration.
/* Mapper is created with CustomList as T and Integer as V.CustomList must be a subclass of ArrayList and implement Formattable */Mapper<CustomList, Integer> mapper = new Mapper<CustomList, Integer>();Since Java SE 7, it is possible to use a diamond (<>) in place of type arguments, in which case the latter will be inferred. The following code in Java SE 7 is equivalent to the code in the previous example:
Mapper<CustomList, Integer> mapper = new Mapper<>();When declaring a variable for a parameterized type, it is possible to use wildcards instead of explicit type names. Wildcards are expressed by writing ? sign instead of the actual type. It is possible to limit possible types to the subclasses or superclasses of some specific class by writing the extends keyword or the super keyword correspondingly followed by the class name.
/* Any Mapper instance with CustomList as the first parametermay be used regardless of the second one.*/Mapper<CustomList, ?> mapper;mapper = new Mapper<CustomList, Boolean>();mapper = new Mapper<CustomList, Integer>();/* Will not accept types that use anything buta subclass of Number as the second parameter */void addMapper(Mapper<?, ? extends Number> mapper) {}Usage of generics may be limited to some particular methods, this concept applies to constructors as well. To declare a parameterized method, type variables are written before the return type of the method in the same format as for the generic classes. In the case of constructor, type variables are declared before the constructor name.
class Mapper { // The class itself is not generic, the constructor is <T, V> Mapper(T array, V item) { }}/* This method will accept only arrays of the same type asthe searched item type or its subtype*/static <T, V extends T> boolean contains(T item, V[] arr) { for (T currentItem : arr) { if (item.equals(currentItem)) { return true; } } return false;}Interfaces can be parameterized in the similar manner as the classes.
interface Expandable<T extends Number> { void addItem(T item);}// This class is parameterizedclass Array<T extends Number> implements Expandable<T> { void addItem(T item) { }}// And this is not and uses an explicit type insteadclass IntegerArray implements Expandable<Integer> { void addItem(Integer item) { }}
