Cdigo Fuente Basico.

java


public class Basico {


public static void main(String args[]) {
System.out.println("Un despliegue de Datos");
}


}
Programa Java Introduccin Basico.java
La primer caracterstica de un programa Java es que este debe definir una Clase que lleve
por nombre el mismo nombre del archivo fuente, en este caso el archivo Basico.java debe
incluir una definicin de una Clase llamada Basico, ntese que ambos nombres coinciden
en su sintaxis, esto es, ambos inician con letra mayscula lo cual es una convencin llevada
acabo para la definicin de Clases.
Para definir una Clase se utiliza el vocablo class as como un calificador de acceso, en este
caso se utiliza el calificador public, el uso y variacin de calificadores ser descrito
posteriormente cuando se aborde el tema de libreras ("packages") donde es de influencia
su uso.
Dentro de la definicin de la Clase se deben incluir los respectivos mtodos que podrn ser
invocados. En el caso del programa Basico.java nicamente es definido el mtodo main,
dicho mtodo es invocado por "default" al ejecutarse el programa (Clase).
Ntese que el mtodo inicia con letra minscula, esta es otra convencin utilizada para
diferenciarse de las distintas clases. La definicin del mtodo indica lo siguiente:
Primeramente se definen los calificadores del mtodo en este caso siendo public
static
Posteriormente se define el valor de retorno del mtodo: void, lo cual indica que no
ser retornado ningn valor
Le sigue el nombre del mtodo: main
Dentro de parntesis se incluyen los parmetros de entrada para el mtodo (String
args[]).
Finalmente la Clase/Mtodo System.out.println enva un mensaje a la pantalla
Metodo principal main
El mtodo principal main de una Clase Java es inalterable, es este sentido inalterable se
refiere a sus caractersticas:
Siempre debe incluir los calificadores : public y static.
Nunca puede retornar un valor como resultado, por ende, siempre debe indicar el
valor void como retorno.
Su parmetro de entrada siempre ser un arreglo de String's (String[]) el cual es
tomado de la linea de comandos o una fuente alterna.
Aunque no es un requerimiento definir el mtodo main dentro de toda Clase Java, dicho
mtodo representa el nico mecanismo automtico para realizar tareas al invocarse una
Clase, esto es, al momento de ejecutarse determinada Clase siempre ser ejecutado todo el
contenido dentro de dicho mtodo.
Para generar una Clase compilada (Byte-Code) se utiliza el comando javac :

$ javac Basico.java
Lo anterior genera un archivo llamado Basico.class; para ejecutar este Byte-Code es
empleado el comando java:

$ java Basico
Al invocar el comando anterior ser ejecutada la Clase Basico.class. Ntese que el comando java
recibe el nombre de la Clase sin la extensin .class.
Libreras ("Packages") y JAR's.
Conforme empieza a crecer un desarrollo de Software surge la necesidad de reutilizar
ciertos componentes que ya han sido escritos, as como dar cierta estructura para mantener
una organizacin de cdigo; al igual que otros lenguajes, esta organizacin se lleva acabo
mediante libreras, denominadas "packages" en el mundo Java .
Java toma una perspectiva nueva respecto a otros lenguajes, adoptando una convencin a
partir de Dominios en Internet, esto es, nuestros programas y por ende libreras
("packages") estarn basados en el nombre de la empresa/dominio para la cual son
diseados, lo anterior permite evitar la tan conocida Colisin de Nombres en Software.
Esta Colisin de Nombres se da cuando dos Clases llevan el mismo nombre y ambas
requieren ser utilizadas dentro de un programa en particular, empleando Dominios en
Internet se garantiza que el nombre de la Clase/Librera sea nica , puesto que es una
caracterstica de Dominios en Internet.
Para que puedan ser asignadas Clases a determinadas libreras es necesario indicar dicha
Librera("Package") en la definicin inicial de un programa, adems de esto, es necesario
crear una estructura de directorios para generar las determinadas Clases; lo anterior se
ilustra mejor a travs de un ejemplo:
Estructura de Directorios para utilizar Libreras ("Packages")
Para utilizar "Packages" en Java es necesario generar una estructura de directorios que
lleven la misma secuencia de las libreras que desean disearse, observe:

+-com+-
|
+-osmosislatina+-
|
+-escritura+-
|
+-graficas+-
|
+-correo+-
|
+-errores+-
|
+-auxiliares+-
Lo anterior demuestra una estructura para las libreras del dominio com.osmosislatina, se
debe mencionar que no existe ninguna restriccin en el nmero de directorios anidados,
esto es, es posible que existan libreras de 5 o 10 niveles de profundidad, esta sub-
clasificacin se va realizando en base a los requerimientos de las libreras y es dentro de
cada sub-directorio donde son colocadas las distintas Clases.
Adems de la generacin de estos directorios, se debe incluir un calificador de la librera en
el cdigo fuente de cada Clase :

package com.osmosislatina.escritura;

Lo anterior sera incluido en todos los programas pertenecientes a la librera ("Package")
com.osmosislatina.escritura, debe mencionarse que este calificador debe ser la primer
declaracin en todo programa Java (Salvo no vaya a ser incluido en libreras); recuerde
que adems de este calificador el programa debe estar colocado en la estructura de
directorios correspondiente, lo anterior es sumamente importante al llevarse acabo la
compilacin para la generacin de Byte-Code
Cdigo Fuente Pantalla.java
La siguiente Clase define dos mtodos que pueden ser utilizados para imprimir resultados a
pantalla:
La siguiente Clase debe ser colocada bajo la estructura de
directorios com/osmosislatina/escritura, en base a su ambiente
(Linux o Windows) por favor genere dicha estructura para colocar
esta Clase


package com.osmosislatina.escritura;

public class Pantalla {

public static void sinSalto(String s) {
System.out.print(s);
}

public static void conSalto(String s) {
System.out.println(s);
}

}

Primeramente se declara la librera ("package") a la que ser asignada el programa a
travs del vocablo package.
Se define la Clase con los respectivos mtodos sinSalto y conSalto.
NOTA: Recuerde que este programa debe residir dentro del directorio
com/osmosislatina/escritura/.
NOTA 2: Observe que esta Clase no posee el mtodo principal main.
Para compilar esta Clase basta ejecutar el comando:

$ javac Pantalla.java
Lo anterior genera el archivo de ByteCode : Panatalla.class. En la siguiente seccin ser
diseado un programa que haga uso de esta librera ("package").
Utilizacin de Libreras ("Packages")
Para emplear Libreras("Packages") en un programa es necesario importarlas, esto es
llevado acabo mediante el calificativo import como se demuestra a continuacin :


import com.osmosislatina.graficas.Recuadro;

La declaracin anterior permite que la clase Recuadro de la librera ("Package")
com.osmosislatina.graficas este disponible en el programa en cuestin, las caractersticas
del uso de import son las siguientes:
Se debe declarar al inicio de un programa, antes de la definicin de la clase, aunque
posterior a la definicin de package (si existiese) .
Se pueden utilizar un numero ilimitado de import.
Es posible importar todas las clases de una librera a travs de un asterisco (*).
Cdigo Fuente MandaPantalla.java
La siguiente Clase manda llamar mtodos definidos en la Clase Pantalla.java.
La siguiente Clase debe ser colocada bajo la estructura de
directorios com/osmosislatina/auxiliares, en base a su
ambiente (Linux o Windows) por favor genere dicha estructura para
colocar esta Clase

package com.osmosislatina.auxiliares;

import com.osmosislatina.escritura.*;

public class MandaPantalla {

public static void main(String args[]) {

Pantalla primera = new Pantalla();
primera.conSalto("Esto es un renglon CON salto de linea");
primera.conSalto("Esta linea tambien tiene salto");
primera.sinSalto("Linea Continua");
primera.sinSalto("Linea Continua");
primera.conSalto("Esta linea si tiene salto!");
primera.sinSalto("Termina sin salto");
System.out.println(" Se termina el uso de funciones");
}

}

Primeramente se declara la librera ("package") a la que ser asignada el programa a
travs del vocablo package.
Posteriormente se importan las Clases que sern utilizadas en el programa a travs
del vocablo import.
Se define el mtodo main dentro del cual se genera una instancia de la Clase
Pantalla (aquella importada) y sobre la que posteriormente se mandan llamar los
distintos mtodos a travs de su referencia.
La compilacin (Generacin de Byte-Code) de esta Clase requiere que esta sea
llevada acabo bajo el directorio raz de la estructura de Clases, esto es, aunque esta
Clase radique dentro del directorio com/osmosislatina/auxiliares es necesario
llevar acabo la compilacin desde la raz (./com), lo anterior se debe a que esta
Clase requiere ubicar (importar) las Clases de la Librera ("Package")
com/osmosislatina/escritura; los detalles de esta rutina sern descritos en la
seccin de CLASSPATH.
Para ejecutar este programa tambin se requiere descender al directorio raz de la
librera ("Package"), razn que tambin esta relacionada con la variable
CLASSPATH y ser descrita a fondo en su seccin.
Una vez acumuladas un nmero substancial de Clases en una Librera("Package") ser necesario
colocarlas en una estructura que permita una distribucin fcil y prctica, esto es, si ha generado
100 o 500 clases sera muy imprctico distribuir la estructura de directorios a un tercero para ser
utilizada, para este problema han sido diseados los archivos JAR ("Java Archives").
Archivos JAR ("Java Archives")
Una archivo JAR es simplemente un archivo comprimido que incluye una estructura de
directorios con Clases, lo anterior permite:
Distribuir/Utilizar Clases de una manera eficiente a travs de un solo archivo.
Declarar dichas Clases de una manera ms eficiente en la variable CLASSPATH.
En todo JDK/J2SE se incluye el comando jar el cual permite generar, observar y
descomprimir archivos JAR; a continuacin se describen estos tres casos.
Generacin de Archivo JAR
Para generar un archivo JAR es necesario colocarse bajo el directorio raz de la estructura
de directorios donde residen las Clases:


$ jar cvf osmosislatina.jar *

Al ejecutar el comando anterior se genera una archivo JAR llamado osmosislatina.jar
con todos los archivos .class que residen en la estructura de directorios.
Observar contenido de Archivo JAR
Para observar el contenido de un archivo JAR, se utiliza un comando similar:

$ jar tvf osmosislatina.jar
El comando anterior despliega el contenido del archivo JAR osmosislatina.jar; NOTA:
Este comando nicamente despliega el contenido, la extraccin de un archivo JAR se
describe a continuacin.
Extraccin de Archivo JAR
En ocasiones es conveniente extraer el contenido de un archivo JAR para llevar acabo
modificaciones, esto se realiza a travs del siguiente comando:

$ jar xvf osmosislatina.jar
El comando anterior genera una estructura de directorios con el contenido del archivo JAR
osmosislatina.jar. En la siguiente seccin se describe como son utilizados estos
archivos JAR en la compilacin/ejecucin de programas Java.
La Variable CLASSPATH.
Al utilizar Clases y Libreras en ambientes Java surge otro tema en lo que concierne a su
ubicacin: Cuales Clases/Libreras estn disponibles al momento de Compilar/Ejecutar
programas Java ? , la respuesta a esta pregunta es la conocida variable CLASSPATH.
A travs de esta variable se indica donde residen las Clases/Libreras("Packages") de
nuestro ambiente, en ella se definen los directorios base de Clases as como cualquier
archivo JAR que requiera ser cargado al compilar/ejecutar programas Java.
Para definir/alterar esta variable existen dos alternativas: Definirse al nivel de Sistema en
variables de ambientales o al tiempo de invocarse un comando Java, ya sea java o javac.
Observando la Variable Ambiental CLASSPATH
Para observar la variable CLASSPATH en un ambiente Unix/Linux se utiliza el siguiente
comando :


$ set | egrep CLASSPATH
CLASSPATH=/usr/local/jdk/lib/tools.jar:/root/mislibrerias/:.:
Para observar la variable CLASSPATH en un ambiente Windows NT/2000/XP se utiliza el
siguiente comando :

Seleccione:
Start- Settings -Control Panel y el icono System.

En Windows NT:
Seleccione el Tab Environment
En Windows 2000/XP :
Seleccione el Tab Advanced

Posteriormente entre en Variables de Entorno ("Environment Variables").
Localize "CLASSPATH" en las variables del usuario ("User Variables") y
variables de Sistema ("System Variables").
Como se puede observar en el despliegue anterior, los valores de la variable CLASSPATH
se encuentran separados por dos puntos (:) [ o punto y coma (;) para Windows], el valor de
CLASSPATH declarado anteriormente significa :
El archivo JAR llamado tools.jar bajo el directorio /usr/local/jdk/lib estar
accesible al compilar/ejecutar programas Java.
Las estructuras de directorios ubicados bajo /root/mislibrerias tambin sern
localizadas al invocar el JVM ("Java Virtual Machine").
Finalmente la ultima declaracin en CLASSPATH (:.:) indica que toda estructura
de directorios residente en el directorio actual de compilacin/ejecucin ser
accesible.
Modificar la Variable Ambiental CLASSPATH
Para modificar el valor de la variable ambiental CLASSPATH en un sistema
Unix/Linux se utilizara el siguiente comando:


$ export CLASSPATH=/root/osmosislatina.jar:$CLASSPATH

Para modificar el valor de la variable ambiental CLASSPATH en un sistema
Windows NT/2000/XP se utilizara el siguiente comando:


C:> set CLASSPATH=C:\osmosislatina.jar;%CLASSPATH%;.;

El comando anterior modifica el valor de la variable CLASSPATH agregando el
archivo JAR (osmosislatina.jar), el termino $CLASSPATH (%CLASSPATH% en
Windows) indica el valor previo de la variable, lo cual permite mantener los valores
pre-existentes.
Cabe mencionar que al modificar la variable CLASSPATH de esta manera, ser
nicamente el Shell existente el cual reflejar estos cambios, esto es, si usted posee
otros programas que hacen uso de Java ser necesario modificar el valor de
CLASSPATH al nivel de sistema, lo anterior en Sistemas Unix se hace modificando
el archivo /etc/profile o el perfil del usuario ~/.bashrc, de la siguiente manera:


CLASSPATH="/usr/local/mislibrerias"
export CLASSPATH

La modificacin de la variable CLASSPATH a nivel de sistema para ambientes
Windows es llevada acabo de la siguiente manera:

Seleccione:
Start- Settings -Control Panel y el icono System.

En Windows NT:
Seleccione el Tab Environment
En Windows 2000/XP :
Seleccione el Tab Advanced

Posteriormente entre en Variables de Entorno ("Environment Variables").
Localize o genere la variable "CLASSPATH" en variables de Sistema
("System Variables").
Utilizando la variable CLASSPATH al invocarse java o javac y otro comando.
En ocasiones es necesario cargar/ubicar ciertas libreras("packages")/clases que solo sern
utilizadas ocasionalmente, por lo que modificar la variable CLASSPATH al nivel de
ambiente sera innecesario, para esto pueden ser pasados parmetros al tiempo de invocar
los comandos java o javac :

$ javac -classpath "$CLASSPATH:.:/lib/postgresql.jar" Conexion.java
[Linux]

C:> javac -classpath "%CLASSPATH%;C:\osmosislatina.jar;.;
Conexion.java [Windows]
o

$ javac -cp "$CLASSPATH:.:/lib/postgresql.jar" Conexion.java [Linux]

C:> javac -cp "%CLASSPATH%;C:\osmosislatina.jar;.; Conexion.java
[Windows]
A travs del flag classpath o cp se indica que al momento de llevarse acabo la
compilacin de la Clase Conexion.java, sea cargado el archivo JAR postgresql.jar
adems del valor actual ($CLASSPATH en Linux o %CLASSPATH% en Windows) de la variable
ambiental CLASSPATH.
Este mismo mecanismo puede ser utilizado para los diversos comandos Java, lo cual
permite ubicar/cargar libreras("packages")/Clases al momento de ejecucin.
Calificadores: Public, Private, Protected, Static y Final.
El uso de calificadores de acceso en Java tiene sus bases en el uso de libreras ("packages"),
al ser diseado un programa existen diversas funciones/mtodos y variables dentro de ste,
algunas de estas requerirn ser modificadas conforme incrementen las necesidades del
programa, mientras otras permanecern inmviles, la importancia de estos cambios requiere
que sean utilizados calificadores para permitir/negar el acceso a ciertos segmentos del
programa, analicemos el siguiente caso:
Usted ya diseo 300 clases que estn siendo re-utilizadas por otros programas, sin embargo,
se le ha solicitado una modificacin radical a estos objetos base, cuales mtodos/campos de
estas 300 Clases puede modificar sin quebrantar los otros programas que hacen uso de estas
? Aqu puede surgir un serio problema sino han sido utilizados los calificadores de acceso
acordemente.
Ahora bien, adems de los calificadores de acceso que permiten restringir el uso de
mtodos/campos a determinadas situaciones, tambin existen otros calificadores que
afectan directamente la creacin y uso de instancias por clase estos calificadores son
static yfinal.
public : Acceso libre .
El uso del calificador public significa que toda definicin ser accesible de cualquier punto,
ya sea un mtodo, campo o clase. Su uso implica un acceso global, desde luego el uso de
este calificativo en Clases que sern modificadas constantmente es fuertemente
desalentado, ya que puede quebrantar dependencias forjadas en versiones previas.
private : Solo en la misma Clase .
El calificador private indica que dicho componente ser accesible nicamente dentro de la
Clase en cuestin, si se intenta accesar cualquier elemento de este tipo dentro de otra Clase
ser generado un error de compilacin.
El calificador private suele utilizarse en Clases que sern modificadas continuamente, esto
permite evitar futuros quebrantos en otras Clases como fue mencionado al inicio.
protected : Clases Heredadas y misma Clase.
El uso de protected es utilizado bajo los conceptos de Herencias ("Inheritance"), aunque
este tema ser descrito en otra seccin, mediante protected es posible accesar elementos de
la Clase Hereditaria ("Inherited"), aunque no aquellos que utilicen el calificador private.
En otras palabras, si determinada Clase hijo hereda ("inherit") el comportamiento de una
Clase padre, la Clase hijo tendr acceso a todos aquellos campos/mtodos definidos como
protected en padre, pero no aquellos declarados como private en padre.
Ningn Calificador : Clase en Librera y misma Clase .
Finalmente, cuando no es empleado ninguno de los calificadores de acceso mencionados
anteriormente los elementos son considerados amigables, esto implica que todo
campo/mtodo carente de calificador ser accesible dentro de todas Clases pertenecientes a
su misma librera("package").
static : Una sola instancia .
El uso del vocablo static ha venido siendo utilizado en los mtodos principales (main) de
los programas escritos anteriormente, su uso esta relacionado directamente al uso de
instancias en Clases; en ocasiones es necesario o conveniente generar elementos que tomen
un mismo valor para cualquier nmero de instancias generadas o bien invocar/llamar
mtodos sin la necesidad de generar instancias, y es bajo estas dos circunstancias que es
empleado el calificador static.
El primer uso de static puede ser poco evidente, pero tomemos el caso de la Clase
mencionada al inicio de este curso de una Lampara, en caso de requerirse un elemento
como un apagador pudiera resultar sobrado generar una instancia para cada Lampara, en
este caso pudiera ser restringido un apagador a una sola instancia mediante el calificador
static permitiendo que dicho elemento sea utilizado por todas las instancias de Lampara
ah generadas; desde luego la descripcin anterior esta trivializada, sin embargo, conforme
se avance en el presente curso sern ilustrados otros ejemplos con este mecanismo.
La segunda situacin para el uso de static puede ser ejemplificada perfectamente a travs
del mtodo main Java, el mtodo main puede ser llamado automticamente al invocarse la
respectiva Clase debido a que no se encuentra asociado con ningn tipo de instancia, esto
implica que su comportamiento siempre ser el mismo independientemente de la instancia
que realza su llamada.
Dos aspectos caractersticos de utilizar el calificador static en un elemento Java son los
siguientes :
No puede ser generada ninguna instancia (Uso de new) de un elemento static puesto
que solo existe una instancia.
Todos los elementos definidos dentro de una estructura static deben ser static ellos
mismos , o bien, poseer una instancia ya definida para poder ser invocados.
NOTA: Lo anterior no implica que no puedan ser generadas instancias dentro de un
elemento static; no es lo mismo llamar/invocar que crear/generar.
La teora del concepto static puede ser un poco difcil de digerir, sin embargo, como fue
mencionado anteriormente, conforme avance el curso sern descritos diversos fragmentos
de cdigo para dejar en claro su uso.
final : Una sola instancia y definitiva.
El calificador final estrechamente relacionado con el uso de static implica una
asignacin nica y definitiva al elemento de una clase. A diferencia de static que implica
una sola instancia, el termino final lleva dicha instancia a una definicin nica y como su
nombre lo implica final.
Generalmente final es utilizado en aquellos elementos que no sern modificados al
momento de ejecutarse ("Run-Time") un programa o clase , a travs de final se asigna un
valor que no podr ser modificado bajo ninguna circunstancia al momento de ejecucin
("Run-Time), en efecto logrando un nivel de eficiencia en ejecucin.
De igual manera que la utilizacin de static el uso de final ser ilustrado conforme se
avanze en este curso.


Cdigo Fuente Condicional.java


public class Condicional {

static int analisis(int prueba, int objetivo) {
int resultado = 0;

if(prueba > objetivo)
resultado = +1;
else if(prueba < objetivo)
resultado = -1;
else
resultado = 0; // Prueba igual a Objetivo

return resultado;
}

public static void main(String[] args) {
System.out.println(analisis(7, 3));
System.out.println(analisis(3, 7));
System.out.println(analisis(7, 7));

}

}

Clase Condicional.java
Primeramente se declara la Clase atravs del vocablo class.
Es definido un mtodo llamado analisis el cual retorna una respuesta en base a las
operaciones del condicional if/else; una caracterstica de este mtodo es que utiliza
el calificativo static, esto se debe a que es llamado directamente del mtodo
principal main el cual tambin es static; debido a que el vocablo static es
empleado en mtodos que no requieren instancias, si se realiza un llamado hacia
determinado mtodo de uno static ste tambin deber ser static, esto garantiza
un posible error al invocar mtodos estaticos.
Dentro del mtodo principal (main) es invocado el mtodo analisis en tres
ocasiones, imprimiendo los respectivos resultados a pantalla.
Uso de llaves ({ }) en Ciclos.
Una caracterstica del ciclo if/else as como los otros ciclos disponibles en Java es el uso de
llaves { }, en el ejemplo anterior pudo notar que no fueron utilizadas llaves { } para
delimitar las condicionales, al no emplearse este mecanismo, se asume que el ciclo o
condicional tendr efecto nicamente en la linea contigua a su inicio.Aunque es
recomendable utilizar llaves ({ } ) para incrementar la legibilidad del cdigo, es importante
sealar que esta sintaxis de no utilizar llaves ({ } ) es valida y muy comn
(Lamentablemente) .
Existe otra variacin de if/else que agrupa las condicionales en una sola expresin :
if (expresion Boolean ? operacin verdadera : operacin falsa)
A continuacin se describe un ejemplo empleando esta variacin de if/else.
Codigo Fuente Tercia.java


public class Tercia {
public static int trio(int r) {
return r < 10 ? r*3 : r*22;
}
public static void main(String args[]) {
System.out.println(trio(2));
System.out.println(trio(20));
}
}

Clase Tercia
Es definido un mtodo llamado trio el cual hace uso de la variante if/else; la
expresin boolean es r < 10, si esta expresin resulta verdadera es ejecutada la
operacin r*3, caso contrario r*22.
Dentro del mtodo principal main es invocado el mtodo trio en dos ocasiones,
enviando a pantalla los respectivos resultados.

Sintaxis del Ciclo for.
La Sintaxis empleada por el ciclo for es la siguiente:
for (valores de entrada ; condicin de terminacin ; iteracin
por ciclo)
Las tres partes del ciclo se encuentran separadas por ; (punto y coma)
La primer parte del ciclo especifica valores previo a su inicio.
La segunda parte indica la condicin de terminacin para el ciclo, la cual esta
directamente relacionada con los valores iniciales.
Finalmente, la ltima parte especifica como sern manipulados los valores iniciales
en cada iteracin del ciclo.
Cada parte del ciclo debe incluir al menos un elemento, a la cual es posible agregar otros
elementos a partir de una , (coma).
Cdigo Fuente PruebaFor.java

public class PruebaFor {

public static void main(String[] args) {
for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
System.out.println("i= " + i + " j= " + j);
}
}
}

Clase PruebaFor.
Se inicia este programa con la clsica definicin de class.
Se define el mtodo principal ( main ), el uso de corchetes ([]) al lado de la Clase
String indica un Arreglo de String's.
Se define el ciclo for con las siguientes caractersticas:
o Dos variables iniciales (primitivos) i y j.
o La condicin para terminar el ciclo es definida cuando el valor de la variable
i sea menor 5.
o Cada iteracin de ciclo el valor de la variable i debe ser incrementado en uno
(++) y el valor de j debe ser igualado a dos veces el valor de i.
Dentro del Ciclo se utiliza la Clase System.out.println para imprimir los valores
de las variables i y j en cada iteracin de ciclo.
*************************************************************************
Sintaxis del Ciclo while.
La Sintaxis empleada por el ciclo while es la siguiente:
while (condicin de terminacin)
Consta de un solo elemento que indica la condicin de terminacin para un Ciclo.
Cdigo Fuente PruebaWhile.java

public class PruebaWhile {
public static void main(String[] args) {
double r = 0;
while(r < 0.99d) {
r = Math.random();
System.out.println(r);
}
}
}
Clase PruebaWhile.
Se inicia este programa definiendo la Clase en cuestin.
Se define el mtodo principal ( main ), el uso de corchetes ([]) al lado de la Clase
String indica un Arreglo de String's.
Se define un primitivo del tipo double con valor inicial de 0 (cero).
El ciclo while utiliza la condicin de terminacin hasta que el valor de la variable d
sea asignado un valor mayor a 0.99; la d al final del numero indica un nmero
(primitivo) del tipo double .
Dentro del ciclo, el valor de la variable es modificado con un numero aleatorio a
travs de la funcin Math.random (proporcionada en las Clases Base del JDK), que
toma como valor de entrada un nmero (primitivo).
Es impreso a pantalla (va System.out.println) el valor de la variable r.
Cdigo Fuente BreakYContinue.java

public class BreakYContinue {

public static void main(String[] args) {

for(int i = 0; i < 100; i++) {
if(i == 74) break; // Fuera de Ciclo
if(i % 9 != 0) continue; // Siguiente Iteracin
System.out.println(i);
}
int i = 0;

// Un ciclo "infinito":
while(true) {
i++;
int j = i * 27;
if(j == 1269) break; // Fuera del Ciclo
if(i % 10 != 0) continue; // Regreso al Inicio del Ciclo
System.out.println(i);
}

}

}
Clase BreakYContinue
La Clase nicamente contiene cdigo en su mtodo principal (main) descrito a continuacin
:
Se inicia un ciclo for con cien iteraciones empleando la variable i, cada iteracin es
impreso el valor la variable a pantalla, salvo los siguientes casos:
o Si el valor de la variable i equivale a 74 se termina todo el ciclo debido al
vocablo break.
o Si la variable i no es mltiplo de 9 se interrumpe la iteracin actual debido
al vocablo continue.
Antes de iniciarse un ciclo while se reinicializa la variable i a cero.
Dentro del ciclo se imprimen los valores de la variable i en cada iteracin, excepto
en los siguientes casos:
o Si el valor de la variable j equivale a 1269 se termina todo el ciclo debido al
vocablo break.
o Si la variable i no es mltiplo de 10 se interrumpe la iteracin actual debido
al vocablo continue.
Cdigo Fuente LabelFor.java

public class LabelFor {
public static void main(String[] args) {
int i = 0;
externo: // Definicn de Label

for(; true ;) { // Ciclo Infinito
interno: // Defincin de Label

for(; i < 10; i++) {
prt("i = " + i);

if(i == 2) {
prt("continue");
continue;
}

if(i == 3) {
prt("break");
i++; // Incrementar antes del "Break"
break;
}

if(i == 7) {
prt("continue externo");
i++; // Incrementar antes del "Label"
//
continue externo;
}

if(i == 8) {
prt("break externo");
break externo;
}

for(int k = 0; k < 5; k++) {
if(k == 3) {
prt("continue interno");
continue interno;
}

}

}

}

}

static void prt(String s) {
System.out.println(s);
}

}
Resultados de Ejecutar Clase LabelFor
Los resultados de esta Clase son los siguientes:
$ java LabelFor
i = 0
continue interno
i = 1
continue interno
i = 2
continue
i = 3
break
i = 4
continue interno
i = 5
continue interno
i = 6
continue interno
i = 7
continue externo
i = 8
break externo
Codigo Fuente LabelWhile.java

