RESUMEN DE SINTAXIS BSICA DE JAVA CONVENCIONES En Java se crean clases dentro de paquetes (packages).

Es posible crear clases fuera de paquetes, pero no es recomendable. En los nombres de los identificadores no deben usarse espacios, acentos, ees, ni smbolos especiales. Los operadores (como +, -etc.) tampoco puede usarse, aunque el guin bajo s. Las convenciones de nombrado ms comunes son: los nombres de paquete slo usan minsculas. Cuando se quieran anidar los paquetes, se usa el punto para expresarlo. Ejemplos: com.empresa.programa, ejercicios.agenda. los nombres de variables van en minscula, pudiendo usar maysculas cuando queramos destacar el principio de alguna palabra en mitad del nombre. Ejemplos: numero, notaMedia. los nombres de las constantes van totalmente en maysculas. Para distinguir el comienzo de una palabra, se suele usar un guin bajo. Ejemplos: INCREMENTO, LIMITE_MAXIMO. los nombres de las clases siguen el mismo patrn que las variables, aunque la primera letra se pone mayscula. Ejemplos: Calculadora, AlumnoMatriculado.

COMENTARIOS Los comentarios se pueden escribir de diversas formas:

TIPOS DE DATOS Los tipos de datos bsicos (tambin llamados tipos primitivos) son: byte: cantidad entera entre -128 y 127. short: cantidad entera entre -32768 y 32767. int: cantidad entera entre -2147483648 y 2147483647. Es el tipo ms utilizado para cantidades numricas, salvo cuando tenemos alguna buena razn para usar un rango de valores diferente. long: cantidad entera entre -9223372036854775808 y 9223372036854775807. float: cantidad decimal con precisin simple. double: cantidad decimal con precisin doble. Es el tipo ms utilizado para valores decimales, salvo que queramos ahorrar memoria a costa de precisin.

boolean: valor lgico que slo puede ser verdadero (true) o falso (false). char: representa a un nico carcter, sea una letra, dgito, signo, smbolo,etc.

Adems de los tipos bsicos, existe el tipo String que es muy utilizado y que representa cadenas de texto. Pero no se trata en este caso de un tipo bsico sino de una clase; por eso su nombre comienza con mayscula, a diferencia de los anteriores. DECLARACIN, INICIALIZACIN Y LITERALES Es obligatorio declarar todos los identificadores, aunque no es obligatorio inicializar las variables:
int x; // Declaracin sin inicializacin. String nombre = Perico; // Declaracin con inicializacin.

Siempre que se utilice el valor de un identificador para cualquier cosa, ser necesario que ese identificador haya recibido previamente algn valor (ya sea en su inicializacin, o en alguna otra parte del programa). La declaracin puede hacerse en cualquier parte, siempre que sea antes del uso. Los literales numricos se escriben sin comillas. Los literales tipo cadena de texto es escriben entre comillas dobles (), y los literales tipo carcter se escriben entre comillas simples (). Los literales lgicos o booleanos son siempre true o false, escritos en minsculas:
int numero = 7; double precio = 10.75; // Se usa el punto para los decimales. String texto = Bienvenido al curso; char letraInicial = J; boolean hayQueSalir = false;

OPERADORES BSICOS Los operadores ms utilizados son los siguientes: ASIGNACIN

OPERADORES ARITMTIC OS
+ * / % Suma (tambin hace concatenacin de cadenas de texto). Resta. Multiplicacin. Divisin. Resto (mdulo).

OPERADORES UNARIOS
+ ++ -! Indica signo positivo (es opcional, porque se asume signo positivo si no se dice otra cosa). Signo negativo. Tambin sirve para cambiar el signo: x = -x. Incremento. Decremento. Complemento. Invierte un valor booleano (cambia true por false y viceversa).

OPERADORES DE COMPARACIN
== != > >= < <= Igual. No igual. Mayor. Mayor o igual. Menor. Menor o igual.

OPERADORES LGICOS
&& || ?: Conjuncin (y). Disyuncin (o). Operador condicional. Se explica ms adelante, en la seccin de las estructuras condicionales.

