P. 1
curso Basico java

curso Basico java

|Views: 8,468|Likes:
Published by m4lote

More info:

Published by: m4lote on Feb 28, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

04/02/2013

pdf

text

original

Sections

  • El Proceso de Abstracción, Lenguajes Computacionales y Objetos
  • Java y sus Características
  • JDK/J2SE
  • Un Programa Java
  • Código Fuente Basico.java
  • Metodo principal main
  • Librerías ("Packages") y JAR's
  • Estructura de Directorios para utilizar Librerías ("Packages")
  • Código Fuente Pantalla.java
  • Utilización de Librerías ("Packages")
  • Archivos JAR ("Java Archives")
  • Generación de Archivo JAR
  • Observar contenido de Archivo JAR
  • Extracción de Archivo JAR
  • La Variable CLASSPATH
  • Observando la Variable Ambiental CLASSPATH
  • Modificar la Variable Ambiental CLASSPATH
  • Utilizando la variable CLASSPATH al invocarse java o javac y otro comando
  • Objetos y Primitivos
  • Código Fuente Capsulas.java
  • Clase Capsulas
  • Uso de Sufijos
  • Campos("Fields") y Métodos
  • Clase Automoviles
  • Código Fuente Fecha.java
  • Clase Fecha
  • Significado de return
  • Constructores
  • Código Fuente Arboles.java
  • Clase Arboles
  • Constructor Obligatorio
  • Métodos y Parámetros por Referencia
  • Generación de Documentación (Vía Comentarios)
  • Comentarios en Java
  • Otros parámetros (@) para Comentarios en Java
  • Generación de Documentación
  • Herencias ("Inheritance")
  • Definición de Dos Clases y Herencias ("Inheritance")
  • Clase Radio
  • Condicionales if/else
  • Clase Condicional.java
  • Codigo Fuente Tercia.java
  • Clase Tercia
  • Uso de los Ciclos for y while
  • Sintaxis del Ciclo for
  • Clase PruebaFor
  • Sintaxis del Ciclo while
  • Clase PruebaWhile
  • Clase BreakYContinue
  • Código Fuente LabelFor.java
  • Resultados de Ejecutar Clase LabelFor
  • Resultados de Ejecutar Clase LabelWhile
  • Uso de switch
  • Sintaxis del switch
  • Código Fuente Meses.java
  • Clase Meses
  • Código Fuente Meses2.java
  • Clase Meses2
  • Operadores Matemáticos, Relacionales y Lógicos
  • Clase Asignacion
  • Clase Equivalencia
  • Clase OperadoresMat
  • Código Fuente AutoInc.java
  • Clase AutoInc
  • Clase Calificaciones
  • Codigo Fuente Trilog.java
  • Clase Trilog
  • Clase OperaLogico
  • Definición de Errores y Bloques try/catch/finally
  • Sintaxis del Bloque try/catch
  • Sintaxis del Bloque try/catch/finally
  • Clase MiError
  • Clase DefinirErrores
  • Código Fuente Nombres.java
  • Clase Nombres
  • Ejecución de Clase Nombres
  • Clase NombresBlock
  • "Streams"
  • java.io.InputStream y java.io.OutputStream
  • java.io.Writer y java.io.Reader
  • Código Fuente Calculo.java
  • Clase Calculo
  • Clase LeerArchivo

M4lote

Curso Java Básico

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

M4lote

Curso Java Básico
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

M4lote

Curso Java Básico

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

• lib: Contiene las librerías (Clases) base empleadas en la generación de la gran mayoría de programas Java.M4lote Curso Java Básico "Stubs" y "Skeletons" a través de IDL e inclusive una implementación de un ORB ("Object Request Broker") para interactuar con ambientes CORBA.jar | | javac* dt.java 4 . entre otros ejecutables. La estructura de directorios del JDK/J2SE es la siguiente: JDK 1. Para entrar en materia es necesario escribir nuestro primer programa Java. la estructura se encuentra dividida en tres grandes partes : • bin: Incluye los ejecutables para la generación de programas Java.4. Un Programa Java. el cual a su vez se encuentra sub-dividido en distintos directorios.jar ext security i386 applet fonts charsets.jar bin lib javap* | ________ ___|___ _________ ________ _______ javah* java* | | | | | | javadoc* rt. • jre: Incluye el ambiente necesario para ejecutar programas Java.out. Dependiendo de la manera en que haya instalado la documentación del JDK. el cual ilustra la sintaxis así como estructura de un programa básico.jar | / \ | / \ localedata.java public class Basico { public static void main(String args[]) { System.2 ___________|_________________ | | | bin lib jre | | ________|__________ java* tools. Código Fuente Basico. } } Programa Java Introducción Basico.jar server client Como se puede observar.println("Un despliegue de Datos"). se recomienda observarla en estos momentos para que se familiarice con sus Clases Base.

Nótese que el método inicia con letra minúscula. esta es otra convención utilizada para diferenciarse de las distintas clases. 5 . esto es. dicho método es invocado por "default" al ejecutarse el programa (Clase). ambos inician con letra mayúscula lo cual es una convención llevada acabo para la definición de Clases. En el caso del programa Basico. así como dar cierta estructura para mantener una organización de código. para ejecutar este Byte-Code es empleado el comando java: $ java Basico Al invocar el comando anterior será ejecutada la Clase Basico. en este caso el archivo Basico. • 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. Para generar una Clase compilada (Byte-Code) se utiliza el comando javac : $ javac Basico. Para definir una Clase se utiliza el vocablo class así como un calificador de acceso.out.M4lote Curso Java Básico 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.class. • Finalmente la Clase/Método System.class. al igual que otros lenguajes.java debe incluir una definición de una Clase llamada Basico.java únicamente es definido el método main. Nótese que el comando java recibe el nombre de la Clase sin la extensión . Conforme empieza a crecer un desarrollo de Software surge la necesidad de reutilizar ciertos componentes que ya han sido escritos.class. Dentro de la definición de la Clase se deben incluir los respectivos métodos que podrán ser invocados. es este sentido inalterable se refiere a sus características: • Siempre debe incluir los calificadores : public y static. siempre debe indicar el valor void como retorno. 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. Librerías ("Packages") y JAR's. 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. denominadas "packages" en el mundo Java . Aunque no es un requerimiento definir el método main dentro de toda Clase Java. 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[]). por ende. al momento de ejecutarse determinada Clase siempre será ejecutado todo el contenido dentro de dicho método. en este caso se utiliza el calificador public. dicho método representa el único mecanismo automático para realizar tareas al invocarse una Clase. • Nunca puede retornar un valor como resultado. nótese que ambos nombres coinciden en su sintaxis. esta organización se lleva acabo mediante librerías.println envía un mensaje a la pantalla Metodo principal main El método principal main de una Clase Java es inalterable.java Lo anterior genera un archivo llamado Basico. esto es.

esto es. lo anterior permite evitar la tan conocida Colisión de Nombres en Software. 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. se debe mencionar que no existe ninguna restricción en el número de directorios anidados. adoptando una convención a partir de Dominios en Internet. 6 . lo anterior se ilustra mejor a través de un ejemplo: • • Generación de Librerías ("Packages") . es necesario crear una estructura de directorios para generar las determinadas Clases. nuestros programas y por ende librerías ("packages") estarán basados en el nombre de la empresa/dominio para la cual son diseñados. es posible que existan librerías de 5 o 10 niveles de profundidad. observe: +-com+| +-osmosislatina+| +-escritura+| +-graficas+| +-correo+| +-errores+| +-auxiliares+- Lo anterior demuestra una estructura para las librerías del dominio com. además de esto. 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. 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. Utilización de Librerías ("Packages") . esto es. 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.osmosislatina.M4lote Curso Java Básico Java toma una perspectiva nueva respecto a otros lenguajes. 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 compilar esta Clase basta ejecutar el comando: • $ javac Pantalla. public class Pantalla { public static void sinSalto(String s) { System.osmosislatina.println(s).osmosislatina.out. } public static void conSalto(String s) { System. • Se define la Clase con los respectivos métodos sinSalto y conSalto.graficas. 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. esto es llevado acabo mediante el calificativo import como se demuestra a continuación : import com.out. Lo anterior sería incluido en todos los programas pertenecientes a la librería ("Package") com. Utilización de Librerías ("Packages") Para emplear Librerías("Packages") en un programa es necesario importarlas.print(s). 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.escritura. • NOTA 2: Observe que esta Clase no posee el método principal main.java Lo anterior genera el archivo de ByteCode : Panatalla. En la siguiente sección será diseñado un programa que haga uso de esta librería ("package").M4lote Curso Java Básico Además de la generación de estos directorios. en base a su ambiente (Linux o Windows) por favor genere dicha estructura para colocar esta Clase package com.escritura.Recuadro. • NOTA: Recuerde que este programa debe residir dentro del directorio com/osmosislatina/escritura/. } } Primeramente se declara la librería ("package") a la que será asignada el programa a través del vocablo package.escritura.osmosislatina. 7 . se debe incluir un calificador de la librería en el código fuente de cada Clase : package com.osmosislatina.class.

