Palabras reservadas (funcionales):
abstact |
boolean |
break |
byte |
case |
catch |
char |
class |
continue |
default |
do |
double |
else |
extends |
false |
final |
finally |
float |
for |
if |
implements |
import |
instanceof |
int |
interface |
long |
native |
new |
null |
package |
private |
protected |
public |
return |
short |
static |
super |
switch |
syncroniced |
this |
throw |
throws |
transient |
try |
void |
volatile |
while |
Tipos de comentarios:
/*comentario*/ | // Hasta fin de línea | //* javadoc */ |
Bloques de código:
{ // conjunto de sentencias }Separadores Java:
{ } , : ;Propuestas de estilo de nombres de identificadores:
Tipo |
bytes |
Tipo Datos |
Rango (positivo) |
Literal |
byte |
1 |
Entero |
127 |
14 |
short |
2 |
Entero |
32767 |
14 |
int |
4 |
Entero |
2.147.483.647 |
14 |
long |
8 |
Entero |
9.233e15 |
14 |
float |
4 |
Coma flotante |
1.4e-45 a 3.4e38 |
36,6 |
double |
8 |
Coma flotante |
4.9e-324 a 1.7e308 |
3,14e2 |
char |
2 |
Caracter |
Unicode |
'a' o \064 |
boolean |
1 |
Booleano |
true o false |
true o false |
Vectores:
int vectorNumeros[]=new int[numero];Cadenas Constates:
String nombreBonito = "Amelia";Cadenas Variables:
StringBuffer cadenaVariable = "Cambiante"; C. OperadoresOperadores Unarios:
Operador |
Descripción (prefija) |
Operador |
Descripción (pre o posfija) |
+ |
Convierte el operador a int |
++ |
Incrementa operador |
- |
Niega aritméticamente oper. |
-- |
Decrementa operador |
Operadores aritméticos (binarios):
Operador |
Uso |
Atajo |
Descripción |
+ |
op1 + op2 |
op1 += op2 |
Suma op1 y op2 |
- |
op1 - op2 |
op1 -= op2 |
Resta op2 de op1 |
* |
op1 * op2 |
op1 *= op2 |
Multiplica op1 por op2 |
/ |
op1 / op2 |
op1 /= op2 |
Divide op1 por op2 |
% |
op1 % op2 |
op1 %= op2 |
Resto de op1 / op2 |
Operadores de comparación (binarios):
Operador |
Uso |
Devuelve verdadero si |
> |
op1 > op2 |
op1 es mayor que op2 |
>= |
op1 >= op2 |
op1 es mayor o igual que op2 |
< |
op1 < op2 |
op1 es menor que op2 |
<= |
op1 <= op2 |
op1 es menor o igual que op2 |
== |
op1 == op2 |
op1 y op2 son iguales |
!= |
op1 != op2 |
op1 y op2 son distintos |
&& |
op1 && op2 |
AND, condicionalmente evalúa op2 |
& |
op1 & op2 |
AND, siempre evalúa op1 y op2 |
|| |
op1 || op2 |
OR, condicionalmente evalúa op2 |
| |
op1 | op2 |
OR, siempre evalúa op1 y op2 |
! |
! op |
op es falso |
Operadores de bit (binarios):
Operador |
Uso |
Operación |
>> |
op1 >> op2 |
Desplaza los bits de op1 a la derecha op2 veces |
<< |
op1 << op2 |
Desplaza los bits de op1 a la izquierda op2 veces |
>>> |
op1 >>> op2 |
Desplaza los bits de op1 a la derecha op2 veces (sin signo) |
& |
op1 & op2 |
AND |
| |
op1 | op2 |
OR |
^ |
op1 ^ op2 |
"XOR" |
~ |
~op2 |
Complemento |
Operador terciario:
expresion ? sentencia_si : sentencia_si_noPrecedencia de operadores:
Tipo de operadores |
Operadores de este tipo |
Operadores posfijos |
[ ] . (parametros) expr++ expr-- |
Operadores unarios |
++expr --expr +expr -expr ~ ! |
Creación o conversión |
new (tipo) expr |
Multiplicación |
* / % |
Suma |
+ - |
Desplazamiento |
<< |
Comparación |
< <= = instanceof |
Igualdad |
== != |
AND a nivel de bit |
& |
OR a nivel de bit |
^ |
XOR a nivel de bit |
| |
AND lógico |
&& |
OR lógico |
|| |
Condicional |
? : |
Asignación |
= += -= *= /= %= &= ^= |= <<= = = |
Toma de decisión (if-else y switch):
if ( condición ) { Bloque de código a ejecutar si la condición es cierta } else { Bloque de código a ejecutar si no } switch ( expresionMultivalor ) { case valor1 : conjuntoDeSentencias; break; case valor2 : conjuntoDeSentencias; break; case valor3 : conjuntoDeSentencias; break; default : conjuntoDeSentencias; break; }
Bucles iterativos (while, do-while, for):
while ( expresiónBooleana ) { sentencias; }; do { sentencias; } while ( expresiónBooleana ); for(inicio; condicion_continuacion; sentencia_actualizacion) { sentencias; }
Sentencias de saltos:
etiquetaSentencia: sentenciaEtiquetada break nombreEtiqueta; // Sale del último bucle continue; // Hace otra pasada al último bucle return valor; // Sale del método devolviendo valor E. ClasesDefinición de clase:
acceso class NombreDeClase herencia{ acceso tipo nombreAtributo1; NombreDeClase{ // Constructor } // . . . finalize { //Recogida de basura } acceso tipo_devuelto nombreMétodo1( parámetros ) { cuerpo_del_método1; } }
Tipos de acceso de las clases:
Herencia:
Acceso (igual que para métodos):
Composición:
class claseCompuesta { claseComponente referenciaAObjetoComponente. }G. Métodos
Referencias válidas en los métodos:
Modificadores permitidos:
Sobrecarga del método: Varias implementaciones en función de los parámetros.
Sobreescritura del método: Un cuerpo en cada nivel de herencia.
H. ObjetosInstanciación:
NombreDeClase referenciaAObjeto = new NombreDeClase();Acceso al objeto:
referenciaAObjeto.método( parámetros ); referenciaAObjeto.atributo;Destrucción: Cuando la referencia a objeto sale de ámbito en el programa.
I. InterfacesDeclaración de una interfaz:
interface MiInterfaz { int CONSTANTE = 100; int metodoAbstracto( int p ); // Por definir }
Implementación de interfaces:
class ImplementaInterfaz implements MiInterfaz{ int m=CONSTANTE; int metodoAbstracto( int p ){ return ( p*m ); } }
Herencia múltiple entre interfaces:
interface InterfazMultiple extends Interfaz0,Interfaz1;Clases de envoltura de tipos simples:
Clases de envoltura de tipos simples |
|
Double |
double |
Float |
float |
Integer |
int, short, byte |
Long |
long |
Character |
char |
Boolean |
boolean |
J. Paquetes
Creación de un paquete (primera sentencia de un fichero fuente):
package NombrePaquete;Importación de un paquete o parte de él:
import Paquete.Subpaquete1.Subpaquete2.Clase1; Paquete.Subpaquetes1.Subpaquete2.Clase_o_Interfaz.elementoVisibilidad en los paquetes:
Situación del elemento |
private |
por defecto |
protected |
public |
En la misma clase |
Sí |
Sí |
Sí |
Sí |
En una clase en el mismo paquete |
No |
Sí |
Sí |
Sí |
En una clase hija en otro paquete |
No |
No |
Sí |
Sí |
En una clase no hija en otro paquete |
No |
No |
No |
Sí |
K. Excepciones
Tipos de excepciones:
Lanzamiento de una excepción:
metodoLanzador() throws MiException{ throw MiException: }
Tratamiento de una excepción:
try { // Código posiblemente problematico } catch( tipo_de_excepcion e) { // Código para solucionar la excepcion e } catch( tipo_de_excepcion_mas_general e) // Código para solucionar la excepcion e } finally { // Se ejecutara tras try o catch }L. Threads
Creación:
Sincronización de procesos: