Código Fuente Basico.java

public class Basico {

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

}

}

Programa Java Introducción Basico.java

La primer característica 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 definición de una Clase llamada Basico, nótese que ambos nombres coinciden en su sintaxis, esto es, ambos inician con letra mayúscula lo cual es una convención llevada acabo para la definición 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 variación de calificadores será descrito posteriormente cuando se aborde el tema de librerías ("packages") donde es de influencia su uso.

Dentro de la definición de la Clase se deben incluir los respectivos métodos que podrán ser invocados. En el caso del programa Basico.java únicamente es definido el método main, dicho método es invocado por "default" al ejecutarse el programa (Clase).

Nótese que el método inicia con letra minúscula, esta es otra convención utilizada para diferenciarse de las distintas clases. La definición del método indica lo siguiente:

Primeramente se definen los calificadores del método en este caso siendo public static

Posteriormente se define el valor de retorno del método: void, lo cual indica que no será retornado ningún valor

Le sigue el nombre del método: main Dentro de paréntesis se incluyen los parámetros de entrada para el método (String

args[]). Finalmente la Clase/Método System.out.println envía un mensaje a la pantalla

Metodo principal main

El método principal main de una Clase Java es inalterable, es este sentido inalterable se refiere a sus características:

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 parámetro 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 método main dentro de toda Clase Java, dicho método representa el único mecanismo automático para realizar tareas al invocarse una Clase, esto es, al momento de ejecutarse determinada Clase siempre será ejecutado todo el contenido dentro de dicho método.

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. Nótese que el comando java recibe el nombre de la Clase sin la extensión .class.

Librerías ("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 organización de código; al igual que otros lenguajes, esta organización se lleva acabo mediante librerías, denominadas "packages" en el mundo Java .

Java toma una perspectiva nueva respecto a otros lenguajes, adoptando una convención a partir de Dominios en Internet, esto es, nuestros programas y por ende librerías ("packages") estarán basados en el nombre de la empresa/dominio para la cual son diseñados, lo anterior permite evitar la tan conocida Colisión de Nombres en Software.

Esta Colisión 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/Librería sea única , puesto que es una característica de Dominios en Internet.

Para que puedan ser asignadas Clases a determinadas librerías es necesario indicar dicha Librería("Package") en la definición inicial de un programa, además de esto, es necesario crear una estructura de directorios para generar las determinadas Clases; lo anterior se ilustra mejor a través de un ejemplo:

Estructura de Directorios para utilizar Librerías ("Packages")

Para utilizar "Packages" en Java es necesario generar una estructura de directorios que lleven la misma secuencia de las librerías que desean diseñarse, observe:

+-com+- | +-osmosislatina+- | +-escritura+- | +-graficas+- | +-correo+- | +-errores+- | +-auxiliares+-

Lo anterior demuestra una estructura para las librerías del dominio com.osmosislatina, se debe mencionar que no existe ninguna restricción en el número de directorios anidados, esto es, es posible que existan librerías de 5 o 10 niveles de profundidad, esta sub-clasificación se va realizando en base a los requerimientos de las librerías y es dentro de cada sub-directorio donde son colocadas las distintas Clases.

Además de la generación de estos directorios, se debe incluir un calificador de la librería en el código fuente de cada Clase :

package com.osmosislatina.escritura;

Lo anterior sería incluido en todos los programas pertenecientes a la librería ("Package") com.osmosislatina.escritura, debe mencionarse que este calificador debe ser la primer declaración en todo programa Java (Salvo no vaya a ser incluido en librerías); recuerde que además de este calificador el programa debe estar colocado en la estructura de directorios correspondiente, lo anterior es sumamente importante al llevarse acabo la compilación para la generación de Byte-Code

Código Fuente Pantalla.java

La siguiente Clase define dos métodos 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 librería ("package") a la que será asignada el programa a través del vocablo package.

Se define la Clase con los respectivos métodos 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 método 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 sección será diseñado un programa que haga uso de esta librería ("package").

Utilización de Librerías ("Packages")

Para emplear Librerías("Packages") en un programa es necesario importarlas, esto es llevado acabo mediante el calificativo import como se demuestra a continuación :

import com.osmosislatina.graficas.Recuadro;

La declaración anterior permite que la clase Recuadro de la librería ("Package") com.osmosislatina.graficas este disponible en el programa en cuestión, las características del uso de import son las siguientes:

Se debe declarar al inicio de un programa, antes de la definición de la clase, aunque posterior a la definición de package (si existiese) .

Se pueden utilizar un numero ilimitado de import. Es posible importar todas las clases de una librería a través de un asterisco (*).

Código Fuente MandaPantalla.java

La siguiente Clase manda llamar métodos 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 librería ("package") a la que será asignada el programa a través del vocablo package.

Posteriormente se importan las Clases que serán utilizadas en el programa a través del vocablo import.

Se define el método main dentro del cual se genera una instancia de la Clase Pantalla (aquella importada) y sobre la que posteriormente se mandan llamar los distintos métodos a través de su referencia.

La compilación (Generación de Byte-Code) de esta Clase requiere que esta sea llevada acabo bajo el directorio raíz de la estructura de Clases, esto es, aunque esta Clase radique dentro del directorio com/osmosislatina/auxiliares es necesario llevar acabo la compilación desde la raíz (./com), lo anterior se debe a que esta Clase requiere ubicar (importar) las Clases de la Librería ("Package") com/osmosislatina/escritura; los detalles de esta rutina serán descritos en la sección de CLASSPATH.

Para ejecutar este programa también se requiere descender al directorio raíz de la librería ("Package"), razón que también esta relacionada con la variable CLASSPATH y será descrita a fondo en su sección.

Una vez acumuladas un número substancial de Clases en una Librería("Package") será necesario colocarlas en una estructura que permita una distribución fácil y práctica, esto es, si ha generado 100 o 500 clases sería muy impráctico distribuir la estructura de directorios a un tercero para ser utilizada, para este problema han sido diseñados 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 través de un solo archivo. Declarar dichas Clases de una manera más eficiente en la variable CLASSPATH.

En todo JDK/J2SE se incluye el comando jar el cual permite generar, observar y descomprimir archivos JAR; a continuación se describen estos tres casos.

Generación de Archivo JAR

Para generar un archivo JAR es necesario colocarse bajo el directorio raíz 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 extracción de un archivo JAR se describe a continuación.

Extracción de Archivo JAR

En ocasiones es conveniente extraer el contenido de un archivo JAR para llevar acabo modificaciones, esto se realiza a través 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 sección se describe como son utilizados estos archivos JAR en la compilación/ejecución de programas Java.

La Variable CLASSPATH.

Al utilizar Clases y Librerías en ambientes Java surge otro tema en lo que concierne a su ubicación: Cuales Clases/Librerías están disponibles al momento de Compilar/Ejecutar programas Java ? , la respuesta a esta pregunta es la conocida variable CLASSPATH.

A través de esta variable se indica donde residen las Clases/Librerías("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 también serán localizadas al invocar el JVM ("Java Virtual Machine").

Finalmente la ultima declaración en CLASSPATH (:.:) indica que toda estructura de directorios residente en el directorio actual de compilación/ejecución será accesible.

Modificar la Variable Ambiental CLASSPATH Para modificar el valor de la variable ambiental CLASSPATH en un sistema

Unix/Linux se utilizaría 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 utilizaría 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 modificación 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 librerías("packages")/clases que solo serán utilizadas ocasionalmente, por lo que modificar la variable CLASSPATH al nivel de ambiente sería innecesario, para esto pueden ser pasados parámetros 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 través del flag classpath o cp se indica que al momento de llevarse acabo la compilación de la Clase Conexion.java, sea cargado el archivo JAR postgresql.jar además 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 librerías("packages")/Clases al momento de ejecución.

Calificadores: Public, Private, Protected, Static y Final.

El uso de calificadores de acceso en Java tiene sus bases en el uso de librerías ("packages"), al ser diseñado un programa existen diversas funciones/métodos y variables dentro de éste, algunas de estas requerirán ser modificadas conforme incrementen las necesidades del programa, mientras otras permanecerán inmóviles, 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 diseño 300 clases que están siendo re-utilizadas por otros programas, sin embargo, se le ha solicitado una modificación radical a estos objetos base, cuales métodos/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, además de los calificadores de acceso que permiten restringir el uso de métodos/campos a determinadas situaciones, también existen otros calificadores que

afectan directamente la creación y uso de instancias por clase estos calificadores son static yfinal.

public : Acceso libre .

El uso del calificador public significa que toda definición será accesible de cualquier punto, ya sea un método, campo o clase. Su uso implica un acceso global, desde luego el uso de este calificativo en Clases que serán 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 cuestión, si se intenta accesar cualquier elemento de este tipo dentro de otra Clase será generado un error de compilación.

El calificador private suele utilizarse en Clases que serán 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 sección, 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/métodos definidos como protected en padre, pero no aquellos declarados como private en padre.

Ningún Calificador : Clase en Librería 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/método carente de calificador será accesible dentro de todas Clases pertenecientes a su misma librería("package").

static : Una sola instancia .

El uso del vocablo static ha venido siendo utilizado en los métodos 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 número de instancias generadas o bien invocar/llamar métodos 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 descripción anterior esta trivializada, sin embargo, conforme se avance en el presente curso serán ilustrados otros ejemplos con este mecanismo.

La segunda situación para el uso de static puede ser ejemplificada perfectamente a través del método main Java, el método main puede ser llamado automáticamente al invocarse la respectiva Clase debido a que no se encuentra asociado con ningún tipo de instancia, esto implica que su comportamiento siempre será el mismo independientemente de la instancia que realza su llamada.

Dos aspectos característicos 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 teoría del concepto static puede ser un poco difícil de digerir, sin embargo, como fue mencionado anteriormente, conforme avance el curso serán descritos diversos fragmentos de código para dejar en claro su uso.

final : Una sola instancia y definitiva.

El calificador final estrechamente relacionado con el uso de static implica una asignación ú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 definición única y como su nombre lo implica final.

Generalmente final es utilizado en aquellos elementos que no serán modificados al momento de ejecutarse ("Run-Time") un programa o clase , a través de final se asigna un valor que no podrá ser modificado bajo ninguna circunstancia al momento de ejecución ("Run-Time), en efecto logrando un nivel de eficiencia en ejecución.

De igual manera que la utilización de static el uso de final será ilustrado conforme se avanze en este curso.

Código 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 através del vocablo class. Es definido un método llamado analisis el cual retorna una respuesta en base a las

operaciones del condicional if/else; una característica de este método es que utiliza el calificativo static, esto se debe a que es llamado directamente del método principal main el cual también es static; debido a que el vocablo static es empleado en métodos que no requieren instancias, si se realiza un llamado hacia determinado método de uno static éste también deberá ser static, esto garantiza un posible error al invocar métodos estaticos.

Dentro del método principal (main) es invocado el método analisis en tres ocasiones, imprimiendo los respectivos resultados a pantalla.

Uso de llaves ({ }) en Ciclos.

Una característica 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 código, es importante señalar que esta sintaxis de no utilizar llaves ({ } ) es valida y muy común (Lamentablemente) .

Existe otra variación de if/else que agrupa las condicionales en una sola expresión :

if (expresion Boolean ? operación verdadera : operación falsa)

A continuación se describe un ejemplo empleando esta variación 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 método llamado trio el cual hace uso de la variante if/else; la expresión boolean es r < 10, si esta expresión resulta verdadera es ejecutada la operación r*3, caso contrario r*22.

Dentro del método principal main es invocado el método 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 ; condición de terminación ; iteración 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 condición de terminación para el ciclo, la cual esta

directamente relacionada con los valores iniciales. Finalmente, la última parte especifica como serán manipulados los valores iniciales

en cada iteración 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).

Código 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 clásica definición de class. Se define el método 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 características:

o Dos variables iniciales (primitivos) i y j. o La condición para terminar el ciclo es definida cuando el valor de la variable

i sea menor 5.o Cada iteración 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 iteración de ciclo.

*************************************************************************

Sintaxis del Ciclo while.

La Sintaxis empleada por el ciclo while es la siguiente:

while (condición de terminación)

Consta de un solo elemento que indica la condición de terminación para un Ciclo.

Código 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 cuestión. Se define el método 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 condición de terminación hasta que el valor de la variable d

sea asignado un valor mayor a 0.99; la d al final del numero indica un número (primitivo) del tipo double .

Dentro del ciclo, el valor de la variable es modificado con un numero aleatorio a través de la función Math.random (proporcionada en las Clases Base del JDK), que toma como valor de entrada un número (primitivo).

Es impreso a pantalla (vía System.out.println) el valor de la variable r. Código 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 Iteración 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 código en su método principal (main) descrito a continuación :

Se inicia un ciclo for con cien iteraciones empleando la variable i, cada iteración 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 múltiplo de 9 se interrumpe la iteración 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 iteración, 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 múltiplo de 10 se interrumpe la iteración actual debido al vocablo continue.

Código Fuente LabelFor.java

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

for(; true ;) { // Ciclo Infinito interno: // Definción 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 LabelFori = 0continue internoi = 1continue internoi = 2continuei = 3breaki = 4continue internoi = 5continue internoi = 6continue internoi = 7continue externoi = 8break 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 LabelWhileExterno Ciclo whilei = 1continuei = 2i = 3continue externoExterno Ciclo whilei = 4i = 5breakExterno Ciclo whilei = 6i = 7break 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 serán 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 definición de la linea default, cuyas instrucciones serán ejecutadas en caso que la variable del switch no coincida con los valores definidos.

Código 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 instrucción 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 declaración (case) era opcional, esto se debe a la posibilidad que exista más de un valor que deba ejecutar las mismas instrucciones, a continuación se describe este caso:

Código Fuente Meses2.java

public class Meses2 {

public static void main(String[] args) {

int mes = 10; int año = 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 ( ((año % 4 == 0) && !(año % 100 == 0)) || (año % 400 == 0) ) numDias = 29; else numDias = 28; break; } System.out.println("Numero de Dias = " + numDias); }}

Clase Meses2

En esta Clase el uso de switch varía, 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 errático, ya que al no indicarse se continúan 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 través 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.