curso Basico java

Curso Java BásicoM4lote

El Proceso de Abstracción, Lenguajes Computacionales y Objetos.Todo lenguaje de programación ofrece un proceso de abstracción sobre un concepto extraído del mundo real, en otras palabras, un lenguaje permite un mapeo entre un problema espacial(real) hacia uno maquinal que será aquel ejecutado por una computadora. Es en esta capacidad de abstracción es que reside la facilidad/complejidad de generar programas funcionales capaces de resolver el problema espacial.El lenguaje ensamblador es una abstracción de la maquina ejecutora ("procesador"); lenguajes como Fortran, Basic y C son abstracciones de este mismo lenguaje ensamblador, sin embargo, aunque estos últimos ofrecen un avance sobre el lenguaje ensamblador, estos aún requieren de procesos de abstracción considerables.Lo anterior produce programas que son difíciles de escribir y actualizar por la simple razón que el problema espacial dista en grandes proporciones del mapeo maquinal; frente a estas deficiencias han surgido lenguajes más apegados al problema real tales como: PROLOG donde todo problema es mapeado a una cadena de decisiones o LISP donde todo problema es convertido a listas.Aquí es donde los lenguajes orientados a objetos salen a relucir, esto se debe a que permiten llevar acabo un mapeo más directo con el problema espacial(real). Allan Kay, describió las 5 principales características de Smalltalk, uno de los primeros lenguajes orientados a objetos y uno de los lenguajes en los cuales esta basado Java:

• Todo es un objeto: Considere un objeto una variable especial, no solamente guarda datos, sino también se pueden hacer solicitudes a este Objeto en sí. En teoría, cualquier elemento en el problema espacial(real) (edificios, servicios, automóviles, u otra entidad) puede ser representado como un objeto en un programa.

• Un programa es un conjunto de Objetos, enviándose mensajes entre sí : Para realizar una solicitud a un Objeto es necesario enviarle un mensaje. Concretamente se puede pensar que un mensaje es una solicitud para llamar una función que pertenece a cierto objeto.

• Cada Objeto tiene su memoria, conformada por otros Objetos : En otras palabras, es posible generar un tipo de Objeto nuevo agrupando Objetos existentes. De esta manera se pueden armar estructuras complejas en un programa, escondidas detrás de la simplicidad de Objetos.

• Todo Objeto tiene su Tipo: En este sentido Tipo se refiere a Clase, donde cada Objeto es una instancia de una Clase en cuestión. La característica más importante de una Clase es el tipo de mensajes que pueden ser enviados a ella.

• Todo Objeto de un mismo tipo puede recibir los mismos mensajes : Esto implica que si un Objeto es del tipo Circulo, un Objeto del tipo Figura será capaz de recibir mensajes de Circulo, puesto que un Circulo es una Figura. Este concepto forma parte medular de todo lenguaje orientado a Objetos y será explorado en una sección especifica de este curso.

En la gráfica anterior se puede observar una Clase conformada por una Lámpara (problema espacial real) a la cual pueden ser enviados distintos mensajes tales como: prender, apagar, girar y cambiar; para crear un Objeto de esta Clase y ser utilizado dentro de un programa es necesario generar una instancia del mismo, esto se demuestra a continuación:

1


Lampara candil = new Lampara();candil.prender();

El primer renglón genera una instancia de la Clase Lampara la cual es asignada a la referencia candil; en la segunda linea, a través de esta referencia se manda llamar el método prender() definido en la misma Clase; a través de referencias es posible generar distintos Objetos del mismo tipo cada uno con su propio comportamiento:

Lampara candil = new Lampara();Lampara manual = new Lampara(); Lampara jardin = new Lampara();candil.prender(); candil.girar();manual.apagar();jardin.prender();jardin.elevar();candil.apagar();

Lo anterior demuestra una de las principales características de los lenguajes orientados a Objetos, sin embargo, a continuación se describen las características especificas del Lenguaje Java y porque es considerado uno de los más avanzados en su ramo.Java y sus Características Entre los lenguajes orientados a Objetos hoy en día Java figura entre los más utilizados comparado con sus homólogos, pre-aparición de Java el lenguaje C++ se encontraba en la cúspide para desarrollos de Software con orientación a Objetos, sin embargo, Java ha venido suplantando su uso debido a dos características muy especificas que C++ no ofrece.

Interoperabilidad de Plataforma Esta característica forma parte del lema Java: "Write once, run everywhere" (Escríbalo una vez, ejecútelo en todos lados), a continuación se ilustra este concepto.

El proceso de creación es muy similar a la de otros lenguajes: una vez creado el Código Fuente es necesario compilarlo para generar un binario, este binario denominado Byte-Code en Java lleva por extensión .class, sin embargo, a diferencia de otros lenguajes este binario (Byte-Code) puede ser ejecutado en diversas plataformas obteniéndose el mismo resultado final.Esta interoperabilidad de ejecución se debe a que el Byte-Code es ejecutado en una maquina virtual llamada "Java Virtual Machine", es a través de este componente que se logra una ejecución idéntica en distintos ambientes.

Hoy en día, existen diversos JVM("Java Virtual Machines") para distintas plataformas y ambientes que oscilan desde los Sistemas Operativos Linux,Solaris,Windows,HP-UX hasta productos como Bases de Datos

2


Oracle y Servidores de Aplicaciones BEA; esto permite que código escrito en Java pueda ser ejecutado en cualquier ambiente produciéndose los mismos resultados.

Recolección de Basura ("Garbage Collection")En la sección anterior se pudo observar como son generadas distintas instancias de Objetos a través de una referencia, sin embargo, el uso de esta metodología trae consigo otro pregunta : Que se hace con estas instancias una vez que ya no son utilizadas ? La importancia de este concepto se debe al uso de memoria en una computadora, es lógico que estas instancias de Objetos requieren memoria ("RAM") para mantener su información, ahora bien, también tiene sentido asumir que la memoria ("RAM") es limitada en todo sistema, esto trae consigo el problema denominado "fuga de memoria" ("memory leak").

Si alguna vez ha programado en el lenguaje C++ debe estar familiarizado con este concepto, el cual significa que los recursos de memoria ("RAM") han sido agotados en el sistema. Suponga que ha diseñado un programa que invoca la creación de miles de instancias , eventualmente su memoria ("RAM") puede fugarse si no ha tomado las precauciones necesarias para deshacerse/destruir estas instancias de Objetos.

En el mundo Java, esta administración explicita de instancias de Objetos no es necesaria debido al proceso de "Garbage Collection"; este mecanismo a través del JVM ("Java Virtual Machine") inspecciona constantemente la memoria empleada por Java, lo cual le permite ir eliminando las instancias de Objetos que han dejado de ser utilizadas en un programa, en el proceso despreocupándose de la destrucción de Objetos.

Aunque el concepto de recolección de basura ("Garbage Collection") posee una infinidad de detalles en su fondo, es conveniente saber que este proceso es llevado automáticamente por Java, y que es una facilidad no ofrecida en otros lenguajes como C++

JDK/J2SE.JDK ("Java Development Kit") y J2SE ("Java 2 Standard Edition") son nombres para el mismo componente utilizado en ambientes Java, el cual agrupa las diversas funcionalidades necesarias para desarrollar programas Java.Hoy en día, existen JDK's/J2SE para diversos ambientes y plataformas, los cuales ofrecen lo siguiente:

• Un compilador Java, capaz de generar Byte-Code.• Un JVM ("Java Virtual Machine"), capaz de ejecutar Byte-Code.• Un conjunto de Clases base utilizadas para generar programas Java.• Otras utilerías para administrar código escrito en Java.

Para este curso se hace uso del JDK/J2SE de Sun Microsystems , aunque claro esta, cualquier programa generado en este JDK puede ser ejecutado otros ambientes, al igual que programas compilados en otros JDK's/J2SE pueden ser ejecutados en este ambiente. El conjunto de Clases base proporcionadas por el JDK/J2SE incluyen clases de uso común tales como : Manipulación de String's, Fechas y Números así como todas las funcionalidades base esperadas de un lenguaje computacional como: Ordenamiento y manipulación de Arreglos, Operaciones matemáticas complejas (Trigonométricas y Exponenciales) y escritura/lectura de "Streams".Además de estas Clases base, el JDK/J2SE posee otra serie de Clases especializadas que también ofrecen la base para la creación de otros componentes Java que incluyen : Applets, Objetos CORBA , Fragmentos Auditivos, Soporte de Criptografía (Seguridad) y Manipulación de XML entre otras funcionalidades.Aunado a las Clases base, el JDK/J2SE incluye una serie de ejecutables utilizados para diversas tareas como : Creación de ejecutables (Byte-Code), generación de documentación, creación de

3


"Stubs" y "Skeletons" a través de IDL e inclusive una implementación de un ORB ("Object Request Broker") para interactuar con ambientes CORBA, entre otros ejecutables.La estructura de directorios del JDK/J2SE es la siguiente: JDK 1.4.2 ___________|_________________ | | | bin lib jre | | ________|__________java* tools.jar | | javac* dt.jar bin libjavap* | ________ ___|___ _________ ________ _______ javah* java* | | | | | | javadoc* rt.jar ext security i386 applet fonts charsets.jar | / \

| / \ localedata.jar server client

Como se puede observar, la estructura se encuentra dividida en tres grandes partes : • bin: Incluye los ejecutables para la generación de programas Java.• lib: Contiene las librerías (Clases) base empleadas en la generación de la gran mayoría de

programas Java.• jre: Incluye el ambiente necesario para ejecutar programas Java, el cual a su vez se

encuentra sub-dividido en distintos directorios.Dependiendo de la manera en que haya instalado la documentación del JDK, se recomienda observarla en estos momentos para que se familiarice con sus Clases Base.