public class LabelWhile {

public static void main(String[] args) {
int i = 0;
externo:

while(true) {
prt("Externo Ciclo while");

while(true) {
i++;
prt("i = " + i);

if(i == 1) {
prt("continue");
continue;
}

if(i == 3) {
prt("continue externo");
continue externo;
}

if(i == 5) {
prt("break");
break;
}

if(i == 7) {
prt("break externo");
break externo;

}

}

}

}

static void prt(String s) {
System.out.println(s);
}
}
Resultados de Ejecutar Clase LabelWhile
Los resultados de esta Clase son los siguientes:
$ java LabelWhile
Externo Ciclo while
i = 1
continue
i = 2
i = 3
continue externo
Externo Ciclo while
i = 4
i = 5
break
Externo Ciclo while
i = 6
i = 7
break externo
Sintaxis del switch.
La Sintaxis empleada por un switch es la siguiente:
switch (variable) {
case : Instrucciones : break;
case : Instrucciones : break;
case : Instrucciones : break;
case : Instrucciones : break;
case : Instrucciones : break;
default : Instrucciones ;
Dada una variable de entrada esta se define seguido del vocablo switch.
Se abre una llave para iniciar los posibles valores que pueda tomar dicha variable.
Los juegos de valores son iniciados con case seguido del posible valor de la
variable, posteriormente es definido un juego de instrucciones que sern ejecutados
en caso de corresponder con el valor de la variable y finalmente (opcional) se utiliza
vocablo break para salir de ciclo case.
Un valor opcional es la definicin de la linea default, cuyas instrucciones sern
ejecutadas en caso que la variable del switch no coincida con los valores definidos.
Cdigo Fuente Meses.java

public class Meses {
public static void main(String[] args) {
int month = 8;
switch (month) {
case 1: System.out.println("Enero"); break;
case 2: System.out.println("Febrero"); break;
case 3: System.out.println("Marzo"); break;
case 4: System.out.println("Abril"); break;
case 5: System.out.println("Mayo"); break;
case 6: System.out.println("Junio"); break;
case 7: System.out.println("Julio"); break;
case 8: System.out.println("Agosto"); break;
case 9: System.out.println("Septiembre"); break;
case 10: System.out.println("Octubre"); break;
case 11: System.out.println("Noviembre"); break;
case 12: System.out.println("Diciembre"); break;
}
}
}
Clase Meses
Se define un primitivo con valor de 8, el cual es utilizado como variable para un
switch.
Dentro del switch son definidos valores del 1 al 12, los cuales tienen como
instruccin imprimir a pantalla el valor del mes correspondiente.
Cuando se describi la Sintaxis de un switch se mencion que el uso de break al final de
cada declaracin (case) era opcional, esto se debe a la posibilidad que exista ms de un
valor que deba ejecutar las mismas instrucciones, a continuacin se describe este caso:
Cdigo Fuente Meses2.java

public class Meses2 {
public static void main(String[] args) {

int mes = 10;
int ao = 2002;
int numDias = 0;

switch (mes) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
numDias = 31;
break;
case 4:
case 6:
case 9:
case 11:
numDias = 30;
break;
case 2:
if ( ((ao % 4 == 0) && !(ao % 100 == 0))
|| (ao % 400 == 0) )
numDias = 29;
else
numDias = 28;
break;
}
System.out.println("Numero de Dias = " + numDias);
}
}
Clase Meses2
En esta Clase el uso de switch vara, ya que son agrupados distintos valores, al omitir el uso
del vocablo break; el uso de break en un switch es critico ya que al no ser definido puede
ocasionar un comportamiento errtico, ya que al no indicarse se continan evaluando los
distintos valores restantes en un switch, posiblemente causando un comportamiento no
deseado.
Finalmente, vale mencionar que las datos que se puede evaluar a travs de un switch son
solo primitivos, esto es, no se puede definir un juego de String's y comparar sus valores,
para este tipo de situaciones (String u otro Objeto) se requiere usar condicionales if/else
anidadas.