Hay que poner atencin en no confundir el operador de asignacin (=) con el de igualdad (==). El primero realiza una asignacin de un valor a un identificador, mientras que el segundo compara si se cumple una igualdad. Se puede ver la diferencia haciendo:
System.out.println(x=3); System.out.println(x==3);

La primera orden asigna el valor 3 al identificador x, y luego visualiza dicho valor. La segunda lnea no altera el valor de x para nada, simplemente comprueba si es igual a 3 o no, y como s lo es, visualiza la palabra true (verdadero). En cuanto a los operadores de incremento y decremento, pueden usarse delante o detrs del identificador. Dependiendo de dnde se coloque, la operacin se realizar antes o despus de ejecutar la orden en la que aparezcan. Ejemplo:
int x = 0; System.out.println(x++); // Visualiza 0 y luego incrementa. System.out.println(++x); // Incrementa, y luego visualiza 2. System.out.println(x--); // Visualiza 2 y luego decrementa. System.out.println(x); // Visualiza 1.

OPERADORES ABREVIADOS Con frecuencia usamos operadores para cambiar el valor de una variable, por ejemplo para incrementarla, sumarle o restarle una cantidad, multiplicarla o dividirla por algo, etc. Para abreviar el incremento y el decremento ya tenemos los operadores ++ y -- vistos arriba. En algunos otros casos podemos usar la siguiente sintaxis:

x += 7; // Suma 7 a x. x -= 10; // Resta 10 a x. x *= j; // Multiplica x por j. x /= (z+7); // Divide x entre el valor de z+7. String msj = Hola; msj += msj; // Concatena msj consigo misma (valdr HolaHola).

RDENES Y BLOQUES Cada orden o sentencia de Java termina en un punto y coma. Varias rdenes se pueden agrupar encerrndolas entre llaves, lo cual se denomina un bloque. Los bloques no deben llevar punto y coma al final:
int x; x = 0; System.out.println(x); { int x; x = 0; System.out.println(x); }

Tres rdenes, cada una con su punto y coma.

Tres rdenes agrupadas en un bloque. Cada orden termina en punto y coma, pero el bloque no.