las características del uso de import son las siguientes: • Se debe declarar al inicio de un programa. primera. • 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.M4lote Curso Java Básico La declaración anterior permite que la clase Recuadro de la librería ("Package") com.java. aunque posterior a la definición de package (si existiese) . System. los detalles de esta rutina serán descritos en la sección de CLASSPATH. lo anterior se debe a que esta Clase requiere ubicar (importar) las Clases de la Librería ("Package") com/osmosislatina/escritura. • 8 .conSalto("Esto es un renglon CON salto de linea"). razón que también esta relacionada con la variable CLASSPATH y será descrita a fondo en su sección. • Para ejecutar este programa también se requiere descender al directorio raíz de la librería ("Package").conSalto("Esta linea si tiene salto!"). antes de la definición de la clase. primera. primera. } } Primeramente se declara la librería ("package") a la que será asignada el programa a través del vocablo package. public class MandaPantalla { public static void main(String args[]) { Pantalla primera = new Pantalla().sinSalto("Linea Continua"). esto es.escritura.conSalto("Esta linea tambien tiene salto").osmosislatina.osmosislatina. esto es. Código Fuente MandaPantalla. aunque esta Clase radique dentro del directorio com/osmosislatina/auxiliares es necesario llevar acabo la compilación desde la raíz (. • Se pueden utilizar un numero ilimitado de import. • Posteriormente se importan las Clases que serán utilizadas en el programa a través del vocablo import. si ha generado 100 o 500 clases sería muy impráctico distribuir la estructura de directorios a un tercero para ser utilizada. primera.graficas este disponible en el programa en cuestión. primera.auxiliares.sinSalto("Termina sin salto").osmosislatina. La siguiente Clase debe ser colocada bajo la estructura de directorios com/osmosislatina/auxiliares. • Es posible importar todas las clases de una librería a través de un asterisco (*).java La siguiente Clase manda llamar métodos definidos en la Clase Pantalla.out. en base a su ambiente (Linux o Windows) por favor genere dicha estructura para colocar esta Clase package com. para este problema han sido diseñados los archivos JAR ("Java Archives"). import com.println(" Se termina el uso de funciones").*.sinSalto("Linea Continua"). primera. 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. • 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./com).

observar y descomprimir archivos JAR. en ella se definen los directorios base de Clases así como cualquier archivo JAR que requiera ser cargado al compilar/ejecutar programas Java. Observar contenido de Archivo JAR Para observar el contenido de un archivo JAR.jar.jar El comando anterior despliega el contenido del archivo JAR osmosislatina. esto se realiza a través del siguiente comando: $ jar xvf osmosislatina. a continuación se describen estos tres casos. La Variable CLASSPATH.jar. 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 ? .jar con todos los archivos . se utiliza un comando similar: $ jar tvf osmosislatina. En la siguiente sección se describe como son utilizados estos archivos JAR en la compilación/ejecución de programas Java.jar El comando anterior genera una estructura de directorios con el contenido del archivo JAR osmosislatina.jar * Al ejecutar el comando anterior se genera una archivo JAR llamado osmosislatina. En todo JDK/J2SE se incluye el comando jar el cual permite generar. • Declarar dichas Clases de una manera más eficiente en la variable CLASSPATH.class que residen en la estructura de directorios. ya sea java o javac. 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.M4lote Curso Java Básico Generación de Archivos JAR ("Java Archives") . lo anterior permite: • Distribuir/Utilizar Clases de una manera eficiente a través de un solo archivo. NOTA: Este comando únicamente despliega el contenido. Archivos JAR ("Java Archives") Una archivo JAR es simplemente un archivo comprimido que incluye una estructura de directorios con Clases. 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. Extracción de Archivo JAR En ocasiones es conveniente extraer el contenido de un archivo JAR para llevar acabo modificaciones. la extracción de un archivo JAR se describe a continuación. A través de esta variable se indica donde residen las Clases/Librerías("Packages") de nuestro ambiente. 9 . la respuesta a esta pregunta es la conocida variable CLASSPATH.

• Las estructuras de directorios ubicados bajo /root/mislibrerias también serán localizadas al invocar el JVM ("Java Virtual Machine"). el valor de CLASSPATH declarado anteriormente significa : • El archivo JAR llamado tools. los valores de la variable CLASSPATH se encuentran separados por dos puntos (:) [ o punto y coma (.. • Finalmente la ultima declaración en CLASSPATH (:.jar.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. • 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.. 10 .:) 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 bajo el directorio /usr/local/jdk/lib estará accesible al compilar/ejecutar programas Java.) para Windows].%CLASSPATH%. Como se puede observar en el despliegue anterior.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").M4lote Curso Java Básico Utilización de la Variable CLASSPATH .jar:/root/mislibrerias/:. Localize "CLASSPATH" en las variables del usuario ("User Variables") y variables de Sistema ("System Variables").: Para observar la variable CLASSPATH en un ambiente Windows NT/2000/XP se utiliza el siguiente comando : Seleccione: Start.

será únicamente el Shell existente el cual reflejará estos cambios. Utilizando la variable CLASSPATH al invocarse java o javac y otro comando. para esto pueden ser pasados parámetros al tiempo de invocar los comandos java o javac : 11 .M4lote Curso Java Básico El comando anterior modifica el valor de la variable CLASSPATH agregando el archivo JAR (osmosislatina. En Windows NT: Seleccione el Tab Environment En Windows 2000/XP : Seleccione el Tab Advanced Posteriormente entre en Variables de Entorno ("Environment Variables"). Cabe mencionar que al modificar la variable CLASSPATH de esta manera.jar). lo anterior en Sistemas Unix se hace modificando el archivo /etc/profile o el perfil del usuario ~/. Localize o genere la variable "CLASSPATH" en variables de Sistema ("System Variables").Settings -Control Panel y el icono System. el termino $CLASSPATH (%CLASSPATH% en Windows) indica el valor previo de la variable.bashrc. por lo que modificar la variable CLASSPATH al nivel de ambiente sería innecesario. esto es. si usted posee otros programas que hacen uso de Java será necesario modificar el valor de CLASSPATH al nivel de sistema. En ocasiones es necesario cargar/ubicar ciertas librerías("packages")/clases que solo serán utilizadas ocasionalmente. 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. lo cual permite mantener los valores pre-existentes.

java [Linux] C:> javac -cp "%CLASSPATH%. sin embargo. al ser diseñado un programa existen diversas funciones/métodos y variables dentro de éste. ya que puede quebrantar dependencias forjadas en versiones previas.java.. 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.java [Windows] o $ javac -cp "$CLASSPATH:.jar.M4lote Curso Java Básico $ javac -classpath "$CLASSPATH:. lo cual permite ubicar/cargar librerías("packages")/Clases al momento de ejecución. campo o clase. Calificadores: Public. mientras otras permanecerán inmóviles. además de los calificadores de acceso que permiten restringir el uso de métodos/campos a determinadas situaciones.:/lib/postgresql. Static y Final.jar" Conexion. también existen otros calificadores que afectan directamente la creación y uso de instancias por clase estos calificadores son static yfinal. se le ha solicitado una modificación radical a estos objetos base. Ahora bien. El uso de calificadores de acceso en Java tiene sus bases en el uso de librerías ("packages").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. la importancia de estos cambios requiere que sean utilizados calificadores para permitir/negar el acceso a ciertos segmentos del programa. Private.jar. sea cargado el archivo JAR postgresql. El uso del calificador public significa que toda definición será accesible de cualquier punto.jar" Conexion. Este mismo mecanismo puede ser utilizado para los diversos comandos Java... algunas de estas requerirán ser modificadas conforme incrementen las necesidades del programa.C:\osmosislatina. si se intenta accesar cualquier elemento de este tipo dentro de otra Clase será generado un error de compilación.java [Linux] C:> javac -classpath "%CLASSPATH%. El calificador private indica que dicho componente será accesible únicamente dentro de la Clase en cuestión. Su uso implica un acceso global.:/lib/postgresql.C:\osmosislatina. private : Solo en la misma Clase . desde luego el uso de este calificativo en Clases que serán modificadas constantmente es fuertemente desalentado. 12 .. public : Acceso libre . Protected. Conexion. Conexion. ya sea un método. analicemos el siguiente caso: Usted ya diseño 300 clases que están siendo re-utilizadas por otros programas.jar además del valor actual ($CLASSPATH en Linux o %CLASSPATH% en Windows) de la variable ambiental CLASSPATH.

cuando no es empleado ninguno de los calificadores de acceso mencionados anteriormente los elementos son considerados amigables. su uso esta relacionado directamente al uso de instancias en Clases. y es bajo estas dos circunstancias que es empleado el calificador static. conforme avance el curso serán descritos diversos fragmentos de código para dejar en claro su uso. pero tomemos el caso de la Clase mencionada al inicio de este curso de una Lampara. El primer uso de static puede ser poco evidente. static : Una sola instancia . conforme se avance en el presente curso serán ilustrados otros ejemplos con este mecanismo. como fue mencionado anteriormente. 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. esto implica que todo campo/método carente de calificador será accesible dentro de todas Clases pertenecientes a su misma librería("package"). la Clase hijo tendrá acceso a todos aquellos campos/métodos definidos como protected en padre. desde luego la descripción anterior esta trivializada. 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. no es lo mismo llamar/invocar que crear/generar. pero no aquellos declarados como private en padre. • NOTA: Lo anterior no implica que no puedan ser generadas instancias dentro de un elemento static. La teoría del concepto static puede ser un poco difícil de digerir. esto implica que su comportamiento siempre será el mismo independientemente de la instancia que realza su llamada. El uso de protected es utilizado bajo los conceptos de Herencias ("Inheritance"). El uso del vocablo static ha venido siendo utilizado en los métodos principales (main) de los programas escritos anteriormente. poseer una instancia ya definida para poder ser invocados. en caso de requerirse un elemento como un apagador pudiera resultar sobrado generar una instancia para cada Lampara. sin embargo. aunque este tema será descrito en otra sección. 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.M4lote Curso Java Básico El calificador private suele utilizarse en Clases que serán modificadas continuamente. aunque no aquellos que utilicen el calificador private. si determinada Clase hijo hereda ("inherit") el comportamiento de una Clase padre. sin embargo. mediante protected es posible accesar elementos de la Clase Hereditaria ("Inherited"). Finalmente. • 13 . 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. • Todos los elementos definidos dentro de una estructura static deben ser static ellos mismos . o bien. Ningún Calificador : Clase en Librería y misma Clase . La segunda situación para el uso de static puede ser ejemplificada perfectamente a través del método main Java. protected : Clases Heredadas y misma Clase. esto permite evitar futuros quebrantos en otras Clases como fue mencionado al inicio. En otras palabras.

String let = new String("Algo sencillo") La declaración anterior no solo genera una instancia nueva de la Clase String. dichas estructuras son conocidas como primitivos. 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. sin embargo. pudo notar que todo gira alrededor de instancias de Objetos que son manipuladas a través de referencias: Lampara candil = new Lampara().0f Float double 64-bit IEEE754 IEEE754 0. es por esto que Java ofrece un mecanismo simplístico para definir estructuras de datos como alternativa a utilizar Clases/Objetos. De igual manera que la utilización de static el uso de final será ilustrado conforme se avanze en este curso. Objetos y Primitivos. La declaración anterior genera una referencia. sino le asigna un valor inicial ("Algo sencillo") el cual es asignado a la referencia let. Al diseñar sus primeros programas en Java.prender(). A diferencia de static que implica una sola instancia. En la siguiente tabla se describen los diversos primitivos disponibles en el lenguaje Java: Tipo de Valor Valor Valor Tamaño "Wrapper" Primitivo Mínimo Máximo Default boolean false Boolean `\u0000' char 16-bit Unicode 0 Unicode 216. esta no es asociada con ninguna instancia de Objeto. El hecho de generar instancias de objetos es un proceso involucrado ( hablando en términos computacionales mas no en sintaxis ) . Generalmente final es utilizado en aquellos elementos que no serán modificados al momento de ejecutarse ("Run-Time") un programa o clase . El calificador final estrechamente relacionado con el uso de static implica una asignación única y definitiva al elemento de una clase.M4lote Curso Java Básico final : Una sola instancia y definitiva. donde el generar una instancia de Clase resultaría en un proceso tardado y mecánico. para llevar acabo este proceso es necesario utilizar el vocablo new.0d Double 14 . candil. Al utilizar referencias en Java estas pueden ser inicializadas sin que pertenezcan a ninguna instancia de Objeto: String let. 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.1 Character (null) byte 8-bit -128 +127 (byte) 0 Byte 15 15 short 16-bit -2 +2 -1 (short) 0 Short 31 31 int 32-bit -2 +2 -1 0 Integer 63 63 long 64-bit -2 +2 -1 0L Long float 32-bit IEEE754 IEEE754 0. el termino final lleva dicha instancia a una definición única y como su nombre lo implica final. en efecto logrando un nivel de eficiencia en ejecución. a través de final se asigna un valor que no podrá ser modificado bajo ninguna circunstancia al momento de ejecución ("Run-Time).

a continuación se describen los mecanismos para realizar este tipo de conversiones : • Uso de "Wrappers" y primitivos en Java . // sufijo para primitivo float float f3 = 1. // sufijo para primitivo long long l2 = 200l. // sufijo para primitivo double double d2 = 14D. en la tabla anterior se describen los rangos de dichos primitivos así como sus respectivos "Wrappers". vale mencionar que existen diversos mecanismos para convertir de Clases tipo Objeto ("Wrappers") a primitivos y viceversa.java public class Capsulas { public static void main(String[] args) { // Inicializar Primitivos int i1 = 12. sin embargo. posteriormente se genera una instancia de la Clase Character (Nótese el uso del vocablo new). // sufijo para primitivo float float f2 = 1e+11f. // Inicializar "Wrappers" con primitivos Integer wi1 = new Integer(i1). long l1 = 200L. int i2 = 300. La primer linea genera un primitivo el cual es asignado a la variable c. double d1 = 32e46d. float f1 = 1e-39F. 15 . estos "Wrappers" son Clases utilizadas como contra parte de primitivos: char c = 'x'. el uso de "Wrappers" (Objetos) para primitivos es empleado bajo ciertas circunstancias. Character C = new Character(c). // sufijo para primitivo long long l3 = 200. Código Fuente Capsulas.M4lote Curso Java Básico void - - - - Void Nótese que estos primitivos inician con letra minúscula. // sufijo para primitivo double double d3 = 1.

// Convertir/Imprimir Valores de "Wrappers" como float (primitivo) prt(wi1.longValue()).floatValue()). // Convertir/Imprimir Valores de "Wrappers" como double (primitivo) prt(wi1. // Convertir/Imprimir Valores de "Wrappers" como integer (primitivo) prt(wi1. prt(wf1.longValue()). prt(wl1. // Convertir/Imprimir Valores de "Wrappers" como long (primitivo) prt(wi1. prt(wf1.floatValue()). prt(wd1. prt(wd1.intValue()). prt(wl1.intValue()). prt(wd1.longValue()).doubleValue()). prt(wl1.floatValue()).doubleValue()).floatValue()).M4lote Curso Java Básico Long wl1 = new Long(l1). prt(wf1. Float wf1 = new Float(f1). Double wd1 = new Double(d1). prt(wf1.longValue()).doubleValue()).intValue()).doubleValue()). prt(wl1. 16 .

// Imprimir Valores prt(wi2). prt(wf2).intValue()). prt(wl2. // Inicializar "Wrappers" con "String's" Integer wi2 = new Integer(str1).43". prt(wf2.23".toString()). prt(wd2). String str2 = "57". Float wf2 = new Float(str3). prt(wd2. Double wd2 = new Double(str4). // Inicializar "Wrappers" con primitivos 17 . String str4 = "797.toString()). Long wl2 = new Long(str2). prt(wl2). // Inicializar "String's" con valores numericos String str1 = "7". // Convertir/Imprimir Valores de "Wrappers" como String's prt(wi2.toString()).toString()). String str3 = "3.M4lote Curso Java Básico prt(wd1.

out.parseLong(str2)).out. prt(wl3. } static void prt(Double d) { System.parseInt(str1)). prt(wd3.println("Un Long (\"Wrapper\") con valor " + l).parseDouble(str4)).parseFloat(str3)). 18 . Long wl3 = new Long(0). Double wd3 = new Double(0).M4lote Curso Java Básico Integer wi3 = new Integer(0).println("Un Integer (\"Wrapper\") con valor " + i). } static void prt(Long l) { System. prt(wf3.out. // Convertir/Imprimir Valores de "Wrappers" a través de "String's" // a su respectivo primitivo prt(wi3. Float wf3 = new Float(0). } static void prt(Integer i) { System.println("Un Float (\"Wrapper\") con valor " + f).out.println("Un String con valor " + s).out.println("Un Double (\"Wrapper\") con valor " + d). } static void prt(Float f) { System. } static void prt(String s) { System.

} static void prt(double d) { System. su uso se hace más evidente cuando los primitivos son empleados para realizar operaciones matemáticas con mayor precisión. tal sería el caso al realizar un "Cast" de double a int. } } Clase Capsulas • Como en todo programa Java .println("Un float (primitivo) con valor " + f). mediante esta utilización de "Casting" se puede ilustrar la pérdida de exactitud en primitivos. Uso de Sufijos Aunque el uso de sufijos no es obligatorio. } static void prt(float f) { System. Seguido se emplean una serie de declaraciones con el método prt para imprimir valores a pantalla.println("Un double (primitivo) con valor " + d). Tomemos un número definido como 14D.l.out. Dichos métodos auxiliares se encuentran disponibles para todo "Wrapper" de primitivo y permiten restringir el rango del mismo.f.D. esto en términos computacionales es conocido como "Casting" (Concepto ilustrado a más detalle en otra sección de este curso). 19 • . 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.out.M4lote Curso Java Básico } static void prt(int i) { System. nótese que en algunas declaraciones se emplea un sufijo para definir el valor del primitivo (L. lo anterior se hace con la finalidad de asignar un espacio apropiado para futuras manipulaciones numéricas. se inicializan cuatro "Wrappers" a través de los primitivos definidos anteriormente.d).println("Un long (primitivo) con valor " + l). • Se define el método principal main y dentro de éste se generan diversos campos ("fields").println("Un int (primitivo) con valor " + i). esta pérdida de precisión será ilustrada a continuación.out.out.F. esto permite que el número sea manipulado con otros primitivos double sin perder precisión. primeramente se define la Clase a través del vocablo class. } static void prt(long l) { System. en esta serie de declaraciones se manda imprimir el valor de los "Wrappers" definidos anteriormente a través de métodos auxiliares xxxxValue(). • • Posteriormente.

sin embargo . Son impresos a pantalla (a través de prt) los valores de los "Wrappers".doble_traccion). 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. Campos("Fields") y Métodos. los métodos ya fueron descritos en los ejemplos anteriores. System. jeep.cantidad + " Doble Traccion: " + ford.cantidad = 2. dicha impresión de "String's" como primitivos se logra a través de los métodos auxiliares parseXXX. 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.cantidad = 3. public static void main(String args[]) { Automoviles ford = new Automoviles(). un campo es un objeto o primitivo utilizado para guardar datos en cada instancia de un objeto : • Uso de Campos("Fields") en Java .java public class Automoviles { int cantidad. Se declara otra serie de "Wrappers" que son inicializados a través de los "String's" definidos anteriormente. ford. • • • • • • El uso práctico para emplear "Wrappers" y/o primitivos será explorado en una futura sección de este curso. boolean doble_traccion.doble_traccion = true. Cuando se define una Clase esta puede contener dos tipos de elementos: Campos ("Fields") o Métodos. Finalmente son definidos una serie de métodos prt que toman distintos argumentos de entrada . vw. Automoviles vw = new Automoviles().out. 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". Código Fuente Automoviles.M4lote Curso Java Básico Posteriormente son definidos cuatro "String's" con valores numéricos. 20 .println("Autos Ford: " + ford. Automoviles jeep = new Automoviles().

y aunque dicho calificativo puede ser empleado en métodos y Clases su uso más común es en campos.println("Autos Volkswagen : " + vw. primeramente se define la Clase a través del vocablo class. ahora bien.out. Posteriormente. lo anterior permite mayor eficiencia al momento de ejecutarse un programa ("RunTime"). nótese que a través de las referencias de cada instancia son manipulados los valores de los campos("fields"). reciben un valor "default" (primitivos) • • En Java existen ciertos campos que son definidos como final. Se define el método principal main y dentro de este se generan tres instancias de la Clase. nótese que aquellas instancias que no asignaron valores a sus campos("fields").cantidad + " Doble Traccion: " + jeep.M4lote Curso Java Básico System. 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 .cantidad + " Doble Traccion: " + vw.doble_traccion). cuando es utilizado final en referencias de Objetos se restringe que dicha referencia sea utilizada para apuntar hacia otro Objeto. } Clase Automoviles • • Como en todo programa Java . 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.*. en este caso primitivos. Al utilizarse final en variables (primitivos) estas toman un valor constante al llevarse acabo la compilación.out. System.println("Autos Jeep : " + jeep. se imprimen a pantalla los valores de las diversas instancias con sus respectivos campos("fields").java import java. return a. Código Fuente Fecha. las razones por las que es utilizado final pueden ser: Eficiencia o Diseño. el uso del vocablo final será explorado en otra sección de este curso. } 21 . esto permite realizar un diseño que prohibe a la referencia ser re-asignada.util.doble_traccion). su significado puede ser descrito con las siguientes palabras: "No puede cambiar". public class Fecha { public Date hoy() { Date a = new Date(). Inmediatamente después son definidos dos campos ("fields") dentro de la clase.

hoy()).out. Código Fuente Arboles. Se define el método principal main y dentro de este se genera una instancia de la Clase.out. • • • Significado de return.println(tiempo. System. tiene dos usos principales: • • Primeramente es una manera de indicar que el método en cuestión ha terminado. mandándose llamar el método hoy. a continuación se describen varios ejemplos utilizando constructores: • Utilización de Constructores .java. } } Clase Fecha • Se importan las Clases de la librería java. Como en todo programa Java . Es definido un método llamado hoy que retorna la fecha actual mediante un Objeto Date . Constructores. El uso del vocablo return no es obligatorio en la gran mayoría de métodos definidos en Java.util. a través de este tipo de métodos es posible generar diversos tipos de instancias para la Clase en cuestión.M4lote Curso Java Básico public static void main(String[] args) { Fecha tiempo = new Fecha().*. se emplea el vocablo return para evitar ambigüedad. sin embargo. donde se encuentra la Clase Date empleada para manipular fechas en Java. Un Constructor es un método especial en Java empleado para inicializar valores en Instancias de Objetos. } 22 . public class Arboles { public Arboles() { System. la principal característica de este tipo de métodos es que llevan el mismo nombre de la clase.println("Un árbol genérico"). Cuando en determinado método se manipula más de una instancia/primitivo del mismo tipo que será retornado. se define la Clase a través del vocablo class.

• Constructor Obligatorio."Pino"). al ser generada la instancia a través del vocablo new se pasa un parámetro. Posteriormente son definidos 4 Constructores.String tipo) { System.M4lote Curso Java Básico public Arboles(String tipo) { System. Arboles arbol2 = new Arboles("Roble"). primeramente se define la Clase a través del vocablo class.println("Un árbol tipo " + tipo).println("Un " + tipo + " de " + altura + " metros").out. nótese que cada uno recibe el mismo nombre de la Clase y posee distintos argumentos de entrada. el cual a su vez invoca la Clase System.out. Arboles arbol3 = new Arboles().println que imprime a pantalla.out. Arboles arbol4 = new Arboles(5. y es dependiendo de este parámetro que es llamado el Constructor correspondiente. } } Clase Arboles • • Como en todo programa Java . } public static void main(String args[]) { Arboles arbol1 = new Arboles(4). 23 . Dentro del método principal (main) son generadas cuatro instancias de la Clase. } public Arboles(int altura) { System. } public Arboles(int altura.out. como se puede observar. sin embargo.println("Un árbol de " + altura + " metros").. y la razón es que el compilador lleva acabo esta definición de Constructor vacío detrás de los escenarios. En los ejemplos anteriores del curso se pudo notar que no se hizo uso de Constructor alguno..

.. existen dos tipos de comentarios puros como tal : 24 . al emplear esta sintaxis se esta haciendo alusión a los campos de la Clase. Cuando son utilizados Constructores puede surgir la necesidad de inicializar algún campo perteneciente a la Clase. Comentarios en Java Primeramente vale hacer mencionar los tipos de comentarios utilizados en Java.. deberá existir un método vacío por el mismo nombre.. { } . esto trae consigo otro detalle en lo que concierne la asignación de valores dentro de un método. 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 el caso anterior. a continuación se describe un ejemplo : • Utilización de Comentarios . observe: public Class Cableado { int longitud. Aunque sería posible emplear distintos nombres para los valores de entrada. un concepto utilizado en Java para ambientes Web (JSP's/Servlets).. public Cableado(String tipo. esto de cierta manera salvaguarda a un programador al momento de definir métodos que no vayan a ser definidos erróneamente como Constructores. en Java la generación de Documentación es llevada en conjunción del código a través de comentarios. Lo anterior significa que si el compilador observa un método con el mismo nombre de la clase con argumentos (Constructor).M4lote Curso Java Básico existe una situación en la que es necesario definir un Constructor vacío y esta es cuando se hace uso de otros constructores. evitando el uso del vocablo this. dentro del constructor son utilizados como parámetros de entrada los mismos valores. • Generación de Documentación . 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 . la razón se debe a que dentro de un método puede surgir el requerimiento de accesar campos definidos en la Clase. Métodos y Parámetros por Referencia. dentro del constructor se desea asignar valores a los campos de una Clase. para tener acceso a los campos de la Clase se utiliza el vocablo: this.tipo = tipo this. sin embargo. . la sintaxis con el vocablo this es ampliamente utilizada en el caso de Constructores mencionado anteriormente. int longitud) this. en muchas ocasiones esta documentación ni existe..longitud = longitud. así como Java Beans. String tipo.

esto es.*. dependiendo de la ubicación de este comentario será generada la documentación. cualquier palabra entre /* y */ es considerada comentario. 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. 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. * @author Juan Sanchez 25 .M4lote Curso Java Básico /* Este es un comentario que expande diversas lineas. sin embargo. Existe otra Sintaxis especifica para definir los elementos dentro de los comentarios. si aparece antes de un elemento class es considerado documentación para la Clase y así sucesivamente. la cual se ilustra a continuación: import java.util. esto es. /** * Programa que Despliega la Fecha. a partir de ellos no son generados ningún tipo de documentación. /** A comentario para método */ public void f() {} } Todo elemento colocado entre los elementos /** */ será contemplado en la generación de documentación. al igual que todo renglón que inicie con //.

M4lote Curso Java Básico * @author jsanchez@osmosislatina. lo anterior permite generar listas enumeradas.java package com. dar mayor estilo a la documentación y cualquier otro formato disponible en HTML / XHTML . A continuación se ilustran dos Clases escritas anteriormente.out. genera un link la Clase> HTML / XHTML hacia la Clase en cuestión.out. /** 26 . así como el proceso para generar la documentación HTML / XHTML del código fuente Java. los anteriores son algunos elementos que pueden ser utilizados al definir documentación. Este parámetro es utilizado para indicar que una Clase ha sido repuesta por otra más reciente.println(new Date()).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. } } Los elementos que inician con el símbolo @ son utilizados para indicar parámetros específicos dentro de la documentación. al ser indicado este parámetro en una Clase/Método el compilador (javac) generará un aviso. En la siguiente sección serán ilustrados otros elementos @. 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 Elemento utilizado para hacer referencia a otras Clases.osmosislatina.com * @version 1. indicando que la Clase/Método ha sido repuesto. @deprecated Además de los parámetros anteriores también es posible escribir lenguaje HTML / XHTML entre los elementos /** */ . System. La definición de Clases para Errores será descrita en otra sección.println("Hoy es: "). @throws <Nombre de la Clase> Empleado para indicar la Clase utilizada al generarse un Error.escritura. con los respectivos comentarios para generar documentación: Clase Pantalla.

println(s).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. } /** 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.com * @version 1.out.print(s).java 27 . } } Clase MandaPantalla.out.M4lote Curso Java Básico * Programa con métodos auxiliares para salto de linea * y linea continua * @author Juan Sanchez * @author jsanchez@osmosislatina.

java com/osmosislatina/auxiliares/*.java) y los directorios com/osmosislatina/escritura y com/osmosislatina/auxiliares. primera.escritura. primera. primera. a continuación se describe su uso más básico: $ mkdir docs $ javadoc -d docs/ -version -author -use *.escritura.auxiliares. para observar otros parámetros que puede tomar el comando javadoc basta ejecutar : javadoc -help.conSalto("Esta linea si tiene salto!"). primera.M4lote Curso Java Básico package com. } } Generación de Documentación El comando javadoc posee una gran cantidad de parámetros para generar documentación. en este caso se esta indicando el directorio presente (*.*.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().conSalto("Esta linea también tiene salto"). /** * Programa para demostración de import en la Clase * @author Juan Sanchez * @author jsanchez@osmosislatina.6 * @see com. o -version: Implica que al ser generada la documentación sea desplegado el numero de versión.sinSalto("Termina sin salto"). import com. este aparecerá en la documentación.println(" Se termina el uso de funciones"). Al terminar este proceso será generada la documentación de las distintas Clases dentro del directorio docs. primera.osmosislatina. de ser definido en la Clase. primera. 28 .sinSalto("Linea Continua").osmosislatina.com * @version 1. o -author : En caso de ser definido el parámetro autor.java • • El primer paso antes de generar cualquier documentación Java es crear un directorio donde residirá la documentación.osmosislatina.out. o -use: Es el parámetro utilizado para indicar los directorios donde residen las Clases sobre las que será generada la documentación.java com/osmosislatina/escritura/*. System.conSalto("Esto es un renglón CON salto de linea").sinSalto("Linea Continua"). Posteriormente es invocado el comando javadoc con los siguiente parámetros: o -d docs: Indica el directorio donde será depositada la documentación (docs). en este caso se ha generado un directorio llamado docs.

println(r).java class Radio { private String r = new String("Radio: ").out. este mecanismo permite que nuevas Clases hereden el comportamiento de una Clase Base ya depurada y funcional. observe: El primer diagrama UML ("Universal Markup Language") muestra 3 Clases(Guitarra. en el proceso teniendo acceso a los métodos/campos ya creados con anterioridad .Triangulo) que heredan ("Inherit") de una Clase Base (Figura). a continuación se describe un ejemplo que hace uso de Herencias ("Inheritance"): • Uso de Herencias ("Inheritance") . } public void imprimir() { System. } public void volumen() { agrega(" volumen() "). en Herencias ("Inheritance") el termino reutilizable toma otro sentido al utilizado en la secciones anteriores al importarse Clases (import).Saxofón) que heredan ("Inherit") de una Clase Base (Instrumento).M4lote Curso Java Básico Herencias ("Inheritance") Uno de las partes medulares en un lenguaje orientado a Objetos es el uso de Herencias ("Inheritance") . } public void frecuencia() { agrega(" frecuencia() "). public void agrega(String a) { r += a. Código Fuente MiniComponente.mientras el segundo diagrama muestra 2 Clases (Circulo. uno más complejo y poderoso. el cual permite reutilizar Clases existentes con todas las funcionalidades/comportamientos ya diseñadas en ellas. } 29 .Piano.

x.imprimir().println("Probar la Clase Base: "). super.imprimir(). x. x. x.volumen() ").frecuencia() . x. System. } } public class MiniComponente extends Radio { // Cambiar el metodo ("Override") public void volumen() { agrega( " MiniComponente.M4lote Curso Java Básico public void modelo() { agrega(" modelo() ").volumen().modelo(). x.volumen(). } public static void main(String[] args) { MiniComponente x = new MiniComponente(). x.modelo().equalizador().volumen(). x. } public static void main(String[] args) { Radio x = new Radio(). // Llamar la version de la Clase Base } // Agregar metodo public void equalizador() { agrega(" equalizador() ").out. x.frecuencia(). 30 .

es posible ejecutar la Clase Radio a través del comando java Radio y observar los resultados iniciales. 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. Clase Radio. por lo que esta Clase solo será accesible internamente (O al paquete "package" si fuera incluida en alguno ). nótese que en la Clase Radio también existe un método con este nombre. sin embargo. han sido definidas dos Clases en el mismo archivo fuente llamado MiniComponente. El primer método llamado agrega. el hecho que existan dos Clases en el mismo archivo fuente no influye en ningún factor. posteriormente a través de la respectiva referencia se mandan llamar los distintos métodos de la Clase. es posible afirmar que todo MiniComponente incluye un Radio (AM/FM) entre sus dispositivos . de cualquier manera. Entrando al problema espacial ("real").esto es lo que se refiere como acceso amigable. descrito en la sección de Calificadores. Como se puede observar. nótese que se utiliza el operador +=. en este caso se opto por dicho diseño debido a razones didácticas. } } Definición de Dos Clases y Herencias ("Inheritance"). Los métodos frecuencia.M4lote Curso Java Básico Radio. Clase MiniComponente. Finalmente el método imprimir hace uso de la Clase System. Dentro de este mismo método. en este caso Radio.java. Al definir esta Clase se utiliza el vocablo extends que implica Herencia ("Inheritance"). aunque bien se pudo haber realizado el diseño de este manera por razones administrativas. inicialmente se hace una llamada al método agrega. no se utiliza ningún calificador de acceso. esto es conocido como override en lenguajes orientados a Objetos. si observa el resto de la composición de esta Clase notará que no existe ninguno por este nombre. volumen y modelo hacen uso del método agrega concatenando distintos valores. 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. Se define un campo tipo String con la referencia r. seguido de éste se indica la Clase que será heredada ("Inherited"). el cual es asignado un valor inicial de "Radio: ". debido a esto se ha decidido reutilizar(Heredar) el comportamiento de una Clase Base de Radio.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. • • • • • Una vez compilado el código fuente. dentro de esta Clase se esta modificando el comportamiento de dicho método.out. a través de este operador es posible concatenar diversos elementos.main(args). toma como valor de entrada un String y su función es concatenar diversos String's. El primer método definido se llama volumen. • Como cualquier Clase Java se utiliza el vocablo class. 31 . sin embargo. a continuación se describe la Clase Radio.

3)). La segunda llamada en este método es: super. donde todas son descendientes de la Clase Base java. } public static void main(String[] args) { System. son llamados con la implementación de la Clase Base.java • Primeramente se declara la Clase através del vocablo class. 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. los tres principales tipos son el conocido if/else.volumen. a través de esta linea se esta realizando una llamada hacia el método volumen definido en Radio. En Java al igual que otros lenguajes son utilizados condicionales que permiten controlar el flujo de ejecución en un programa. System.out. • Es definido un método llamado analisis el cual retorna una respuesta en base a las operaciones del condicional if/else.println(analisis(7. en este caso se esta haciendo uso de los métodos de la Clase Base. inclusive las Clases Base del JDK lo utilizan extensamente.java public class Condicional { static int analisis(int prueba. El uso de Herencias es ampliamente utilizado en diseños Java. notará en la parte superior el árbol de Herencias ("Inheritance") para la Clase correspondiente. Código Fuente Condicional. Condicionales if/else.Object.println(analisis(7. si observa la documentación de estas Clases. else resultado = 0. } } Clase Condicional.M4lote Curso Java Básico dentro de la Clase Base existe dicho método. int objetivo) { int resultado = 0. Dentro del método principal main se genera una instancia de la Clase MiniComponente. seguido de diversas llamadas a distintos métodos. una característica de este método es que utiliza el 32 .out. // Prueba igual a Objetivo return resultado.out.while y for. if(prueba > objetivo) resultado = +1. que también hace uso del método agrega. En el último paso del método main se realiza una llamada hacia el otro método main definido en la Clase Radio. 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. 7)). Una vez compilado el código fuente.println(analisis(3. a continuación se describen varios ejemplos con el uso de if/else: • Utilización de Condicional if/else .lang. el vocablo super indica una llamada hacia la Clase Base (Radio). nótese que aquellos no definidos dentro de la Clase. System. else if(prueba < objetivo) resultado = -1. 7)).

println(trio(20)). (punto y coma) 33 . a continuación se describe el uso del ciclo for y while : • • Ciclo for en Java . al no emplearse este mecanismo. caso contrario r*22. condición de terminación . se asume que el ciclo o condicional tendrá efecto únicamente en la linea contigua a su inicio. si esta expresión resulta verdadera es ejecutada la operación r*3. Uso de los Ciclos for y while El uso de Ciclos en lenguajes de programación es un concepto ampliamente utilizado. System. en el ejemplo anterior pudo notar que no fueron utilizadas llaves { } para delimitar las condicionales. } } Clase Tercia • Es definido un método llamado trio el cual hace uso de la variante if/else. esto se debe a que es llamado directamente del método principal main el cual también es static.M4lote Curso Java Básico • calificativo static. debido a que el vocablo static es empleado en métodos que no requieren instancias. imprimiendo los respectivos resultados a pantalla. Dentro del método principal (main) es invocado el método analisis en tres ocasiones. esto garantiza un posible error al invocar métodos estaticos. La Sintaxis empleada por el ciclo for es la siguiente: for (valores de entrada .Aunque es recomendable utilizar llaves ({ } ) para incrementar la legibilidad del código. • Dentro del método principal main es invocado el método trio en dos ocasiones.out. Sintaxis del Ciclo for. 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. Una característica del ciclo if/else así como los otros ciclos disponibles en Java es el uso de llaves { }. es importante señalar que esta sintaxis de no utilizar llaves ({ } ) es valida y muy común (Lamentablemente) .java public class Tercia { public static int trio(int r) { return r < 10 ? r*3 : r*22. la expresión boolean es r < 10. Utilización de Condicional while .println(trio(2)). si se realiza un llamado hacia determinado método de uno static éste también deberá ser static. Codigo Fuente Tercia. enviando a pantalla los respectivos resultados.out. } public static void main(String args[]) { System. iteración por ciclo) • Las tres partes del ciclo se encuentran separadas por . Uso de llaves ({ }) en Ciclos.

Cada parte del ciclo debe incluir al menos un elemento. Sintaxis del Ciclo while.out. • Dentro del Ciclo se utiliza la Clase System.random(). System. a la cual es posible agregar otros elementos a partir de una .M4lote Curso Java Básico La primer parte del ciclo especifica valores previo a su inicio. } } } Clase PruebaFor.java • public class PruebaWhile { public static void main(String[] args) { double r = 0. Código Fuente PruebaWhile. la cual esta directamente relacionada con los valores iniciales.99d) { r = Math. } } } Clase PruebaWhile. j = i * 2) { System. 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 o o • Dos variables iniciales (primitivos) i y j. la última parte especifica como serán manipulados los valores iniciales en cada iteración del ciclo. i < 5.java • public class PruebaFor { public static void main(String[] args) { for(int i = 1. while(r < 0. 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. 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. • Se inicia este programa definiendo la Clase en cuestión.out. j = i + 10. Código Fuente PruebaFor. i++. La condición para terminar el ciclo es definida cuando el valor de la variable i sea menor 5.println("i= " + i + " j= " + j).println para imprimir los valores de las variables i y j en cada iteración de ciclo. • La segunda parte indica la condición de terminación para el ciclo. (coma). • • Se inicia este programa con la clásica definición de class.println(r). • Finalmente. Se define el método principal ( main ). 34 .out.

este comportamiento se logra a través de los vocablos break y continue. } int i = 0. saltar una iteración en ciertas circunstancias. i++) { if(i == 74) break. Código Fuente BreakYContinue.out. // Siguiente Iteración System. el uso de corchetes ([]) al lado de la Clase String indica un Arreglo de String's. // Un ciclo "infinito": while(true) { i++. a continuación se describe su uso: • break/continue en Ciclos .java public class BreakYContinue { public static void main(String[] args) { for(int i = 0.99.println(i). Es impreso a pantalla (vía System. o bien.println) el valor de la variable r. la d al final del numero indica un número (primitivo) del tipo double . // Regreso al Inicio del Ciclo 35 . // Fuera de Ciclo if(i % 9 != 0) continue.M4lote Curso Java Básico Se define el método principal ( main ). int j = i * 27. • • • • • En ciertas ocasiones surge la necesidad de interrumpir un ciclo si ocurre determinada condición. 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. i < 100. que toma como valor de entrada un número (primitivo). el valor de la variable es modificado con un numero aleatorio a través de la función Math. if(j == 1269) break.random (proporcionada en las Clases Base del JDK). Se define un primitivo del tipo double con valor inicial de 0 (cero). // Fuera del Ciclo if(i % 10 != 0) continue. Dentro del ciclo.out.

es fuertemente desalentado debido a la poca legibilidad que resulta en el código. pero criticado "goto". Código Fuente LabelFor. excepto en los siguientes casos: o o Si el valor de la variable j equivale a 1269 se termina todo el ciclo debido al vocablo break.java public class LabelFor { public static void main(String[] args) { int i = 0. • • Antes de iniciarse un ciclo while se reinicializa la variable i a cero. Si la variable i no es múltiplo de 9 se interrumpe la iteración actual debido al vocablo continue. salvo los siguientes casos: o o Si el valor de la variable i equivale a 74 se termina todo el ciclo debido al vocablo break. • Etiquetas Labels en Ciclos. Otra variación para interrumpir y saltar iteraciones en ciclos es a través de Etiquetas (Labels). Dentro del ciclo se imprimen los valores de la variable i en cada iteración. Si la variable i no es múltiplo de 10 se interrumpe la iteración actual debido al vocablo continue. cada iteración es impreso el valor la variable a pantalla.) { // Ciclo Infinito interno: // Definción de Label 36 . este mecanismo logra un comportamiento similar al famoso. externo: // Definicón de Label for(. true . } } } 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. Aunque su uso es permitido.println(i).out.M4lote Curso Java Básico System.

k < 5. } if(i == 8) { prt("break externo"). i++. i++. // Incrementar antes del "Break" break. i < 10. } for(int k = 0. continue. } if(i == 7) { prt("continue externo"). k++) { 37 . if(i == 2) { prt("continue"). } if(i == 3) { prt("break"). break externo.M4lote Curso Java Básico for(. i++) { prt("i = " + i). // Incrementar antes del "Label" // continue externo.

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 .M4lote Curso Java Básico if(k == 3) { prt("continue interno").out. } } } } } static void prt(String s) { System.println(s).

39 . while(true) { i++. externo: while(true) { prt("Externo Ciclo while").java public class LabelWhile { public static void main(String[] args) { int i = 0. prt("i = " + i).M4lote Curso Java Básico break i=4 continue interno i=5 continue interno i=6 continue interno i=7 continue externo i=8 break externo Codigo Fuente LabelWhile. if(i == 1) { prt("continue").

continue externo. break. } } } } static void prt(String s) { System. } if(i == 7) { prt("break externo").println(s). } 40 .out. } if(i == 3) { prt("continue externo"). break externo.M4lote Curso Java Básico continue. } if(i == 5) { prt("break").

Dada una variable de entrada esta se define seguido del vocablo switch.M4lote Curso Java Básico } 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. break. 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. break. Sintaxis del switch. break. La Sintaxis empleada por un switch es la siguiente: switch (variable) { case <posible valor> : Instrucciones case <posible valor> : Instrucciones case <posible valor> : Instrucciones case <posible valor> : Instrucciones case <posible valor> : Instrucciones default : Instrucciones . este tipo de estructura es ideal cuando se requieren condicionales que lleven más de dos valores. break. A través de un Switch se posible definir una serie de tareas cada una asignada a una lista de valores. Se abre una llave para iniciar los posibles valores que pueda tomar dicha variable. 41 . • • : : : : : break.

switch (mes) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: numDias = 31.println("Septiembre"). case 5: System. case 3: System. case 9: System. break. break.out.println("Marzo"). esto se debe a la posibilidad que exista más de un valor que deba ejecutar las mismas instrucciones.println("Enero"). 42 . break. } } } Clase Meses • Se define un primitivo con valor de 8. case 6: System.out. break. 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. a continuación se describe este caso: Código Fuente Meses2. los cuales tienen como instrucción imprimir a pantalla el valor del mes correspondiente. break.out. int numDias = 0. case 7: System. break. case 11: System. switch (month) { case 1: System. break. case 4: case 6: case 9: case 11: numDias = 30. break. case 12: System.println("Diciembre").println("Julio"). case 8: System.out. cuyas instrucciones serán ejecutadas en caso que la variable del switch no coincida con los valores definidos.println("Noviembre").out.out. Cuando se describió la Sintaxis de un switch se mencionó que el uso de break al final de cada declaración (case) era opcional. • Dentro del switch son definidos valores del 1 al 12. break. break. case 4: System.M4lote Curso Java Básico Los juegos de valores son iniciados con case seguido del posible valor de la variable.out. break. • Un valor opcional es la definición de la linea default.println("Junio").println("Agosto"). Código Fuente Meses. int año = 2002.println("Mayo"). break.out.println("Abril").println("Febrero").java • public class Meses { public static void main(String[] args) { int month = 8. case 2: System.out.out.java public class Meses2 { public static void main(String[] args) { int mes = 10. case 10: System.out.println("Octubre"). el cual es utilizado como variable para un switch. break.out.

Numero n2 = new Numero(). Finalmente. no se puede definir un juego de String's y comparar sus valores. ya que al no indicarse se continúan evaluando los distintos valores restantes en un switch. a continuación se describe un ejemplo que demuestra el comportamiento de Asignación de valores para el lenguaje Java: • Asignación de Valores. esto es. Clase Meses2 En esta Clase el uso de switch varía. n1. break. en esta sección se describirán detalles más precisos acerca de su funcionamiento.M4lote Curso Java Básico break. sin embargo. al omitir el uso del vocablo break. ya que son agrupados distintos valores. el uso de break en un switch es critico ya que al no ser definido puede ocasionar un comportamiento errático. posiblemente causando un comportamiento no deseado. Antes de entrar en el uso de Operadores. vale mencionar que las datos que se puede evaluar a través de un switch son solo primitivos. else numDias = 28.out. } } } System. para este tipo de situaciones (String u otro Objeto) se requiere usar condicionales if/else anidadas. Operadores Matemáticos. a lo largo de los distintos programas escritos en este Curso se han empleado su gran mayoría. case 2: if ( ((año % 4 == 0) && !(año % 100 == 0)) || (año % 400 == 0) ) numDias = 29. En Java al igual que otros lenguajes existen diversos operadores que son empleados en diferentes secciones de un programa.println("Numero de Dias = " + numDias). } public class Asignacion { public static void main(String[] args) { Numero n1 = new Numero(). 43 . Código Fuente Asignacion. Relacionales y Lógicos.java class Numero { int i.i = 15.

i: " + n2.i: " + n1.i: " + n1.i + ".i: " + n2. se esta indicando que la referencia n1 apunte hacia aquella de n2.i + ". n2. n1 = n2.i.println("b) n1. System.i + ".out. mientras la segunda (Asignacion) incluye la lógica central del programa. n2.println("a) n1.i: 45 c) n1. Aunque el comportamiento del programa anterior parece predecible. la segunda impresión puede resultar confusa y esto se debe a la asignación n1 = n2.i: 45. o Se imprime a pantalla el valor de cada campo de las dos instancias.println("c) n1.i). 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. n1.M4lote Curso Java Básico n2.i). puesto que simplemente se imprimen los valores recién asignados. n2.i: 15. la instancia de n1 fue efectivamente perdida. 44 .i: " + n1.i cambia efectivamente hacia el mismo de n2. al ser llevada acabo esta asignación el valor n1. este mecanismo en Java es denominado aliasing y suele ser un poco difícil de entender para aquellos que inician en este lenguaje.i: 45 b) n1.i: 27. System. la ejecución del programa anterior da como resultado: a) n1. n2. o Se imprime a pantalla el valor de cada campo de las dos instancias.i: " + n2.i).out.i = 27. o Se modifica el valor del campo en la instancia n1 al valor de 27. Al utilizar la sintaxis n1 = n2. • 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. a partir de ese punto ambas referencias apuntan hacia la instancia del Objeto n2.i = 45. para muchas personas no familiarizadas con lenguajes orientados a Objetos puede resultar una sorpresa. n2. } } Clase Asignacion • En el código fuente son definidas dos Clases.out.i: 27 Los primeros resultados no presentan sorpresa alguna. El comportamiento anterior se debe a que fueron utilizadas referencias en la asignación de valores. n2. o A través de dichas referencias son asignados los valores correspondientes al campo i de la Clase. System. una de ellas (Numero) simplemente contiene un campo.

System.i.i = n2. Código Fuente Equivalencia.M4lote Curso Java Básico La tercer impresión es llevada acabo después de la asignación n1. las cuales son inicializadas con un valor de 75. Para evitar aliasing y mantener las dos instancias de Objetos se utilizaría una asignación más explicita : n1. 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).println(n1 == n2). puesto que ambas referencias apuntan hacia la misma instancia. al llevar acabo este proceso el valor n1. • Es llevada acabo una comparación entre ambas referencias. así como el valor de n2. 45 . 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. • Aunque el comportamiento del programa anterior parece predecible.i = 27.out. System. los resultados de este programa son falso (false) y verdadero (true).println(n1 != n2). 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.out. 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.java public class Equivalencia { public static void main(String[] args) { Integer n1 = new Integer(75).i será modificado. a continuación se demuestra un uso muy común de estos operadores: • Utilizando Equivalencias. Integer n2 = new Integer(75). } } Clase Equivalencia • La Clase anterior genera dos instancias de la Clase Integer. este resultado se debe a que la comparación llevada acabo por el programa es en base a referencias. Operadores Relacionales.i.

java import java. Código Fuente OperadoresMat."-=". En Java se encuentran disponibles los mismos operadores matemáticos que en otros lenguajes."*=". En los siguientes ejemplos se describe el uso de los diversos operadores matemáticos: • • Utilización de Operadores Matemáticos.println(s). 46 . cabe mencionar que los operadores relacionales "==" y "!=" funcionan acordemente ( o como aparentemente se pensaría ) con primitivos.out.M4lote Curso Java Básico Integer n2 = new Integer(75). public class OperadoresMat { // Metodo para Imprimir Mensaje a Pantalla static void prt(String s) { System."/=". Utilización de Operadores Auto-Incremento y Decremento. esta es llevada acabo mediante: "+=".*.out. además de esta sintaxis también existen los operadores de auto-incremento y auto-decremento que son representados por "++" y "--" respectivamente. a través de este método disponible en toda Clase es llevado acabo una comparación entre el valor del Objeto en sí . 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. System.util. } } • En el ejemplo anterior se hace uso del método equals.equals(n2)).println(n1. mencionados a continuación : Operador + = * / % Significado 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.

k). } public static void main(String[] args) { // Generar un numero Aleatorio Random rand = new Random().nextInt() % 100. i = k % j. prt("j . k = rand. prt("k * j". float f) { prt(s + " = " + f).k. j %= k.j). // Imprimir Valores de "j" y "k" prt("j". i = j + k. int i. prt("j %= k". } // Metodo para Imprimir un String y Float ("Overload") static void prt(String s.nextInt() % 100. int i) { prt(s + " = " + i). 47 . prt("j + k".M4lote Curso Java Básico } // Metodo para Imprimir un String y Entero ("Overload") static void prt(String s. prt("k". i). j). i). prt("k / j". prt("k % j". // '%' Limita a un valor maximo de 99 j = rand. i = j . i = k * j. i). i).k". i). j. i = k / j. k.

es una sobrecarga del nombre de un método. u = v * w. prt("v + w".M4lote Curso Java Básico // Prueba para numero Float float u. prt("v .v. pueden existir diversos métodos con el mismo nombre pero distintos parámetros de entrada. w).w. u -= v. prt("u -= v". v = rand. u). u).nextFloat(). } } Clase OperadoresMat A diferencia de otras Clases diseñadas en este Curso.nextFloat(). prt("v". u). v). en donde se puede modificar el comportamiento de un método con los mismos parámetros de entrada en Clases que hereden su 48 . al ser invocado dicho método ocurrirá el comportamiento apropiado en base a los parámetros de entrada.w. u = v / w. u).w". prt("u *= v". prt("u += v". u). u /= v. u = v . u). prt("v / w". prt("v * w". u). u *= v. esta Clase contiene tres métodos con el mismo nombre cada uno con distintos valores de entrada. prt("w". esto es. u = v + w. w = rand. "Overloading" no es lo mismo que "Overriding" El concepto descrito en esta sección es llamado overloading que como su nombre lo implica. Lo anterior es muy distinto al concepto de overriding descrito en Herencias ("Inheritance"). prt("u /= v". // Operadores Adicionales u += v. este comportamiento en Java es conocido como overloading. u).

68947333 /= v = 0. // Post-Incremento prt("i : " + i). // Post-Decremento prt("i : " + i). } // Metodo para Impresion 49 .: " + i--).w = -0.9460438 Código Fuente AutoInc.6748402 -= v = 0. La ejecución de este programa genera números aleatorios a través de la Clase Random. // Pre-Decremento prt("i-.java public class AutoInc { public static void main(String[] args) { int i = 1. prt("i : " + i).9460438 *= v = 0.7703622 + w = 1.k = -33 / j = 0 * j = -266 % j = 14 %= k = -5 = 0. un posible resultado (debido al uso de números aleatorios) es el siguiente: $ j k j j k k k j v w v v v v u u u u java OperadoresMat = -19 = 14 + k = -5 .7287964 = 0.4991586 .041565776 * w = 0.M4lote Curso Java Básico comportamiento. // Pre-Incremento prt("i++ : " + i++). prt("--i : " + --i). prt("++i : " + ++i).94604385 += v = 1. posteriormente se realizan diversas operaciones con primitivos empleando los distintos operadores matemáticos.5614372 / w = 0.

lang.println(s). int gramatica = -2. } } Clase AutoInc La clase hace uso de los distintos operadores para Auto-Incremento y Auto-Decremento de variables. Código Fuente Calificaciones.Math ofrece operaciones trigonométricas.55.lang.java public class Calificaciones { public static void main(String[] args) { int matematicas = 10. 50 .Math. el resultado de dicho programa se muestra a continuación: $ java AutoInc i:1 ++i : 2 i++ : 2 i:3 --i : 2 i-.M4lote Curso Java Básico static void prt(String s) { System. esta Clase bajo el nombre de java.: 2 i:1 Además de estos operadores matemáticos. double historia = 9. a continuación se describen algunos ejemplos empleando dicha clase : • Utilización de métodos en java. exponenciales y otras más.out. el lenguaje también posee una Clase estándar (en el JDK) para realizar operaciones más complejas.

// 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. prt("|" + biologia + "| es " + Math. prt("El techo de " + biologia + " es " + Math.abs(historia)).abs(matematicas)). prt("El techo de " + gramatica + " es " + Math. prt(biologia + " redondeado es " + Math.M4lote Curso Java Básico double biologia = 7.floor(matematicas)).ceil(biologia)).floor(historia)).floor(gramatica)). prt("El piso de " + historia + " es " + Math. // Valores Absolutos prt("|" + matematicas + "| es " + Math.round(historia)). // Redondeo de cifras al siguiente numero entero prt(historia + " redondeado es " + Math.3.ceil(historia)).round(biologia)). prt("El techo de " + historia + " es " + Math. prt("|" + historia + "| es " + Math. prt("|" + gramatica + "| es " + Math.floor(biologia)).ceil(matematicas)). prt("El piso de " + biologia + " es " + Math.abs(gramatica)).abs(biologia)). // Un numero entero es su propio piso ("floor") prt("El piso de " + matematicas + " es " + Math. // El piso ("floor") de un numero es el entero mayor // mayor o igual al mismo numero . 51 .ceil(gramatica)). prt("El piso de " + gramatica + " es " + Math.

min(matematicas. } // Metodo para Impresion static void prt(String s) { System." + gramatica + ") es " + Math. prt("min(" + matematicas + "." + gramatica + ") es " + Math.historia)). prt("max(" + matematicas + ".gramatica)).min(matematicas." + biologia + ") es " + Math." + biologia + ") es " + Math." + gramatica + ") es " + Math.println(s). prt("max(" + biologia + ".max(biologia.max(historia.java public class Trilog { public static void main(String[] args) { 52 ." + gramatica + ") es " + Math.out.min(historia. // max() retorna el mayor de los argumentos proporcionados prt("max(" + matematicas + ".biologia)).gramatica))." + historia + ") es " + Math. prt("max(" + historia + ".gramatica)).M4lote Curso Java Básico // min() retorna el menor de los argumentos proporcionados prt("min(" + matematicas + ".max(matematicas. } } Clase Calificaciones La clase hace uso de distintos métodos para realizar operaciones de redondeo y comparación sobre valores primitivos." + historia + ") es " + Math.min(biologia.max(matematicas. prt("min(" + biologia + ". Codigo Fuente Trilog.gramatica)). prt("min(" + historia + ".biologia)).historia)).

prt("atan(" + radianes + ") es " + Math.log(1. 53 .log(Math.0) es " + Math.)" elevado a la "x" potencia prt("exp(1. prt("log(10.PI equivale a la constante PI (3. prt("acos(" + radianes + ") es " + Math.sin(angulo)).E) is " + Math. prt("asin(" + radianes + ") es " + Math.0.atan(radianes))).0)).exp(1.exp(0.0 * 2.71828. // 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.PI/360. prt("exp(0.0)).0) es " + Math.7182) prt("log(1.cos(angulo)).E equivale a la constante e (2.M4lote Curso Java Básico // Convertir un angulo de 45 grados a radianes // Math.E)). prt("cos(" + angulo + ") es " + Math.toDegrees(Math. int i = 0..exp(10.toDegrees(Math.0) is " + Math.0)). prt("exp(10.0)). prt("sin(" + angulo + ") es " + Math.0)).707.0) es " + Math.asin(radianes)))..0 * Math.toDegrees(Math. // exp(x) equivale a "e (2.acos(radianes))).log(10. prt("log(Math.0) is " + Math.14159) double angulo = 45. // log(y) equivale al logaritmo natural (base e) de "y" // Math.

M4lote

Curso Java Básico

// 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)); }

} // Metodo para Impresion static void prt(String s) { System.out.println(s);

} }

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: Operador || && ! Significado O (OR) Y (AND) Negación (NOT)

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

M4lote

Curso Java Básico 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; } static boolean prueba2(int val) { System.out.println("preuba2(" + val + ")"); System.out.println("resultado: " + (val < 2)); return val < 2; } static boolean prueba3(int val) { System.out.println("prueba3(" + val + ")"); System.out.println("resultado: " + (val < 3)); return val < 3; } public static void main(String[] args) {

// 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

M4lote

Curso Java Básico // 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 OperaLogico prueba1(0) resultado: true preuba2(2) resultado: false Primera Expresion es Falsa prueba1(4) resultado: false

56

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. Como se puede observar en la ilustración. Como habría de esperarse. esto no siempre es posible y por esta razón han sido diseñados mecanismos para encontrarlos al momento de ejecución ("Run-Time"). se utilizaría la siguiente sintaxis: if(t == null) throw new NullPointerException(). a continuación se describe la sintaxis de este bloque: • Sintaxis del Bloque try/catch/finally. Al utilizar una definición similar a la anterior. para mandar llamar este tipo de Clases es necesario utilizar el vocablo throws.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. al terminar esta sección se define un grupo de estructuras con el elemento catch.M4lote Curso Java Básico preuba2(1) resultado: true Segunda Expresion es Verdadera Tercer 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. en el lenguaje Java a la ocurrencia de errores se le denomina "Exceptions" y al procesamiento de errores "Trap" (atrapar). al encontrarse un error ("Exception") en Java es necesario invocar una Clase que realiza las respectivas tareas. Sintaxis del Bloque try/catch try { // Código que pueda generar Errores ("Exception's") } catch(Tipo1 id1) { // Manejar "Exception's" para la Clase Tipo1 } catch(Tipo2 id2) { // Manejar "Exception's" para la Clase Tipo2 } catch(Tipo3 id3) { // Manejar "Exception's" para la Clase Tipo3 } La primer sección del Bloque es iniciada con el vocablo try y una llave ({ ) que indica el principio de la zona protegida. se asume que ya se conoce el tipo de error que puede ser generado en el programa. suponiendo que desea atrapar un error si determinada variable no ha sido inicializada. 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. esta Zona "Protegida" es el conocido bloque try/catch/finally. sin embargo. dentro de esta primer sección es colocado todo código que pueda generar algún tipo de error. el tipo de Clases definidas dentro de cada sección catch depende del numero de "Exceptions" que pueden ser 57 .

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. es de esta Clase que son Heredadas ("Inherited") todo "Exception" en Java. lo anterior permite definir un numero ilimitado de "Exceptions" cada uno con su propio código para manejar el error. 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.lang. 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. Para todo Bloque try/catch debe ser definida al menos una sección catch. 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.java class MiError extends Exception { 58 . siendo la menos especifica la Clase java.Throwable. esto será descrito en la siguiente sección de este curso.M4lote Curso Java Básico generadas por el programa. Sintaxis del Bloque try/catch/finally Para los Bloques try/catch existe una variación que consiste en agregar una sección denominada finally. si son definidos más de dos Clases para errores ("Exceptions") estas deben ser declaradas de más a menos especifica. dicha estructura estaría compuesta de la siguiente manera: try { // Código que pueda generar Errores ("Exception's") } catch(Tipo1 id1) { // Manejar "Exception's" para la Clase Tipo1 } catch(Tipo2 id2) { // Manejar "Exception's" para la Clase Tipo2 } catch(Tipo3 id3) { // Manejar "Exception's" para la Clase Tipo3 } 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.

out. } catch(MiError e) { e. } public static void main(String[] args) { try { f(). } catch(MiError e) { e.err).println("Generando Error explícitamente g()"). } } public class DefinirErrores { public static void f() throws MiError { System.println("Generando Error explícitamente en f()").out. 59 .printStackTrace(System.printStackTrace(System. throw new MiError("Originado en f()").M4lote Curso Java Básico public MiError() {} public MiError(String msg) { super(msg).err). throw new MiError("Originado en g()"). } public static void g() throws MiError { System. } try { g().

La Clase/método System.M4lote Curso Java Básico } } } 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.err representa el "Stream" de salida para cualquier error generado en un programa Java.Exception ya que posee mayores funcionalidades(métodos). debe hacerse fuerte énfasis que esto es independiente de las declaraciones hechas en los bloques try/catch. o Clase DefinirErrores • Esta Clase define dos métodos llamados f() y g(). es simplemente una sintaxis para los métodos capaces de generar errores. • • • • • Datos de Entrada 60 . En el método principal (main) son definidos dos bloques try/catch. NOTA: Aunque la clase base de todo error ("Exception") es java.Throwable.NOTA: El método printStackTrace fue heredado ("Inherited") de la clase Exception. 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. en efecto teniendo acceso a cualquiera de los métodos/campos disponibles en la Clase Base.Exception hereda ("inherit") el comportamiento de la Clase java. 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. generalmente se opta por java.lang. esta sintaxis es obligatoria para los métodos que puedan generar errores.lang. una característica especifica de estos métodos es que utilizan el vocablo throws seguido de una Clase.lang. notará que la Clase java. Al ser llamada la función de cada bloque. Otro es el constructor sin argumentos que debe ser declarado al emplearse más de un constructor. en uno de estos es llamado el método f() y en otro el método g(). Dentro de cada método f() y g() es generado un error con la clase MiError explícitamente. inclusive si observa la documentación del JDK. se genera un error del tipo MiError puesto que cada función invoca explícitamente este error.lang. esto permite utilizar funcionalidades ya definidas en esta Clase. Clase MiError • Esta clase hereda ("Inherit") el comportamiento de Exception.Throwable.

M4lote Curso Java Básico A lo largo de los diversos métodos definidos en los distintos programas. nótese que este primer valor es indicado con el numero cero. seguido de la referencia empleada dentro dentro del método. La sintaxis de los datos de entrada se compone de dos partes: El tipo de Clase/Primitivo.println("Su nombre es: " + args[0]). a través de su referencia args. el uso de corchetes ([]) al lado de la Clase String indica un Arreglo de String's.println("Su nombre es: " + args[0]).out. esto con la intención de recibir parámetros al momento de ser llamada la Clase.out. Código Fuente Nombres. 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)). • Se define el método principal ( main ).out.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. por lo que una vez compilada la Clase (javac Nombres.java public class NombresBlock { public static void main(String[] args) { try { System. Los valores de entrada para el método main son tomados directamente de la linea de ejecución del programa.out. por "default" los métodos principales (main) en Java deben especificar un Arreglo de String's en su definición. Clase Nombres. mientras el segundo y tercero serian Rodriguez y King respectivamente.println("Sus apellidos son: " + args[1] + " } } " + args[2]). o El primer mensaje imprime el primer valor del arreglo de entrada. • Se imprimen dos mensajes a pantalla a través de la Clase System. • Se inicia este programa con la clásica definición de Clase. o El segundo mensaje imprime el segundo y tercer valor del arreglo.java public class Nombres { public static void main(String[] args) { System. inclusive si no proporciona ningún argumento será generado un error ("Exception").println. 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. a continuación se describe un ejemplo que hace uso de este mecanismo: • Utilización de Datos de Entrada . Ejecución de Clase Nombres. esta es Sintaxis de arreglos la cual será descrita a fondo en otra sección. System. 61 .

como su nombre lo indica la primera de estas es utilizada para "Streams" de Entrada (Input) mientras la segunda "Streams" de Salida (Output). pero una manera muy universal de accesar/guardar datos. lo anterior se debe a que el programa termina al ser atrapado ("catch") en el bloque catch inicial. en la siguiente sección será descrito el uso de "Streams" para la lectura/escritura de datos en archivos y otros elementos. se inicia la inspección sobre las secciones catch hasta que el error ("Exception") coincida con una declaración.println("Sus apellidos son: " + args[1] + " " + args[2]).io. 62 . Ahora bien.out. este tipo de error ("Exception") es precisamente ArrayIndexOutOfBoundsException. 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.OutputStream Las principales clases para representar "Streams" son : InputStream y OutputStream. a partir de estas dos Clases son derivadas todas las Clases que hacen uso de datos de entrada y salida. dentro del bloque try se estaría tratando de accesar elementos no definidos en el arreglo. En esta caso.io. • • La única diferencia entre esta Clase y aquella descrita anteriormente es el Bloque try/catch .out. puede estar compuesto por los valores residentes en un archivo texto. } } } Clase NombresBlock.println("Ocurrió un error genérico"). "Streams" Un "Stream" es un nombre genérico otorgado a un flujo de caracteres en un programa de computo. java.InputStream y java. por lo que serán ejecutadas las instrucciones definidas dentro de este bloque. ya que es realizado antes de iniciarse la ejecución de un programa. a continuación se describen estas Clases : • Clases utilizadas en "Streams" . } catch (ArrayIndexOutOfBoundsException ex) { System. • • El uso de Datos de Entrada descrito anteriormente es trivial.out.println utilizada en la gran mayoría de los programas de este curso también es un "Stream". Un "Stream" es la representación más cruda de un juego de datos. nótese que las instrucciones del bloque catch con la Clase Exception nunca son ejecutadas. si es generado un error.M4lote Curso Java Básico System. si son omitidos algunos parámetros de entrada para el programa.println("Esta tratando de accesar datos fuera del Arreglo"). en Java existen diversas Clases utilizadas en conjunción de "Streams". inclusive la clase System. Al estar siendo ejecutadas las instrucciones de la sección try.out. } catch (Exception ex) { System. datos introducidos interactivamente por un usuario o datos que desean ser colocados en determinado archivo.

la principal diferencia entre estas Clases es que las primeras ofrecen lo que es conocido como byte-orientated I/O. al utilizarse 8-bits no es posible emplear muchos caracteres disponibles en Unicode.comportamiento y métodos de las diversas Clases heredadas ("Inherited") de InputStream y OutputStream. Código Fuente Calculo. inclusive la Clase/Método System. además debido a que las Clases Writer y Reader son una adición más reciente al JDK. public class Calculo { public static void main(String[] args) throws IOException { 63 . por esta razón son descritos dos ejemplos en las siguientes secciones: • • Utilización de un "Stream" para leer Archivos. mientras Writer y Reader ofrecen character-based I/O. La importancia de 16-bits radica en Java utilizando Unicode. El uso de "Streams" en programación es un tema muy extenso y en ocasiones considerado muy abstracto.OutputStream.PrintStream la cual a su vez desciende de java. en otras palabras las Clases InputStream y OutputStream solamente soportan "Streams" de 8-bits byte.M4lote Curso Java Básico 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.io. java.Writer y java.io. 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".java import java. estas poseen mayor velocidad de ejecución a diferencia de sus contra partes InputStream y OutputStream. mientras las Clases Writer y Reader soporta "Streams" de 16-bits.io. existen otra gran cantidad de Clases que heredan ("Inherit") el comportamiento de estas Clases bases. "Stream" para escribir Archivos.println es heredada ("Inherited") de la Clase java. Ambas variaciones siguen en uso hoy en día.io.Reader Existen otras dos variaciones para las Clases InputStream y OutputStream que son : Writer y Reader. Se recomienda observar la documentación incluida en el JDK para conocer el uso.out.*.io.

err.readLine()) != null) lineas++. String archivo = stdin.out.println("El archivo " + archivo + " contiene " + lineas + " renglones de Codigo.M4lote Curso Java Básico String s. try { System. System. } catch (IOException exc) { System."). BufferedReader stdin = new BufferedReader( new InputStreamReader(System. while (( s = sarchivo.println("Es la mejor manera de aprender Streams.java\")").readLine().println("Asegurese de haber proporcionado " + " la extension del archivo (\". int lineas = 1.out.println(exc).out. BufferedReader sarchivo = new BufferedReader( new FileReader(archivo)).out.print("Que archivo desea analizar ? "). } finally { System. practicando!"). } } 64 .in)).println("").out. System. System.

o o o o o o o • catch o Dentro de está sección del Bloque se intenta atrapar un error ("Exception") del tipo IOException.M4lote Curso Java Básico } Clase Calculo Esta Clase esta diseñada para interrogar al usuario sobre determinado archivo. la cual contiene los mecanismos necesarios para leer un Archivo. leer su contenido y finalmente indicar al usuario el número de renglones que contiene. en este caso siendo System. y en este caso recibiendo el nombre del archivo. se envía a pantalla una sugerencia así como el error completo. consta únicamente de su método principal (main) y un bloque try/catch/finally. En caso de generarse este error. • • • De inicio son definidos dos campos para utilizarse dentro del método principal (main) . Es generada una nueva instancia de la Clase BufferedReader a la cual será asignada el archivo en cuestión. Dentro de cada iteración de ciclo se incrementa la variable (primitivo) lineas la cual representa el número de lineas en el archivo. Posteriormente se define el bloque try/catch/finally con las siguientes características: try o o Se despliega una pregunta al usuario para que proporcione el nombre del archivo a leer.in que representa el shell de ejecución. Se extrae el nombre del archivo a través del método readLine() y es asignado a una referencia de String. En este programa el error sería generado al intentarse leer un archivo inexistente proporcionado por el usuario. NOTA: El método readLine retorna un resultado null ya que el archivo no contenga lineas. Finalmente se envía a pantalla el resultado obtenido del ciclo. la cual permite leer datos de un "Stream". este tipo de error es generado al no poderse iniciar lectura/escritura en un programa. Es definida una Clase del tipo BufferedReader la cual permite archivar datos temporales en memoria ("Buffer") El argumento que recibe al ser generada la Clase anterior es otra Clase llamada InputStreamReader. 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. 65 o o . El argumento que recibe al ser generada la Clase anterior es otra Clase llamada FileReader.

in.java import java.*.readLine()) != null) s2 += s + "\n".java")).close().M4lote Curso Java Básico finally o • Esta sección del Bloque describe instrucciones que siempre deben ser ejecutadas independientemente de ser generado un error ("Exception") o no. o En la siguiente sección será descrito el uso de "Streams" para escribir hacia archivos. Código Fuente LeerArchivo. 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.in)). 66 . Se imprime a pantalla un mensaje cada vez que sea ejecutado el programa. s2 += "Usted agrego la linea \" " + stdin.print("Introduzca cualquier dato: "). s2 = new String().out. String s. while ((s = in. // Leer Datos Interactivamente BufferedReader stdin = new BufferedReader( new InputStreamReader(System.readLine() + " \" en la linea de comandos". System. ocurra o no ocurra un error ("Exception").io.

} } } 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. 67 • • • • . Lectura de Datos • En la primer sección es definida una Clase BufferedReader. int lineaNo = 1. while ((s = leer. El valor introducido por el usuario es concatenado a la variable s2 que contiene el archivo de código fuente. NOTA: El método readLine retorna un resultado null ya que el archivo no contenga lineas. } catch (EOFException e) { System.println(lineaNo++ + ": " + s). escribir.println("Final de Stream"). Es definida otra Clase BufferedReader la cual es empleada para datos introducidos de la consola (System. Dentro de cada iteración.readLine()) != null) escribir.close().in). 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. la cual lee el archivo de Código Fuente. al igual que el ejemplo anterior consta únicamente de su método principal (main) y un bloque try/catch.txt"))).M4lote Curso Java Básico // Depositar Datos en un Archivo de Texto try { BufferedReader leer = new BufferedReader( new StringReader(s2)).out. PrintWriter escribir = new PrintWriter( new BufferedWriter(new FileWriter("Archivo_Stream. Se define un ciclo while que permanecerá activo hasta que el resultado del método readLine() sobre la referencia definida anteriormente equivalga a null. es concatenado cada renglón leído del "Stream" y colocado en la variable s2.

Se declara una instancia de la Clase BufferedReader . Se define un error ("Exception") del tipo EOFException el cual sería generado en caso de llegar a un fin prematuro del archivo. Se genera un ciclo while. esta última toma como parámetro el archivo que será generado (Archivo_Stream.M4lote Curso Java Básico Escritura de Datos • • Se inicia un Bloque try/catch.txt). Es definida una Clase PrintWriter que permite escritura de "Streams". • • • 68 . la cual recibe como parámetro de entrada el String definido en la sección de lectura. esta Clase recibe como parámetro de entrada la Clase BufferedWriter la cual a su vez recibe la Clase FileWriter. el cual en cada iteración asigna los valores de cada renglón leído hacia la referencia de la Clase PrintWriter.

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->