Un Programa Java. Para entrar en materia es necesario escribir nuestro primer programa Java, el cual ilustra la sintaxis así como estructura de un programa básico.

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

4


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 .

5


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:

• Generación de Librerías ("Packages") .

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

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.

6

http://javabasico.osmosislatina.com/curso/progbasico/genpack.htm

http://javabasico.osmosislatina.com/curso/progbasico/usopack.htm


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


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;

7


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").

8


• Generación de 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.

9

http://javabasico.osmosislatina.com/curso/progbasico/jars.htm


• Utilización de la Variable CLASSPATH .

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%;.;

10

http://javabasico.osmosislatina.com/curso/progbasico/classp.htm


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 :

11


$ 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.

12


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.

13


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.

Objetos y Primitivos. Al diseñar sus primeros programas en Java, pudo notar que todo gira alrededor de instancias de Objetos que son manipuladas a través de referencias:

Lampara candil = new Lampara();candil.prender();

Al utilizar referencias en Java estas pueden ser inicializadas sin que pertenezcan a ninguna instancia de Objeto:

String let;

La declaración anterior genera una referencia, sin embargo, esta no es asociada con ninguna instancia de Objeto, para llevar acabo este proceso es necesario utilizar el vocablo new.

String let = new String("Algo sencillo")

La declaración anterior no solo genera una instancia nueva de la Clase String, sino le asigna un valor inicial ("Algo sencillo") el cual es asignado a la referencia let; este mecanismo de agregar valores al generar una instancia es llevada acabo a través de métodos denominados constructores los cuales serán descritos posteriormente. El hecho de generar instancias de objetos es un proceso involucrado ( hablando en términos computacionales mas no en sintaxis ) , es por esto que Java ofrece un mecanismo simplístico para definir estructuras de datos como alternativa a utilizar Clases/Objetos, dichas estructuras son conocidas como primitivos.Aunque estrictamente hablando un primitivo no es una clase a través de un primitivo se facilita el uso de valores comúnmente utilizados en lenguajes de programación, donde el generar una instancia de Clase resultaría en un proceso tardado y mecánico. En la siguiente tabla se describen los diversos primitivos disponibles en el lenguaje Java:

Tipo de Primitivo

Tamaño Valor Mínimo

Valor Máximo

Valor Default

"Wrapper"

boolean - - - false Boolean

char 16-bit Unicode 0 Unicode 216- 1 `\u0000' (null) Character

byte 8-bit -128 +127 (byte) 0 Byte

short 16-bit -215 +215-1 (short) 0 Short

int 32-bit -231 +231-1 0 Integer

long 64-bit -263 +263-1 0L Long

float 32-bit IEEE754 IEEE754 0.0f Float

double 64-bit IEEE754 IEEE754 0.0d Double

14


void - - - - Void

Nótese que estos primitivos inician con letra minúscula, en la tabla anterior se describen los rangos de dichos primitivos así como sus respectivos "Wrappers"; estos "Wrappers" son Clases utilizadas como contra parte de primitivos:

char c = 'x';Character C = new Character(c);

La primer linea genera un primitivo el cual es asignado a la variable c, posteriormente se genera una instancia de la Clase Character (Nótese el uso del vocablo new); el uso de "Wrappers" (Objetos) para primitivos es empleado bajo ciertas circunstancias, sin embargo, vale mencionar que existen diversos mecanismos para convertir de Clases tipo Objeto ("Wrappers") a primitivos y viceversa, a continuación se describen los mecanismos para realizar este tipo de conversiones :

• Uso de "Wrappers" y primitivos en Java . Código Fuente Capsulas.java

public class Capsulas {

public static void main(String[] args) {

// Inicializar Primitivos

int i1 = 12;

int i2 = 300;

long l1 = 200L; // sufijo para primitivo long

long l2 = 200l; // sufijo para primitivo long

long l3 = 200;

float f1 = 1e-39F; // sufijo para primitivo float

float f2 = 1e+11f; // sufijo para primitivo float

float f3 = 1;

double d1 = 32e46d; // sufijo para primitivo double

double d2 = 14D; // sufijo para primitivo double

double d3 = 1;

// Inicializar "Wrappers" con primitivos

Integer wi1 = new Integer(i1);

15

http://javabasico.osmosislatina.com/curso/progbasico2/wrappers.htm


Long wl1 = new Long(l1);

Float wf1 = new Float(f1);

Double wd1 = new Double(d1);

// Convertir/Imprimir Valores de "Wrappers" como double (primitivo)

prt(wi1.doubleValue());

prt(wl1.doubleValue());

prt(wf1.doubleValue());

prt(wd1.doubleValue());

// Convertir/Imprimir Valores de "Wrappers" como float (primitivo)

prt(wi1.floatValue());

prt(wl1.floatValue());

prt(wf1.floatValue());

prt(wd1.floatValue());

// Convertir/Imprimir Valores de "Wrappers" como long (primitivo)

prt(wi1.longValue());

prt(wl1.longValue());

prt(wf1.longValue());

prt(wd1.longValue());

// Convertir/Imprimir Valores de "Wrappers" como integer (primitivo)

prt(wi1.intValue());

prt(wl1.intValue());

prt(wf1.intValue());

16


prt(wd1.intValue());

// Inicializar "String's" con valores numericos

String str1 = "7";

String str2 = "57";

String str3 = "3.23";

String str4 = "797.43";

// Inicializar "Wrappers" con "String's"

Integer wi2 = new Integer(str1);

Long wl2 = new Long(str2);

Float wf2 = new Float(str3);

Double wd2 = new Double(str4);

// Imprimir Valores

prt(wi2);

prt(wl2);

prt(wf2);

prt(wd2);

// Convertir/Imprimir Valores de "Wrappers" como String's

prt(wi2.toString());

prt(wl2.toString());

prt(wf2.toString());

prt(wd2.toString());

// Inicializar "Wrappers" con primitivos

17


Integer wi3 = new Integer(0);

Long wl3 = new Long(0);

Float wf3 = new Float(0);

Double wd3 = new Double(0);

// Convertir/Imprimir Valores de "Wrappers" a través de "String's"

// a su respectivo primitivo

prt(wi3.parseInt(str1));

prt(wl3.parseLong(str2));

prt(wf3.parseFloat(str3));

prt(wd3.parseDouble(str4));

}

static void prt(String s) {

System.out.println("Un String con valor " + s);

}

static void prt(Integer i) {

System.out.println("Un Integer (\"Wrapper\") con valor " + i);

}

static void prt(Long l) {

System.out.println("Un Long (\"Wrapper\") con valor " + l);

}

static void prt(Float f) {

System.out.println("Un Float (\"Wrapper\") con valor " + f);

}

static void prt(Double d) {

System.out.println("Un Double (\"Wrapper\") con valor " + d);

18


}

static void prt(int i) {

System.out.println("Un int (primitivo) con valor " + i);

}

static void prt(long l) {

System.out.println("Un long (primitivo) con valor " + l);

}

static void prt(float f) {

System.out.println("Un float (primitivo) con valor " + f);

}

static void prt(double d) {

System.out.println("Un double (primitivo) con valor " + d);

}

}

Clase Capsulas • Como en todo programa Java , primeramente se define la Clase a través del vocablo class.• Se define el método principal main y dentro de éste se generan diversos campos ("fields"),

nótese que en algunas declaraciones se emplea un sufijo para definir el valor del primitivo (L,l,F,f,D,d), lo anterior se hace con la finalidad de asignar un espacio apropiado para futuras manipulaciones numéricas.

Uso de Sufijos Aunque el uso de sufijos no es obligatorio, su uso se hace más evidente cuando los primitivos son empleados para realizar operaciones matemáticas con mayor precisión.Tomemos un número definido como 14D, aunque el número catorce bien pudiera ser un entero (int) éste se esta definiendo como un número double a través del sufijo, esto permite que el número sea manipulado con otros primitivos double sin perder precisión, esta pérdida de precisión será ilustrada a continuación.

• Posteriormente, se inicializan cuatro "Wrappers" a través de los primitivos definidos anteriormente.

• Seguido se emplean una serie de declaraciones con el método prt para imprimir valores a pantalla; en esta serie de declaraciones se manda imprimir el valor de los "Wrappers" definidos anteriormente a través de métodos auxiliares xxxxValue().

• Dichos métodos auxiliares se encuentran disponibles para todo "Wrapper" de primitivo y permiten restringir el rango del mismo, esto en términos computacionales es conocido como "Casting" (Concepto ilustrado a más detalle en otra sección de este curso); mediante esta utilización de "Casting" se puede ilustrar la pérdida de exactitud en primitivos, tal sería el caso al realizar un "Cast" de double a int.

19


• Posteriormente son definidos cuatro "String's" con valores numéricos.

• Se declara otra serie de "Wrappers" que son inicializados a través de los "String's" definidos anteriormente.

• Son impresos a pantalla (a través de prt) los valores de los "Wrappers", en la primer serie como "Wrappers" directamente y en la segunda serie manipulados hacia "String's" mediante el método auxiliar toString() disponible en todo "Wrapper".

• Se inicializan otra serie de "Wrappers" con primitivos 0 (cero)

• Son impresos a pantalla los valores de estos últimos "Wrappers" como primitivos a través de los "String's" definidos previamente, dicha impresión de "String's" como primitivos se logra a través de los métodos auxiliares parseXXX.

• Finalmente son definidos una serie de métodos prt que toman distintos argumentos de entrada ; el diseño de estos métodos prt es conocido como overloading, concepto que será ilustrado a detalle en una futura sección del curso.

El uso práctico para emplear "Wrappers" y/o primitivos será explorado en una futura sección de este curso.

Campos("Fields") y Métodos. Cuando se define una Clase esta puede contener dos tipos de elementos: Campos ("Fields") o Métodos, los métodos ya fueron descritos en los ejemplos anteriores, sin embargo , un campo es un objeto o primitivo utilizado para guardar datos en cada instancia de un objeto :

• Uso de Campos("Fields") en Java . Código Fuente Automoviles.java

public class Automoviles {

int cantidad;

boolean doble_traccion;


Automoviles ford = new Automoviles();

ford.cantidad = 3;

Automoviles vw = new Automoviles();

vw.cantidad = 2;

Automoviles jeep = new Automoviles();

jeep.doble_traccion = true;

System.out.println("Autos Ford: " + ford.cantidad + " Doble Traccion: " + ford.doble_traccion);

20

http://javabasico.osmosislatina.com/curso/progbasico2/campos.htm


System.out.println("Autos Volkswagen : " + vw.cantidad + " Doble Traccion: " + vw.doble_traccion);

System.out.println("Autos Jeep : " + jeep.cantidad + " Doble Traccion: " + jeep.doble_traccion);

}

Clase Automoviles • Como en todo programa Java , primeramente se define la Clase a través del vocablo class.

• Inmediatamente después son definidos dos campos ("fields") dentro de la clase, en este caso primitivos; al ser definidos los campos al nivel de Clase (y no dentro de un método como el ejemplo anterior) se garantiza que los campos puedan ser manipulados de cualquier método de la Clase.

• Se define el método principal main y dentro de este se generan tres instancias de la Clase; nótese que a través de las referencias de cada instancia son manipulados los valores de los campos("fields").

• Posteriormente, se imprimen a pantalla los valores de las diversas instancias con sus respectivos campos("fields"); nótese que aquellas instancias que no asignaron valores a sus campos("fields"), reciben un valor "default" (primitivos)

En Java existen ciertos campos que son definidos como final, y aunque dicho calificativo puede ser empleado en métodos y Clases su uso más común es en campos, su significado puede ser descrito con las siguientes palabras: "No puede cambiar"; las razones por las que es utilizado final pueden ser: Eficiencia o Diseño. Al utilizarse final en variables (primitivos) estas toman un valor constante al llevarse acabo la compilación, lo anterior permite mayor eficiencia al momento de ejecutarse un programa ("Run-Time"), ahora bien, cuando es utilizado final en referencias de Objetos se restringe que dicha referencia sea utilizada para apuntar hacia otro Objeto, esto permite realizar un diseño que prohibe a la referencia ser re-asignada, el uso del vocablo final será explorado en otra sección de este curso.En ciertos métodos es utilizado el vocablo return que permite indicar el valor de retorno para un método:

• Uso de return en Métodos . Código Fuente Fecha.java

import java.util.*;

public class Fecha {

public Date hoy() {

Date a = new Date();

return a;

}

21

http://javabasico.osmosislatina.com/curso/progbasico2/return.htm



Fecha tiempo = new Fecha();

System.out.println(tiempo.hoy());

}

}

Clase Fecha • Se importan las Clases de la librería java.util.*, donde se encuentra la Clase Date empleada para

manipular fechas en Java.

• Como en todo programa Java , se define la Clase a través del vocablo class.

• Es definido un método llamado hoy que retorna la fecha actual mediante un Objeto Date .

• Se define el método principal main y dentro de este se genera una instancia de la Clase, mandándose llamar el método hoy.

Significado de return. El uso del vocablo return no es obligatorio en la gran mayoría de métodos definidos en Java, sin embargo, tiene dos usos principales:

• Primeramente es una manera de indicar que el método en cuestión ha terminado.

• Cuando en determinado método se manipula más de una instancia/primitivo del mismo tipo que será retornado, se emplea el vocablo return para evitar ambigüedad.

Constructores. Un Constructor es un método especial en Java empleado para inicializar valores en Instancias de Objetos, a través de este tipo de métodos es posible generar diversos tipos de instancias para la Clase en cuestión; la principal característica de este tipo de métodos es que llevan el mismo nombre de la clase, a continuación se describen varios ejemplos utilizando constructores:

• Utilización de Constructores . Código Fuente Arboles.java.

public class Arboles {

public Arboles() {

System.out.println("Un árbol genérico");

}

22

http://javabasico.osmosislatina.com/curso/progbasico2/constructores.htm


public Arboles(String tipo) {

System.out.println("Un árbol tipo " + tipo);

}

public Arboles(int altura) {

System.out.println("Un árbol de " + altura + " metros");

}

public Arboles(int altura,String tipo) {

System.out.println("Un " + tipo + " de " + altura + " metros");

}


Arboles arbol1 = new Arboles(4);

Arboles arbol2 = new Arboles("Roble");

Arboles arbol3 = new Arboles();

Arboles arbol4 = new Arboles(5,"Pino");

}

}

Clase Arboles • Como en todo programa Java , primeramente se define la Clase a través del vocablo class.

• Posteriormente son definidos 4 Constructores; nótese que cada uno recibe el mismo nombre de la Clase y posee distintos argumentos de entrada.

• Dentro del método principal (main) son generadas cuatro instancias de la Clase, como se puede observar, al ser generada la instancia a través del vocablo new se pasa un parámetro, y es dependiendo de este parámetro que es llamado el Constructor correspondiente, el cual a su vez invoca la Clase System.out.println que imprime a pantalla.

Constructor Obligatorio... En los ejemplos anteriores del curso se pudo notar que no se hizo uso de Constructor alguno, y la razón es que el compilador lleva acabo esta definición de Constructor vacío detrás de los escenarios, sin embargo,

23


existe una situación en la que es necesario definir un Constructor vacío y esta es cuando se hace uso de otros constructores.

Lo anterior significa que si el compilador observa un método con el mismo nombre de la clase con argumentos (Constructor), deberá existir un método vacío por el mismo nombre, esto de cierta manera salvaguarda a un programador al momento de definir métodos que no vayan a ser definidos erróneamente como Constructores.

Métodos y Parámetros por Referencia. Cuando son utilizados Constructores puede surgir la necesidad de inicializar algún campo perteneciente a la Clase, esto trae consigo otro detalle en lo que concierne la asignación de valores dentro de un método, la razón se debe a que dentro de un método puede surgir el requerimiento de accesar campos definidos en la Clase, observe:

public Class Cableado { int longitud; String tipo; public Cableado(String tipo, int longitud) { this.tipo = tipo this.longitud = longitud; } .... .... }

En el caso anterior, dentro del constructor se desea asignar valores a los campos de una Clase, sin embargo, dentro del constructor son utilizados como parámetros de entrada los mismos valores, para tener acceso a los campos de la Clase se utiliza el vocablo: this, al emplear esta sintaxis se esta haciendo alusión a los campos de la Clase.Aunque sería posible emplear distintos nombres para los valores de entrada, evitando el uso del vocablo this, la sintaxis con el vocablo this es ampliamente utilizada en el caso de Constructores mencionado anteriormente, así como Java Beans, un concepto utilizado en Java para ambientes Web (JSP's/Servlets).Generación de Documentación (Vía Comentarios) En muchos lenguajes el mantener documentación acerca de las Clases/Métodos escritos es una tarea que requiere un esfuerzo adicional, ya que por una parte debe mantenerse el código funcional mientras se debe generar documentación acerca de la funciones; en muchas ocasiones esta documentación ni existe, en Java la generación de Documentación es llevada en conjunción del código a través de comentarios. A través de comentarios colocados en cada Clase/Método es posible generar documentación de una manera inmediata y concisa en formato de documentos HTML / XHTML , a continuación se describe un ejemplo :

• Utilización de Comentarios .• Generación de Documentación .

Comentarios en Java Primeramente vale hacer mencionar los tipos de comentarios utilizados en Java, existen dos tipos de comentarios puros como tal :

24

http://javabasico.osmosislatina.com/curso/progbasico2/documentacion.htm

http://javabasico.osmosislatina.com/curso/progbasico2/comentarios.htm


/* Este es un comentario que expande

diversas lineas, sin embargo, este

no será incluido en la documentación */

// Este es un comentario de linea únicamente

// Tampoco será incluido en la documentación

Los dos tipos de comentarios anteriores son utilizados como guia dentro del código fuente, esto es, a partir de ellos no son generados ningún tipo de documentación, cualquier palabra entre /* y */ es considerada comentario, al igual que todo renglón que inicie con //.

Para que un comentario sea contemplado en la generación de documentación se utiliza la siguiente sintaxis

/** Un comentario para Clase */

public class pruebaDocs {

/** Un comentario para Variables */

public int i;

/** A comentario para método */

public void f() {}

}

Todo elemento colocado entre los elementos /** */ será contemplado en la generación de documentación, dependiendo de la ubicación de este comentario será generada la documentación, esto es, si aparece antes de un elemento class es considerado documentación para la Clase y así sucesivamente. Existe otra Sintaxis especifica para definir los elementos dentro de los comentarios, la cual se ilustra a continuación:

import java.util.*;

/** * Programa que Despliega la Fecha. * @author Juan Sanchez

25


* @author [email protected] * @version 1.7 */ public class PruebaFecha { /** Punto de Entrada único para Clase * @param args Arreglo de String's * @return Sin valor de retorno * @exception exceptions Ningún error (Excepción) definida */ public static void main(String[] args) { System.out.println("Hoy es: "); System.out.println(new Date()); } }

Los elementos que inician con el símbolo @ son utilizados para indicar parámetros específicos dentro de la documentación; los anteriores son algunos elementos que pueden ser utilizados al definir documentación.En la siguiente sección serán ilustrados otros elementos @, así como el proceso para generar la documentación HTML / XHTML del código fuente Java.

Otros parámetros (@) para Comentarios en Java Los siguientes parámetros también son utilizados al generar documentación para código Java:

Elemento Uso

@see <Nombre de la Clase>

Elemento utilizado para hacer referencia a otras Clases, genera un link HTML / XHTML hacia la Clase en cuestión.

@throws <Nombre de la

Clase>

Empleado para indicar la Clase utilizada al generarse un Error. La definición de Clases para Errores será descrita en otra sección.

@deprecated

Este parámetro es utilizado para indicar que una Clase ha sido repuesta por otra más reciente; al ser indicado este parámetro en una Clase/Método el compilador (javac) generará un aviso, indicando que la Clase/Método ha sido repuesto.

Además de los parámetros anteriores también es posible escribir lenguaje HTML / XHTML entre los elementos /** */ , lo anterior permite generar listas enumeradas, dar mayor estilo a la documentación y cualquier otro formato disponible en HTML / XHTML .

A continuación se ilustran dos Clases escritas anteriormente, con los respectivos comentarios para generar documentación:

Clase Pantalla.java


/**

26


* Programa con métodos auxiliares para salto de linea

* y linea continua

* @author Juan Sanchez

* @author [email protected]

* @version 1.3

*/

public class Pantalla {

/** Método para linea continua

* @params Un String

* @return Sin valor de retorno

* @exception exceptions Ningún error (Excepción) definida

*/

public static void sinSalto(String s) {

System.out.print(s);

}

/** Método para salto de linea

* @params Un String

* @return Sin valor de retorno

* @exception exceptions Ningún error (Excepción) definida

*/

public static void conSalto(String s) {

System.out.println(s);

}

}

Clase MandaPantalla.java27


package com.osmosislatina.auxiliares;

import com.osmosislatina.escritura.*;

/** * Programa para demostración de import en la Clase * @author Juan Sanchez * @author [email protected] * @version 1.6 * @see com.osmosislatina.escritura.Pantalla */public class MandaPantalla { /** Punto de Entrada único para Clase * <ul> * <li>Utiliza método sinsalto * <li>Utiliza método consalto * </ul> * @param args Arreglo de String's * @return Sin valor de retorno * @exception exceptions Ningun error (Excepción) definida */ public static void main(String args[]) {

Pantalla primera = new Pantalla(); primera.conSalto("Esto es un renglón CON salto de linea"); primera.conSalto("Esta linea también 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"); }

}

Generación de Documentación El comando javadoc posee una gran cantidad de parámetros para generar documentación, a continuación se describe su uso más básico:

$ mkdir docs$ javadoc -d docs/ -version -author -use *.java com/osmosislatina/escritura/*.java com/osmosislatina/auxiliares/*.java

• El primer paso antes de generar cualquier documentación Java es crear un directorio donde residirá la documentación, en este caso se ha generado un directorio llamado docs.

• Posteriormente es invocado el comando javadoc con los siguiente parámetros:o -d docs: Indica el directorio donde será depositada la documentación (docs). o -version: Implica que al ser generada la documentación sea desplegado el numero de

versión, de ser definido en la Clase.o -author : En caso de ser definido el parámetro autor, este aparecerá en la

documentación.o -use: Es el parámetro utilizado para indicar los directorios donde residen las Clases

sobre las que será generada la documentación, en este caso se esta indicando el directorio presente (*.java) y los directorios com/osmosislatina/escritura y com/osmosislatina/auxiliares.

Al terminar este proceso será generada la documentación de las distintas Clases dentro del directorio docs; para observar otros parámetros que puede tomar el comando javadoc basta ejecutar : javadoc -help.

28


Herencias ("Inheritance") Uno de las partes medulares en un lenguaje orientado a Objetos es el uso de Herencias ("Inheritance") , el cual permite reutilizar Clases existentes con todas las funcionalidades/comportamientos ya diseñadas en ellas; en Herencias ("Inheritance") el termino reutilizable toma otro sentido al utilizado en la secciones anteriores al importarse Clases (import), uno más complejo y poderoso, observe:

El primer diagrama UML ("Universal Markup Language") muestra 3 Clases(Guitarra,Piano,Saxofón) que heredan ("Inherit") de una Clase Base (Instrumento),mientras el segundo diagrama muestra 2 Clases (Circulo,Triangulo) que heredan ("Inherit") de una Clase Base (Figura); este mecanismo permite que nuevas Clases hereden el comportamiento de una Clase Base ya depurada y funcional, en el proceso teniendo acceso a los métodos/campos ya creados con anterioridad ; a continuación se describe un ejemplo que hace uso de Herencias ("Inheritance"):

• Uso de Herencias ("Inheritance") .Código Fuente MiniComponente.java

class Radio {

private String r = new String("Radio: ");

public void agrega(String a) { r += a; }

public void imprimir() { System.out.println(r); }

public void frecuencia() { agrega(" frecuencia() "); }

public void volumen() { agrega(" volumen() "); }

29

http://javabasico.osmosislatina.com/curso/progavanza/herencias.htm


public void modelo() { agrega(" modelo() "); }


Radio x = new Radio();

x.frecuencia() ; x.volumen(); x.modelo();

x.imprimir();

}

}

public class MiniComponente extends Radio {

// Cambiar el metodo ("Override")

public void volumen() {

agrega( " MiniComponente.volumen() ");

super.volumen(); // Llamar la version de la Clase Base

}

// Agregar metodo

public void equalizador() { agrega(" equalizador() "); }


MiniComponente x = new MiniComponente();

x.frecuencia();

x.volumen();

x.modelo();

x.equalizador();

x.imprimir();

System.out.println("Probar la Clase Base: ");

30


Radio.main(args);

}

}

Definición de Dos Clases y Herencias ("Inheritance").Como se puede observar, han sido definidas dos Clases en el mismo archivo fuente llamado MiniComponente.java, el hecho que existan dos Clases en el mismo archivo fuente no influye en ningún factor, en este caso se opto por dicho diseño debido a razones didácticas, aunque bien se pudo haber realizado el diseño de este manera por razones administrativas, de cualquier manera, nótese que se sigue cumpliendo la característica de una Clase Java: debe ser definida al menos una Clase con el mismo nombre del archivo fuente.

Entrando al problema espacial ("real"), es posible afirmar que todo MiniComponente incluye un Radio (AM/FM) entre sus dispositivos , debido a esto se ha decidido reutilizar(Heredar) el comportamiento de una Clase Base de Radio, a continuación se describe la Clase Radio.

Clase Radio.• Como cualquier Clase Java se utiliza el vocablo class, sin embargo, no se utiliza ningún calificador de

acceso, por lo que esta Clase solo será accesible internamente (O al paquete "package" si fuera incluida en alguno );esto es lo que se refiere como acceso amigable, descrito en la sección de Calificadores.

• Se define un campo tipo String con la referencia r, el cual es asignado un valor inicial de "Radio: ".

• El primer método llamado agrega, toma como valor de entrada un String y su función es concatenar diversos String's, nótese que se utiliza el operador +=; a través de este operador es posible concatenar diversos elementos, en esta definición se esta declarando que el String de entrada (a) debe ser concatenado con el String r el cual es el campo definido en la Clase.

• Los métodos frecuencia, volumen y modelo hacen uso del método agrega concatenando distintos valores.

• Finalmente el método imprimir hace uso de la Clase System.out.println para enviar a pantalla el valor del String r (el campo de la Clase).

• En el método principal ( main ) se genera una instancia de la Clase Radio, posteriormente a través de la respectiva referencia se mandan llamar los distintos métodos de la Clase.

Una vez compilado el código fuente, es posible ejecutar la Clase Radio a través del comando java Radio y observar los resultados iniciales.

Clase MiniComponente. Al definir esta Clase se utiliza el vocablo extends que implica Herencia ("Inheritance"), seguido de éste se indica la Clase que será heredada ("Inherited"), en este caso Radio. El primer método definido se llama volumen, nótese que en la Clase Radio también existe un método con este nombre, dentro de esta Clase se esta modificando el comportamiento de dicho método, esto es conocido como override en lenguajes orientados a Objetos. Dentro de este mismo método, inicialmente se hace una llamada al método agrega, si observa el resto de la composición de esta Clase notará que no existe ninguno por este nombre, sin embargo,

31


dentro de la Clase Base existe dicho método, en este caso se esta haciendo uso de los métodos de la Clase Base. La segunda llamada en este método es: super.volumen, el vocablo super indica una llamada hacia la Clase Base (Radio), a través de esta linea se esta realizando una llamada hacia el método volumen definido en Radio; el vocablo super es utilizado en los casos donde surge una ambigüedad de nombres entre la Clase heredada y base. Se define un método nuevo llamado equalizador, que también hace uso del método agrega. Dentro del método principal main se genera una instancia de la Clase MiniComponente, seguido de diversas llamadas a distintos métodos, nótese que aquellos no definidos dentro de la Clase, son llamados con la implementación de la Clase Base. En el último paso del método main se realiza una llamada hacia el otro método main definido en la Clase Radio.Una vez compilado el código fuente, es posible ejecutar la Clase MiniComponente a través del comando java MiniComponente y observar los resultados iniciales así como las variaciones de comportamiento en la Clase Radio.El uso de Herencias es ampliamente utilizado en diseños Java, inclusive las Clases Base del JDK lo utilizan extensamente, si observa la documentación de estas Clases, notará en la parte superior el árbol de Herencias ("Inheritance") para la Clase correspondiente, donde todas son descendientes de la Clase Base java.lang.Object.Condicionales if/else. En Java al igual que otros lenguajes son utilizados condicionales que permiten controlar el flujo de ejecución en un programa, los tres principales tipos son el conocido if/else,while y for; a continuación se describen varios ejemplos con el uso de if/else:

• Utilización de Condicional if/else .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 32

http://javabasico.osmosislatina.com/curso/progavanza/ifelse.htm


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.

Uso de los Ciclos for y while El uso de Ciclos en lenguajes de programación es un concepto ampliamente utilizado, a continuación se describe el uso del ciclo for y while :

• Ciclo for en Java .

• Utilización de Condicional while .

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)

33

http://javabasico.osmosislatina.com/curso/progavanza/while.htm

http://javabasico.osmosislatina.com/curso/progavanza/for.htm


• 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.

34


• 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.

En ciertas ocasiones surge la necesidad de interrumpir un ciclo si ocurre determinada condición, o bien, saltar una iteración en ciertas circunstancias, este comportamiento se logra a través de los vocablos break y continue, a continuación se describe su uso:

• break / continue en Ciclos .Código Fuente BreakYContinue.java

public class BreakYContinue {


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

35

http://javabasico.osmosislatina.com/curso/progavanza/bcontinue.htm


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.

Otra variación para interrumpir y saltar iteraciones en ciclos es a través de Etiquetas (Labels), este mecanismo logra un comportamiento similar al famoso, pero criticado "goto". Aunque su uso es permitido, es fuertemente desalentado debido a la poca legibilidad que resulta en el código.

• Etiquetas Labels en Ciclos. Código Fuente LabelFor.java

public class LabelFor {


int i = 0;

externo: // Definicón de Label

for(; true ;) { // Ciclo Infinito

interno: // Definción de Label

36

http://javabasico.osmosislatina.com/curso/progavanza/labels.htm


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++) {

37


if(k == 3) {

prt("continue interno");

continue interno;

}

}

}

}

}



}

}

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

38


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 {


int i = 0;

externo:

while(true) {

prt("Externo Ciclo while");

while(true) {

i++;

prt("i = " + i);

if(i == 1) {

prt("continue");

39


continue;

}

if(i == 3) {

prt("continue externo");

continue externo;

}

if(i == 5) {

prt("break");

break;

}

if(i == 7) {

prt("break externo");

break externo;

}

}

}

}



}

40


}

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

Uso de switch. A través de un Switch se posible definir una serie de tareas cada una asignada a una lista de valores, este tipo de estructura es ideal cuando se requieren condicionales que lleven más de dos valores, en lugar de anidar grupos de condicionales if/else es posible lograr el mismo comportamiento a través de un switch:

• Utilización de Switch . Sintaxis del switch.La Sintaxis empleada por un switch es la siguiente:

switch (variable) { case <posible valor> : Instrucciones : break; case <posible valor> : Instrucciones : break; case <posible valor> : Instrucciones : break; case <posible valor> : Instrucciones : break; case <posible valor> : 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.

41

http://javabasico.osmosislatina.com/curso/progavanza/switch.htm


• 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;

42


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.

Operadores Matemáticos, Relacionales y Lógicos. En Java al igual que otros lenguajes existen diversos operadores que son empleados en diferentes secciones de un programa, a lo largo de los distintos programas escritos en este Curso se han empleado su gran mayoría, sin embargo, en esta sección se describirán detalles más precisos acerca de su funcionamiento.Antes de entrar en el uso de Operadores, a continuación se describe un ejemplo que demuestra el comportamiento de Asignación de valores para el lenguaje Java:

• Asignación de Valores. Código Fuente Asignacion.java

class Numero {

int i;

}

public class Asignacion {


Numero n1 = new Numero();

Numero n2 = new Numero();

n1.i = 15;

43

http://javabasico.osmosislatina.com/curso/progavanza2/asignacion.htm


n2.i = 45;

System.out.println("a) n1.i: " + n1.i +

", n2.i: " + n2.i);

n1 = n2;

System.out.println("b) n1.i: " + n1.i +

", n2.i: " + n2.i);

n1.i = 27;

System.out.println("c) n1.i: " + n1.i +

", n2.i: " + n2.i);

}

}

Clase Asignacion • En el código fuente son definidas dos Clases, una de ellas (Numero) simplemente contiene un

campo, mientras la segunda (Asignacion) incluye la lógica central del programa.• Dentro del método principal (main) de la Clase principal (Asignacion) es definida la

siguiente secuencia de eventos: o Primeramente se generan dos instancias de la Clase Numero a las cuales son

asignadas las referencias n1 y n2.o A través de dichas referencias son asignados los valores correspondientes al campo i

de la Clase.o Se imprime a pantalla el valor de cada campo de las dos instancias.o Se asigna el valor de n2 a la instancia de n1.o Se imprime a pantalla el valor de cada campo de las dos instancias.o Se modifica el valor del campo en la instancia n1 al valor de 27.o Se imprime a pantalla el valor de cada campo de las dos instancias.

Aunque el comportamiento del programa anterior parece predecible, para muchas personas no familiarizadas con lenguajes orientados a Objetos puede resultar una sorpresa, la ejecución del programa anterior da como resultado:

a) n1.i: 15, n2.i: 45b) n1.i: 45, n2.i: 45c) n1.i: 27, n2.i: 27

Los primeros resultados no presentan sorpresa alguna, puesto que simplemente se imprimen los valores recién asignados; la segunda impresión puede resultar confusa y esto se debe a la asignación n1 = n2.Al utilizar la sintaxis n1 = n2, se esta indicando que la referencia n1 apunte hacia aquella de n2; al ser llevada acabo esta asignación el valor n1.i cambia efectivamente hacia el mismo de n2.i. El comportamiento anterior se debe a que fueron utilizadas referencias en la asignación de valores, la instancia de n1 fue efectivamente perdida, a partir de ese punto ambas referencias apuntan hacia la instancia del Objeto n2; este mecanismo en Java es denominado aliasing y suele ser un poco difícil de entender para aquellos que inician en este lenguaje.

44


La tercer impresión es llevada acabo después de la asignación n1.i = 27, al llevar acabo este proceso el valor n1.i será modificado, así como el valor de n2.i, puesto que ambas referencias apuntan hacia la misma instancia.Para evitar aliasing y mantener las dos instancias de Objetos se utilizaría una asignación más explicita : n1.i = n2.i; en la siguiente sección se observará un comportamiento de equivalencia que también puede resultar inusual para un programador no familiarizado con el lenguaje Java.

Operadores Relacionales. A través de operadores relacionales es posible llevar acabo un proceso de comparación entre dos elementos en un programa, siendo su característica principal el generar un resultado verdadero o falso; dichos operadores relacionales se muestran a continuación :

Operador Significado

< Menor que

> Mayor que

<= Menor que o Igual

>= Mayor que o Igual

== Igual

!= No Igual

Muchos de estos Operadores han sido utilizados a lo largo de este curso, a continuación se demuestra un uso muy común de estos operadores:

• Utilizando Equivalencias. Código Fuente Equivalencia.java

public class Equivalencia { public static void main(String[] args) { Integer n1 = new Integer(75); Integer n2 = new Integer(75); System.out.println(n1 == n2); System.out.println(n1 != n2); }}

Clase Equivalencia • La Clase anterior genera dos instancias de la Clase Integer, las cuales son inicializadas con

un valor de 75.• Es llevada acabo una comparación entre ambas referencias.• Aunque el comportamiento del programa anterior parece predecible, los resultados de este

programa son falso (false) y verdadero (true), este resultado se debe a que la comparación llevada acabo por el programa es en base a referencias, para llevar acabo el comportamiento deseado se utiliza la siguiente variación:

public class Equivalencia2 { public static void main(String[] args) { Integer n1 = new Integer(75);

45

http://javabasico.osmosislatina.com/curso/progavanza2/equivalencia.htm


Integer n2 = new Integer(75); System.out.println(n1.equals(n2)); }}

• En el ejemplo anterior se hace uso del método equals, a través de este método disponible en toda Clase es llevado acabo una comparación entre el valor del Objeto en sí ; cabe mencionar que los operadores relacionales "==" y "!=" funcionan acordemente ( o como aparentemente se pensaría ) con primitivos, es solo cuando se utilizan Clases cuando es necesario utilizar el método "equals" para llevar acabo una comparación al nivel de Objetos.

Operadores Matemáticos. En Java se encuentran disponibles los mismos operadores matemáticos que en otros lenguajes, mencionados a continuación :


+ Suma

- Resta

= Igual

* Multiplicación

/ División

% Modulo (El residuo de una División)

Java también ofrece una sintaxis para llevar acabo una operación matemática y asignación en una sola simbología, esta es llevada acabo mediante: "+=","-=","*=","/="; además de esta sintaxis también existen los operadores de auto-incremento y auto-decremento que son representados por "++" y "--" respectivamente.

En los siguientes ejemplos se describe el uso de los diversos operadores matemáticos:

• Utilización de Operadores Matemáticos.

• Utilización de Operadores Auto-Incremento y Decremento.

Código Fuente OperadoresMat.java

import java.util.*;

public class OperadoresMat {

// Metodo para Imprimir Mensaje a Pantalla



46

http://javabasico.osmosislatina.com/curso/progavanza2/operadoresmat2.htm

http://javabasico.osmosislatina.com/curso/progavanza2/operadoresmat.htm


}

// Metodo para Imprimir un String y Entero ("Overload")

static void prt(String s, int i) {

prt(s + " = " + i);

}

// Metodo para Imprimir un String y Float ("Overload")

static void prt(String s, float f) {

prt(s + " = " + f);

}


// Generar un numero Aleatorio

Random rand = new Random();

int i, j, k;

// '%' Limita a un valor maximo de 99

j = rand.nextInt() % 100;

k = rand.nextInt() % 100;

// Imprimir Valores de "j" y "k"

prt("j",j); prt("k",k);

i = j + k; prt("j + k", i);

i = j - k; prt("j - k", i);

i = k / j; prt("k / j", i);

i = k * j; prt("k * j", i);

i = k % j; prt("k % j", i);

j %= k; prt("j %= k", j);

47


// Prueba para numero Float

float u,v,w;

v = rand.nextFloat();

w = rand.nextFloat();

prt("v", v); prt("w", w);

u = v + w; prt("v + w", u);

u = v - w; prt("v - w", u);

u = v * w; prt("v * w", u);

u = v / w; prt("v / w", u);

// Operadores Adicionales

u += v; prt("u += v", u);

u -= v; prt("u -= v", u);

u *= v; prt("u *= v", u);

u /= v; prt("u /= v", u);

}

}

Clase OperadoresMat A diferencia de otras Clases diseñadas en este Curso, esta Clase contiene tres métodos con el mismo nombre cada uno con distintos valores de entrada, este comportamiento en Java es conocido como overloading; al ser invocado dicho método ocurrirá el comportamiento apropiado en base a los parámetros de entrada.

"Overloading" no es lo mismo que "Overriding"El concepto descrito en esta sección es llamado overloading que como su nombre lo implica, es una sobrecarga del nombre de un método, esto es, pueden existir diversos métodos con el mismo nombre pero distintos parámetros de entrada.

Lo anterior es muy distinto al concepto de overriding descrito en Herencias ("Inheritance"), en donde se puede modificar el comportamiento de un método con los mismos parámetros de entrada en Clases que hereden su

48


comportamiento.

La ejecución de este programa genera números aleatorios a través de la Clase Random, posteriormente se realizan diversas operaciones con primitivos empleando los distintos operadores matemáticos; un posible resultado (debido al uso de números aleatorios) es el siguiente:

$ java OperadoresMatj = -19k = 14j + k = -5j - k = -33k / j = 0k * j = -266k % j = 14j %= k = -5v = 0.7287964w = 0.7703622v + w = 1.4991586v - w = -0.041565776v * w = 0.5614372v / w = 0.94604385u += v = 1.6748402u -= v = 0.9460438u *= v = 0.68947333u /= v = 0.9460438

Código Fuente AutoInc.java

public class AutoInc {


int i = 1;

prt("i : " + i);

prt("++i : " + ++i); // Pre-Incremento

prt("i++ : " + i++); // Post-Incremento

prt("i : " + i);

prt("--i : " + --i); // Pre-Decremento

prt("i-- : " + i--); // Post-Decremento

prt("i : " + i);

}

// Metodo para Impresion

49




}

}

Clase AutoInc La clase hace uso de los distintos operadores para Auto-Incremento y Auto-Decremento de variables; el resultado de dicho programa se muestra a continuación:

$ java AutoInc

i : 1

++i : 2

i++ : 2

i : 3

--i : 2

i-- : 2

i : 1

Además de estos operadores matemáticos, el lenguaje también posee una Clase estándar (en el JDK) para realizar operaciones más complejas, esta Clase bajo el nombre de java.lang.Math ofrece operaciones trigonométricas, exponenciales y otras más; a continuación se describen algunos ejemplos empleando dicha clase :

• Utilización de métodos en java.lang.Math .

Código Fuente Calificaciones.java

public class Calificaciones {


int matematicas = 10;

int gramatica = -2;

double historia = 9.55;

50

http://javabasico.osmosislatina.com/curso/progavanza2/langmath.htm


double biologia = 7.3;

// Valores Absolutos

prt("|" + matematicas + "| es " + Math.abs(matematicas));

prt("|" + gramatica + "| es " + Math.abs(gramatica));

prt("|" + historia + "| es " + Math.abs(historia));

prt("|" + biologia + "| es " + Math.abs(biologia));

// Redondeo de cifras al siguiente numero entero

prt(historia + " redondeado es " + Math.round(historia));

prt(biologia + " redondeado es " + Math.round(biologia));

// El techo ("ceiling") de un numero es el minimo entero

// mayor o igual al mismo numero

// Un numero entero es su propio techo ("ceiling")

prt("El techo de " + matematicas + " es " + Math.ceil(matematicas));

prt("El techo de " + gramatica + " es " + Math.ceil(gramatica));

prt("El techo de " + historia + " es " + Math.ceil(historia));

prt("El techo de " + biologia + " es " + Math.ceil(biologia));

// El piso ("floor") de un numero es el entero mayor

// mayor o igual al mismo numero .

// Un numero entero es su propio piso ("floor")

prt("El piso de " + matematicas + " es " + Math.floor(matematicas));

prt("El piso de " + gramatica + " es " + Math.floor(gramatica));

prt("El piso de " + historia + " es " + Math.floor(historia));

prt("El piso de " + biologia + " es " + Math.floor(biologia));

51


// min() retorna el menor de los argumentos proporcionados

prt("min(" + matematicas + "," + gramatica + ") es " + Math.min(matematicas,gramatica));

prt("min(" + historia + "," + biologia + ") es " + Math.min(historia,biologia));

prt("min(" + matematicas + "," + historia + ") es " + Math.min(matematicas,historia));

prt("min(" + biologia + "," + gramatica + ") es " + Math.min(biologia,gramatica));

// max() retorna el mayor de los argumentos proporcionados

prt("max(" + matematicas + "," + gramatica + ") es " + Math.max(matematicas,gramatica));

prt("max(" + historia + "," + biologia + ") es " + Math.max(historia,biologia));

prt("max(" + matematicas + "," + historia + ") es " + Math.max(matematicas,historia));

prt("max(" + biologia + "," + gramatica + ") es " + Math.max(biologia,gramatica));

}




}

}

Clase Calificaciones La clase hace uso de distintos métodos para realizar operaciones de redondeo y comparación sobre valores primitivos.

Codigo Fuente Trilog.java

public class Trilog {


52


// Convertir un angulo de 45 grados a radianes

// Math.PI equivale a la constante PI (3.14159)

double angulo = 45.0 * 2.0 * Math.PI/360.0;

prt("cos(" + angulo + ") es " + Math.cos(angulo));

prt("sin(" + angulo + ") es " + Math.sin(angulo));

// Metodos Trigonometricos Inversos

// Valores en Radianes

// Debido a que los metodos asin y atan emplean radianes

// utilizar el metodo toDegrees para convertir a grados

double radianes = 0.707;

int i = 0;

prt("acos(" + radianes + ") es " + Math.toDegrees(Math.acos(radianes)));

prt("asin(" + radianes + ") es " + Math.toDegrees(Math.asin(radianes)));

prt("atan(" + radianes + ") es " + Math.toDegrees(Math.atan(radianes)));

// exp(x) equivale a "e (2.71828...)" elevado a la "x" potencia

prt("exp(1.0) es " + Math.exp(1.0));



// log(y) equivale al logaritmo natural (base e) de "y"

// Math.E equivale a la constante e (2.7182)

prt("log(1.0) is " + Math.log(1.0));

prt("log(10.0) is " + Math.log(10.0));

prt("log(Math.E) is " + Math.log(Math.E));

53


// pow(x, y) equivale a "x" elevado a la "y" potencia

prt("pow(2.0, 2.0) is " + Math.pow(2.0,2.0));

prt("pow(10.0, 3.5) is " + Math.pow(10.0,3.5));

prt("pow(8, -1) is " + Math.pow(8,-1));

// sqrt(x) equivale a la raiz cuadrada de "x"

for (i=0; i < 10; i++) {

prt(

"La raiz cuadrada de " + i + " is " + Math.sqrt(i));

}

}




}

}

Clase Trilog La clase hace uso de distintos métodos para realizar operaciones trigonométricas, logarítmicas y con exponentes sobre valores primitivos.

Operadores Lógicos. Los operadores lógicos para el lenguaje Java son los siguientes:


|| O (OR)

&& Y (AND)

! Negación (NOT)

A continuación se describe un ejemplo que hace uso de estos operadores :

54


• Operadores Lógicos en Java. Código Fuente OperaLogico.java

public class OperaLogico {

static boolean prueba1(int val) {

System.out.println("prueba1(" + val + ")");

System.out.println("resultado: " + (val < 1));

return val < 1;

}


System.out.println("preuba2(" + val + ")");


return val < 2;

}


System.out.println("prueba3(" + val + ")");


return val < 3;

}


// Primer prueba "Corto-Circuito"

if(prueba1(0) && prueba2(2) && prueba3(2))

System.out.println("Primera Expresion es Verdadera");

else

System.out.println("Primera Expresion es Falsa");

55

http://javabasico.osmosislatina.com/curso/progavanza2/operadoreslogicos.htm


// Segunda Prueba Condicional

if(prueba1(4) || prueba2(1))

System.out.println("Segunda Expresion es Verdadera");

else

System.out.println("Segunda Expresion es Falsa");

// Tercer Prueba Negacion

if(65 != 65)

System.out.println("Tercer Expresion es Falsa");

else

System.out.println("Tercer Expresion es Verdadera");

}

}

Clase OperaLogico • La clase hace uso de los distintos operadores lógicos en Java ; dentro de dicha Clase son

definidos tres métodos los cuales retornan un valor boolean en base al numero int que sea empleado como parámetro.

• Dentro del método principal ( main ) son generadas las siguientes pruebas: o La primer declaración utiliza tres elementos para llevar acabo una comparación , este

ejemplo demuestra una cualidad lógica llamada corto-circuito;al iniciar el proceso de comparación mediante los elementos && y encontrarse uno de estos falso, se termina la evaluación comparativa, en el caso anterior a pesar que el último elemento es verdadero este no es evaluado debido a que el segundo ya dio como resultado falso.

o La segunda declaración hace uso del operador || (OR), en este caso debido a que un elemento da como resultado verdadero, toda la declaración resulta verdadera.

o Finalmente se hace uso del operador de negación (!).La ejecución de este programa da como resultado:

$ java OperaLogicoprueba1(0)resultado: truepreuba2(2)resultado: falsePrimera Expresion es Falsaprueba1(4)resultado: false

56


preuba2(1)resultado: trueSegunda Expresion es VerdaderaTercer Expresion es Verdadera

Definición de Errores y Bloques try/catch/finally. Aunque el tiempo ideal para encontrar errores es al momento de compilar un programa, esto no siempre es posible y por esta razón han sido diseñados mecanismos para encontrarlos al momento de ejecución ("Run-Time").La metodología más común para trabajar con errores en lenguajes de programación es interrumpir el flujo de ejecución e invocar otro código que maneje el error en cuestión; en el lenguaje Java a la ocurrencia de errores se le denomina "Exceptions" y al procesamiento de errores "Trap" (atrapar).Como habría de esperarse, al encontrarse un error ("Exception") en Java es necesario invocar una Clase que realiza las respectivas tareas, para mandar llamar este tipo de Clases es necesario utilizar el vocablo throws; suponiendo que desea atrapar un error si determinada variable no ha sido inicializada, se utilizaría la siguiente sintaxis:

if(t == null) throw new NullPointerException();

Al utilizar una definición similar a la anterior, se asume que ya se conoce el tipo de error que puede ser generado en el programa, sin embargo, este no siempre es el caso y por esta razón en Java se define una Zona Especifica donde puede ser generado un error y a su vez atrapado, esta Zona "Protegida" es el conocido bloque try/catch/finally, a continuación se describe la sintaxis de este bloque:

• Sintaxis del Bloque try/catch/finally . Sintaxis del Bloque try/catch

try {

// Código que pueda generar Errores ("Exception's")

} catch(Tipo1 id1) {

// Manejar "Exception's" para la Clase Tipo1





}

La primer sección del Bloque es iniciada con el vocablo try y una llave ({ ) que indica el principio de la zona protegida, dentro de esta primer sección es colocado todo código que pueda generar algún tipo de error, al terminar esta sección se define un grupo de estructuras con el elemento catch.

Como se puede observar en la ilustración, cada vocablo catch es seguido de un paréntesis que contiene una Clase así como una referencia, estos son considerados los Datos de Entrada para cada sección catch; el tipo de Clases definidas dentro de cada sección catch depende del numero de "Exceptions" que pueden ser

57

http://javabasico.osmosislatina.com/curso/progavanza2/trycatch.htm


generadas por el programa; lo anterior permite definir un numero ilimitado de "Exceptions" cada uno con su propio código para manejar el error.

Para todo Bloque try/catch debe ser definida al menos una sección catch; si son definidos más de dos Clases para errores ("Exceptions") estas deben ser declaradas de más a menos especifica, siendo la menos especifica la Clase java.lang.Throwable; es de esta Clase que son Heredadas ("Inherited") todo "Exception" en Java, esto será descrito en la siguiente sección de este curso.

Sintaxis del Bloque try/catch/finally Para los Bloques try/catch existe una variación que consiste en agregar una sección denominada finally, dicha estructura estaría compuesta de la siguiente manera:

try {

// Código que pueda generar Errores ("Exception's")







} finally {

// Actividades que siempre ocurren

}

La utilización de finally es empleada dentro de un Bloque try/catch para realizar tareas que deben ser ejecutadas independientemente del comportamiento de errores.

Cuando se atrapa un error ("Exception") un programa queda inconcluso, es esta terminación abrupta la que puede causar que algún recurso/mecanismo permanezca asignado o mal utilizado; a través de una sección finally se garantiza que sea ejecutado un juego de instrucciones independientemente del tipo de error que pueda ocurrir; un uso muy común para una sección finally consiste en liberar conexiones hacia Bases de Datos que pudieran haber sido asignadas en la sección try.

Además de los errores ("Exceptions") ofrecidos en las Clases Base del JDK, es posible definir errores propietarios para llevar un control más estricto sobre la generación de errores:

• Definición y uso de una Clase para Errores ("Exceptions"). Código Fuente DefinirErrores.java

class MiError extends Exception {

58

http://javabasico.osmosislatina.com/curso/progavanza2/deferror.htm


public MiError() {}

public MiError(String msg) {

super(msg);

}

}

public class DefinirErrores {

public static void f() throws MiError {

System.out.println("Generando Error explícitamente en f()");

throw new MiError("Originado en f()");

}

public static void g() throws MiError {

System.out.println("Generando Error explícitamente g()");

throw new MiError("Originado en g()");

}


try {

f();

} catch(MiError e) {

e.printStackTrace(System.err);

}

try {

g();

} catch(MiError e) {

e.printStackTrace(System.err);

59


}

}

}

En el archivo fuente anterior son diseñadas dos Clases : MiError que define un error ("Exception") propietario y DefinirErrores que hace uso de esta Clase.

Clase MiError • Esta clase hereda ("Inherit") el comportamiento de Exception, esto permite utilizar funcionalidades

ya definidas en esta Clase. NOTA: Aunque la clase base de todo error ("Exception") es java.lang.Throwable, generalmente se opta por java.lang.Exception ya que posee mayores funcionalidades(métodos); inclusive si observa la documentación del JDK, notará que la Clase java.lang.Exception hereda ("inherit") el comportamiento de la Clase java.lang.Throwable, en efecto teniendo acceso a cualquiera de los métodos/campos disponibles en la Clase Base.

• Son definidos dos constructores para esta Clase:

o Uno de estos recibe un String como valor de entrada y a su vez manda llamar la Clase Base (Exception) a través del vocablo super.

o Otro es el constructor sin argumentos que debe ser declarado al emplearse más de un constructor.

Clase DefinirErrores • Esta Clase define dos métodos llamados f() y g(), una característica especifica de estos métodos es

que utilizan el vocablo throws seguido de una Clase, esta sintaxis es obligatoria para los métodos que puedan generar errores, debe hacerse fuerte énfasis que esto es independiente de las declaraciones hechas en los bloques try/catch, es simplemente una sintaxis para los métodos capaces de generar errores.

• Dentro de cada método f() y g() es generado un error con la clase MiError explícitamente.

• En el método principal (main) son definidos dos bloques try/catch, en uno de estos es llamado el método f() y en otro el método g().

• Al ser llamada la función de cada bloque, se genera un error del tipo MiError puesto que cada función invoca explícitamente este error.

• Cuando se detecta (atrapa) el error se entra en la sección catch donde es invocada la función printStackTrace vía la referencia e.NOTA: El método printStackTrace fue heredado ("Inherited") de la clase Exception.

• La Clase/método System.err representa el "Stream" de salida para cualquier error generado en un programa Java.

Datos de Entrada

60


A lo largo de los diversos métodos definidos en los distintos programas, se ha podido observar que estos definen sus Datos de Entrada seguido del nombre del mismo dentro de un paréntesis (calificadores nombre_del_metodo (datos_de_entrada)).La sintaxis de los datos de entrada se compone de dos partes: El tipo de Clase/Primitivo, seguido de la referencia empleada dentro dentro del método; por "default" los métodos principales (main) en Java deben especificar un Arreglo de String's en su definición, esto con la intención de recibir parámetros al momento de ser llamada la Clase, a continuación se describe un ejemplo que hace uso de este mecanismo:

• Utilización de Datos de Entrada .Código Fuente Nombres.java

public class Nombres { public static void main(String[] args) { System.out.println("Su nombre es: " + args[0]);

System.out.println("Sus apellidos son: " + args[1] + " " + args[2]); }}

Clase Nombres.• Se inicia este programa con la clásica definición de Clase.• Se define el método principal ( main ), el uso de corchetes ([]) al lado de la Clase String

indica un Arreglo de String's. • Se imprimen dos mensajes a pantalla a través de la Clase System.out.println.

o El primer mensaje imprime el primer valor del arreglo de entrada, a través de su referencia args; nótese que este primer valor es indicado con el numero cero, esta es Sintaxis de arreglos la cual será descrita a fondo en otra sección.

o El segundo mensaje imprime el segundo y tercer valor del arreglo. Ejecución de Clase Nombres.Los valores de entrada para el método main son tomados directamente de la linea de ejecución del programa, por lo que una vez compilada la Clase (javac Nombres.java) la ejecución seria llevada acabo de la siguiente manera:

$ java Nombres Ana Rodriguez King

En este caso el primer valor del arreglo de String's seria el Nombre Ana, mientras el segundo y tercero serian Rodriguez y King respectivamente; inclusive si no proporciona ningún argumento será generado un error ("Exception"), a continuación se describe este mismo programa con un bloque try/catch para manejar el error de una manera apropiada :

Código Fuente NombresBlock.java

public class NombresBlock {


try {

System.out.println("Su nombre es: " + args[0]);

61

http://javabasico.osmosislatina.com/curso/progavanza2/datosentrada.htm


System.out.println("Sus apellidos son: " + args[1] + " " + args[2]);

} catch (ArrayIndexOutOfBoundsException ex) {

System.out.println("Esta tratando de accesar datos fuera del Arreglo");

} catch (Exception ex) {

System.out.println("Ocurrió un error genérico");

}

}

}

Clase NombresBlock.• La única diferencia entre esta Clase y aquella descrita anteriormente es el Bloque try/catch .

• Al estar siendo ejecutadas las instrucciones de la sección try, si es generado un error, se inicia la inspección sobre las secciones catch hasta que el error ("Exception") coincida con una declaración.

• En esta caso, si son omitidos algunos parámetros de entrada para el programa, dentro del bloque try se estaría tratando de accesar elementos no definidos en el arreglo, este tipo de error ("Exception") es precisamente ArrayIndexOutOfBoundsException, por lo que serán ejecutadas las instrucciones definidas dentro de este bloque.

• Ahora bien, nótese que las instrucciones del bloque catch con la Clase Exception nunca son ejecutadas, lo anterior se debe a que el programa termina al ser atrapado ("catch") en el bloque catch inicial; la única manera en que pudieran ser ejecutadas las instrucciones de este último bloque sería si el programa generara otro error ("Exception") distinto a ArrayIndexOutOfBoundsException.

El uso de Datos de Entrada descrito anteriormente es trivial, ya que es realizado antes de iniciarse la ejecución de un programa, en la siguiente sección será descrito el uso de "Streams" para la lectura/escritura de datos en archivos y otros elementos."Streams" Un "Stream" es un nombre genérico otorgado a un flujo de caracteres en un programa de computo, puede estar compuesto por los valores residentes en un archivo texto, datos introducidos interactivamente por un usuario o datos que desean ser colocados en determinado archivo.Un "Stream" es la representación más cruda de un juego de datos, pero una manera muy universal de accesar/guardar datos, inclusive la clase System.out.println utilizada en la gran mayoría de los programas de este curso también es un "Stream"; en Java existen diversas Clases utilizadas en conjunción de "Streams", a continuación se describen estas Clases :

• Clases utilizadas en "Streams" .java.io.InputStream y java.io.OutputStream Las principales clases para representar "Streams" son : InputStream y OutputStream, como su nombre lo indica la primera de estas es utilizada para "Streams" de Entrada (Input) mientras la segunda "Streams" de Salida (Output); a partir de estas dos Clases son derivadas todas las Clases que hacen uso de datos de entrada y salida.

62

http://javabasico.osmosislatina.com/curso/progavanza2/clasestream.htm


Algunas Clases que heredan ("Inherit") el comportamiento de InputStream son : FileInputStream y PipedInputStream y algunas Clases que heredan ("Inherit") de OutputStream son: ByteArrayOutputStream y ObjectOutputStream; existen otra gran cantidad de Clases que heredan ("Inherit") el comportamiento de estas Clases bases, inclusive la Clase/Método System.out.println es heredada ("Inherited") de la Clase java.io.PrintStream la cual a su vez desciende de java.io.OutputStream.

Se recomienda observar la documentación incluida en el JDK para conocer el uso,comportamiento y métodos de las diversas Clases heredadas ("Inherited") de InputStream y OutputStream.

java.io.Writer y java.io.Reader Existen otras dos variaciones para las Clases InputStream y OutputStream que son : Writer y Reader, la principal diferencia entre estas Clases es que las primeras ofrecen lo que es conocido como byte-orientated I/O, mientras Writer y Reader ofrecen character-based I/O, en otras palabras las Clases InputStream y OutputStream solamente soportan "Streams" de 8-bits byte, mientras las Clases Writer y Reader soporta "Streams" de 16-bits.

La importancia de 16-bits radica en Java utilizando Unicode, al utilizarse 8-bits no es posible emplear muchos caracteres disponibles en Unicode, además debido a que las Clases Writer y Reader son una adición más reciente al JDK, estas poseen mayor velocidad de ejecución a diferencia de sus contra partes InputStream y OutputStream.

Ambas variaciones siguen en uso hoy en día, inclusive existen dos Clases que permiten una conversión hacia estas Clases más recientes:

• InputStreamReader convierte un InputStream a Reader

• OutputStreamWriter convierte un OutputStream a Writer

En la siguiente sección serán descritos ejemplos que hacen uso de "Streams".

El uso de "Streams" en programación es un tema muy extenso y en ocasiones considerado muy abstracto, por esta razón son descritos dos ejemplos en las siguientes secciones:

• Utilización de un "Stream" para leer Archivos.

• "Stream" para escribir Archivos.

Código Fuente Calculo.java

import java.io.*;

public class Calculo {

public static void main(String[] args) throws IOException {

63

http://javabasico.osmosislatina.com/curso/progavanza2/stream2.htm

http://javabasico.osmosislatina.com/curso/progavanza2/stream.htm


String s;

int lineas = 1;

try {

System.out.print("Que archivo desea analizar ? ");

BufferedReader stdin = new BufferedReader(

new InputStreamReader(System.in));

String archivo = stdin.readLine();

BufferedReader sarchivo = new BufferedReader(

new FileReader(archivo));

while (( s = sarchivo.readLine()) != null)

lineas++;

System.out.println("El archivo " + archivo +

" contiene " + lineas + " renglones de Codigo.");

} catch (IOException exc) {

System.err.println(exc);

System.out.println("Asegurese de haber proporcionado " +

" la extension del archivo (\".java\")");

} finally {

System.out.println("");

System.out.println("Es la mejor manera de aprender Streams, practicando!");

}

}

64


}

Clase Calculo Esta Clase esta diseñada para interrogar al usuario sobre determinado archivo, leer su contenido y finalmente indicar al usuario el número de renglones que contiene; consta únicamente de su método principal (main) y un bloque try/catch/finally.

• De inicio son definidos dos campos para utilizarse dentro del método principal (main) .

• Posteriormente se define el bloque try/catch/finally con las siguientes características:

• try

o Se despliega una pregunta al usuario para que proporcione el nombre del archivo a leer.

o Es definida una Clase del tipo BufferedReader la cual permite archivar datos temporales en memoria ("Buffer")

o El argumento que recibe al ser generada la Clase anterior es otra Clase llamada InputStreamReader, la cual permite leer datos de un "Stream", en este caso siendo System.in que representa el shell de ejecución.

o Se extrae el nombre del archivo a través del método readLine() y es asignado a una referencia de String.

o Es generada una nueva instancia de la Clase BufferedReader a la cual será asignada el archivo en cuestión.

o El argumento que recibe al ser generada la Clase anterior es otra Clase llamada FileReader, la cual contiene los mecanismos necesarios para leer un Archivo, y en este caso recibiendo el nombre del archivo.

o Se entra en un ciclo while el cual permanecerá activo hasta que el resultado del método readLine() sobre la referencia definida anteriormente equivalga a null. NOTA: El método readLine retorna un resultado null ya que el archivo no contenga lineas.

o Dentro de cada iteración de ciclo se incrementa la variable (primitivo) lineas la cual representa el número de lineas en el archivo.

o Finalmente se envía a pantalla el resultado obtenido del ciclo.

• catch

o Dentro de está sección del Bloque se intenta atrapar un error ("Exception") del tipo IOException, este tipo de error es generado al no poderse iniciar lectura/escritura en un programa.

o En este programa el error sería generado al intentarse leer un archivo inexistente proporcionado por el usuario.

o En caso de generarse este error, se envía a pantalla una sugerencia así como el error completo.

65


• finally

o Esta sección del Bloque describe instrucciones que siempre deben ser ejecutadas independientemente de ser generado un error ("Exception") o no.

o Se imprime a pantalla un mensaje cada vez que sea ejecutado el programa, ocurra o no ocurra un error ("Exception").

En la siguiente sección será descrito el uso de "Streams" para escribir hacia archivos.

Código Fuente LeerArchivo.java

import java.io.*;

public class LeerArchivo {

public static void main(String[] args) throws IOException {

// Leer el Codigo Fuente de este Archivo

BufferedReader in = new BufferedReader(

new FileReader("LeerArchivo.java"));

String s, s2 = new String();

while ((s = in.readLine()) != null)

s2 += s + "\n";

in.close();

// Leer Datos Interactivamente

BufferedReader stdin = new BufferedReader(

new InputStreamReader(System.in));

System.out.print("Introduzca cualquier dato: ");

s2 += "Usted agrego la linea \" " + stdin.readLine() +

" \" en la linea de comandos";

66


// Depositar Datos en un Archivo de Texto

try {

BufferedReader leer = new BufferedReader(

new StringReader(s2));

PrintWriter escribir = new PrintWriter(

new BufferedWriter(new FileWriter("Archivo_Stream.txt")));

int lineaNo = 1;

while ((s = leer.readLine()) != null)

escribir.println(lineaNo++ + ": " + s);

escribir.close();

} catch (EOFException e) {

System.out.println("Final de Stream");

}

}

}

Clase LeerArchivo Esta Clase esta diseñada para leer el archivo de Código Fuente presente, leer un renglón proporcionado al momento de ejecutarse el programa y finalmente depositar todo el contenido en otro archivo; al igual que el ejemplo anterior consta únicamente de su método principal (main) y un bloque try/catch.

Lectura de Datos

• En la primer sección es definida una Clase BufferedReader, la cual lee el archivo de Código Fuente, nótese que no es necesario colocar esta declaración dentro de un bloque try/catch puesto que ya se sabe que el archivo existe.

• Se define un ciclo while que permanecerá activo hasta que el resultado del método readLine() sobre la referencia definida anteriormente equivalga a null. NOTA: El método readLine retorna un resultado null ya que el archivo no contenga lineas.

• Dentro de cada iteración, es concatenado cada renglón leído del "Stream" y colocado en la variable s2.

• Es definida otra Clase BufferedReader la cual es empleada para datos introducidos de la consola (System.in).

• El valor introducido por el usuario es concatenado a la variable s2 que contiene el archivo de código fuente.

67


Escritura de Datos

• Se inicia un Bloque try/catch.

• Se declara una instancia de la Clase BufferedReader , la cual recibe como parámetro de entrada el String definido en la sección de lectura.

• Es definida una Clase PrintWriter que permite escritura de "Streams", esta Clase recibe como parámetro de entrada la Clase BufferedWriter la cual a su vez recibe la Clase FileWriter, esta última toma como parámetro el archivo que será generado (Archivo_Stream.txt).

• Se genera un ciclo while, el cual en cada iteración asigna los valores de cada renglón leído hacia la referencia de la Clase PrintWriter.

• Se define un error ("Exception") del tipo EOFException el cual sería generado en caso de llegar a un fin prematuro del archivo.

68

curso Basico java

Documents

Transcript of curso Basico java