Los bloques pueden anidarse, y cada orden seguir teniendo su punto y coma al final, pero los bloques no:
{ int x = 0; { System.out.println(x); --x; } // Aqu no se pone punto y coma. System.out.println(Fin); } // Aqu tampoco.

ESTRUCTURAS CONDICIONALES IF El condicional ms sencillo es if, al que acompaamos con una condicin (expresin lgica o booleana) y un cuerpo que se ejecutar slo si dicha condicin es cierta:
if(x < 10) System.out.println(x es menor que 10.); System.out.println(Esta lnea se ejecuta en cualquier caso.);

El cuerpo puede ser una sola orden (terminada en punto y coma, como arriba) o un bloque, que no llevar punto y coma:
if(x < 10) { System.out.println(x es menor que 10, voy a corregirlo.); x += 10;

} // Aqu no se pone punto y coma.

IF-ELSE Aadiendo la clusula else a un condicional if, podemos especificar qu hacer cuando la condicin sea falsa. Tenemos entonces dos cuerpos (lo que haremos si la condicin es cierta, y lo que haremos si la condicin es falsa), y cualquiera de ellos puede de nuevo ser una sola orden o un bloque:
if(x < 10) { System.out.println(x es menor que 10, voy a corregirlo.); x += 10; } else System.out.println(No era menor que 10, no hubo que cambiarla.); System.out.println(Esto se ejecuta en cualquier caso.);

En el ejemplo anterior, el primer System.out.println se ejecuta slo si x es menor que 10, el segundo System.out.println se ejecuta slo en caso contrario, y el tercer System.out.println se ejecuta en ambos casos. Ojo al uso de los puntos y comas, segn tengamos orden o bloque. Obviamente, las rdenes que pongamos en el cuerpo de un condicional pueden ser cualquier cosa, incluso otro condicional:
if(x > y) System.out.println(x es mayor que y); else if(x < y) System.out.println(x es menor que y); else System.out.println(x es igual a y);

Al anidar los condicionales if-else hay que prestar especial atencin al uso de las llaves. Por ejemplo, qu visualiza este cdigo?
int x = 0; if(x > 0) if(x <= 10) System.out.println(x est entre 1 y 10); else System.out.println(x no es mayor que cero);

Lo cierto es que no visualiza nada, porque la clusula else est dentro del segundo if, no del primero. Recordemos que ni tabulaciones ni espaciados son significativos. El cdigo anterior debera probablemente haberse escrito as:
int x = 0; if(x > 0) { if(x <= 10) System.out.println(x est entre 1 y 10); } else System.out.println(x no es mayor que cero);

SWITCH La sentencia switch es un condicional mltiple, lo que en muchos lenguajes se denomina una estructura segn. Funciona con la siguiente sintaxis:
switch(x) { case 1: System.out.println(x vale uno); break; case 2: System.out.println(x vale dos); break; case 3: System.out.println(x vale tres); break; default: System.out.println(x no es ni 1, ni 2 ni 3.); }

Es decir, cada caso posible se identifica con la clusula case seguida de dos puntos y las rdenes a ejecutar, mientras que las rdenes que hay que ejecutar si no se cumple ningn caso se identifican mediante default, si se desea (esta clusula no es obligatorio ponerla; la usamos slo si la queremos). La expresin que pongamos dentro de los parntesis del switch debe ser numrica, salvo en la versin 7 de Java donde tambin se permite usar valores String. Hay que destacar el uso de la orden break. Se utiliza para salir de la estructura switch, una vez que hemos ejecutado el caso que nos interesa, y no queremos comprobar el resto. Si no ponemos el break, la ejecucin contina por el resto de casos, hasta alcanzar incluso la clusula default:
int x = 1; switch(x) { case 1: System.out.println(x vale uno.); case 2: System.out.println(x vale dos.); default: System.out.println(x no vale ni uno ni dos.); }

El cdigo anterior visualiza:

Dado que tras entrar en el caso 1 y ejecutarlo, no hay un break que nos haga salir del switch. Se contina por tanto comprobando el caso 2 (que no se cumple), y se llega al caso default que se cumple siempre, por lo que tambin se ejecuta. Un detalle a destacar es que el cuerpo de cada caso se considera siempre un bloque aunque no tenga llaves. Es una excepcin a la sintaxis habitual de Java, por lo cual este cdigo:

int x = 1; switch(x) { case 1: System.out.println(Hola); System.out.println(Adis); case 2: System.out.println(Hasta luego); }

Visualiza Hola y Adis, aun sin tener llaves que encierren el cuerpo del caso 1. Por ltimo, hay que destacar que se puede usar el mismo cuerpo para ms de un caso:
switch(diaDeLaSemana) { case 6: case 7: System.out.println(Fin de semana!); break; default: System.out.println(Entre semana, ponte a currar.); }

EL OPERADOR CONDICIONAL En la seccin de operadores se introdujo el operador condicional, sin dar detalle de su uso o funcin. Vamos a verlo ahora. La sintaxis de este operador es condicin ? valor si cierto : valor si falso. La expresin completa se evala, y su valor resultante ser valor si cierto en el caso de que condicin sea verdadera, y valor si falso en el caso de que no lo sea. Veamos un ejemplo:
int x = 1; String texto = x >= 0 ? positivo : negativo; System.out.println(x es + texto);

La segunda lnea asigna a la variable texto la cadena positivo si x es mayor o igual que cero, o la cadena negativo en otro caso. Es decir: La condicin es x >= 0 El valor si cierto es positivo El valor si falso es negativo

Como se ve, se trata de una forma abreviada de hacer un if-else cuando la finalidad de dicho condicional es elegir un valor. Veamos otro ejemplo, ahora anidando dos operadores condicionales:
System.out.println(prueba > secreto ? Te has pasado : (prueba < secreto ? No llegas : Acertaste!));

ESTRUCTURAS DE ITERACIN Existen las siguientes estructuras de iteracin (bucles): Bucle while. Bucle dowhile. Bucle for.

A continuacin se detalla la sintaxis y funcionamiento de cada uno. BUCLE WHILE El bucle while repite una orden o un bloque de rdenes mientras sea cierta una expresin lgica. La expresin lgica puede ser una condicin cualquiera, una variable booleana, una combinacin de ambas cosas, etc. La expresin lgica se coloca entre parntesis tras la palabra while. A continuacin, se escribe lo que haya que repetir, que puede ser una orden (terminada en punto y coma), o un bloque (sin l). Ejemplos:
int x = 1; while(x < 100) x = x * 2; // Se repite slo esta orden.

double valor = 10; while(valor >= 0) { System.out.println(valor); valor /= 2; } // Se repite el bloque.

Hay que cuidar el uso de las llaves. No son necesarias si vamos a repetir slo una orden, pero s lo son cuando vamos a repetir un bloque. Es buena prctica poner las llaves siempre, incluso con una sola orden en el cuerpo del bucle, por si acaso posteriormente aadimos alguna orden ms al cuerpo. Podemos hacer un bucle infinito poniendo dentro de los parntesis una condicin que siempre sea cierta, como 1=1 o simplemente el valor true. Se puede salir de un bucle infinito con la orden break, aunque en general los bucles infinitos y este uso de break se consideran mala prctica en la programacin estructurada:
int x = 100; while(true) { if(x < 20) break; // Si se cumple la condicin, salimos del bucle. x /= 5; // Si no se cumple, ejecutaremos esto y repetiremos.

} System.out.println(x);

BUCLE DOWHILE Este bucle es idntico al anterior, con la nica diferencia de que la condicin se comprueba despus de haber ejecutado el cuerpo del bucle, en vez de antes:
int x = 1; do x *= 2; while(x < 10);

int x = 1; do { System.out.println(x); ++x; } while(x < 10);

Ojo: la palabra while ahora es el final de la orden, por lo cual siempre llevar punto y coma tras ella. Cabe destacar que el bucle dowhile siempre ejecuta su cuerpo al menos una vez, cosa que no es cierta en el bucle while. BUCLE FOR El bucle for se utiliza normalmente cuando hay que repetir algo un nmero de veces que se conoce de antemano. An as, la sintaxis de este bucle en Java es tan flexible que se puede usar para muchos ms casos. La estructura general de la orden for es for(inicializacin; expresin; actualizacin), donde: inicializacin es una orden cualquiera, que se ejecutar una nica vez antes de comentar a iterar. Normalmente se suele declarar e inicializar aqu una variable de control. expresin es cualquier expresin lgica (con valor booleano), que se evaluar antes de cada una de las iteraciones del bucle para saber si se debe entrar al cuerpo del bucle o no. Es decir, a cada vuelta del bucle, primero se comprueba esta expresin; si es verdadera, se ejecuta el cuerpo del bucle y se vuelve a iterar. SI es falsa, se sale del bucle. Esto equivale a decir que el cuerpo del bucle se ejecuta mientras esta expresin sea cierta. actualizacin es una orden cualquiera, que se ejecutar despus de haber ejecutado el cuerpo del bucle, y antes de volver a comprobar la condicin que pongamos como expresin. Normalmente se usa para ir cambiando el valor de la variable de control.

Cualquiera de los campos anteriores es opcional. Lo que siempre es obligatorio es poner siempre los dos signos de punto y coma dentro de los parntesis, incluso si no se pone nada ms. En cualquier caso, tras cerrar los parntesis hay que poner qu hay que repetir (el cuerpo del bucle), que de nuevo puede ser una sola orden, o un bloque. Ejemplos:
for(int i = 0; i < 10; i++) System.out.println(i); // Visualiza los nmeros del 0 al 9. int j = 10; // Si inicializo aqu, no lo tengo que hacer en el for. for(; j>=0; j--) System.out.println(i); // Visualiza los nmeros del 10 al 0. boolean repetir = true; for(;repetir;) // Equivale a while(repetir). { x *= 2; repetir = (x < 100); // Si x<100, asigna true a repetir. // Si no, le asigna false. } for(int n=0; n<10; n++); // Se repite 10 veces, pero no hace nada // porque no hay cuerpo. Ojo al punto y coma. for(;;) System.out.println(Mtenme); // Bucle infinito.