P á g i n a | 1

Programacion para Principiantes JAVA

Universidad “Mariano Gálvez”

Ingeniería en Sistemas de Información

4to. Semestre

Sección “A”

Programacion II

Ing. Axel Castillo

Manual de programación de JAVA

Alvin Steve

Padilla Meza

3090-10-11973

Mazatenango 26 de noviembre del 2015

P á g i n a | 2

Programación para Principiantes JAVA

INDICE

Tema Página

Introduccion……………………………………………………………………………………………………………. 4

Objetivos…………………………………………………………………………………………………………………. 5

Introducción a JAVA……………………………………………………………………………………………. 6

Origen de JAVA…………………………………………………………………………………………………….. 7

Caracteristicas……………………………………………………………………………………………………….. 8-12

Instalación de JBK…………………………………………………………………………………………………. 13

Conceptos Basicos con Respecto a la Estructura de un programa……………….. 14

Control o Modificadores de Acceso……………………………………………………………………. 17

Separadores…………………………………………………………………………………………………………….. 18

Finalizadores……………………………………………………………………………………………………………. 18

Objetos…………………………………………………………………………………………………………………….. 19

Herencia…………………………………………………………………………………………………………………… 20-21

Clases……………………………………………………………………………………………………………………… 22-24

Clases que Utilizamos en JAVA…………………………………………………………………………..24-35

Control General de Flujo o Sentencias de control……………………………………………35-44

Uso de Variables……………………………………………………………………………………………………..44-45

This y Super…………………………………………………………………………………………………………….45-46

Métodos Nativos…………………………………………………………………………………………………. 46-47

Variables y Metodos Estaticos…………………………………………………………………………….47-48

Operadores, Comentarios y Literales………………………………………………………………..49-54

Excepciones……………………………………………………………………………………………………………. 54-63

Metodos y Constructores……………………………………………………………………………………. 63-65

Arrays……………………………………………………………………………………………………………………….65-69

P á g i n a | 3

Programacion para Principiantes JAVA

Referencias y Listas……………………… ………………………………………………………………….69-72

Graficas en JAVA……………………………………………………………………………………………… 72-76

Interfaces…………………………………………………………………………………………………………… 76-78

Hilos……………………………………………………………………………………………………………………… 78-80

Alcances y Objetos y Reciclado de Memoria………………………………………………… 80

Paquetes (Packages)………………………………………………………………………………………………80-83

Minima Aplicación………………………………………………………………………………………………… 83

HOLAMUNDO……………………………………………………………………………………………………… 83-84

Compilacion y Ejecucion de HOLAMUNDO……………………………………………………… 84-85

Un Applet Basico……………………………………………………………………………………………………86

Componentes Basicos de Applet…………………………………………………………………………86-87

Metodos de Applets………………………………………………………………………………………………87-89

Uso de Conversiones………………………………………………………………………………………………89-91

Ficheros………………………………………………………………………………………………………………… 91-92

Acceso a la Informacion………………………………………………………………………………………92-94

Streams de Entrada………………………………………………………………………………………………94-97

Streams de Salida………………………………………………………………………………………………….97-99

Conclusión………………………………………………………………………………………………………………… 100

Bibliografia……………………………………………………………………………………………………………… 101

P á g i n a | 4

Programación para Principiantes JAVA

Introduccion

En este manual acerca de lo que es el lenguaje de programación JAVA antes que

nada el usuario va a entrar a lo que es una Breve Introduccion al Mundo de JAVA,

luego de esto vamos a conocer que lo que fue el origen JAVA con una breve

historia de como surgio JAVA, las características de este lenguaje de

Programacion JAVA esto va a ver con el fin que el usuario se asocie poco a poco

con el mundo de JAVA y con lo que es el lenguaje de programación de este mismo.

También en este manual vamos a aprender a Instalar lo que es JAVA para

nuestra maquina o computadora. También en este manual vamos a conocer lo que

es la estructuración de un programa para JAVA.

En este manual vamos a conocer lo que son los temas de Clases, Herencia,

Constructores, modificadores de Acceso,Objetos, Clases, tipos de clases,

Control de Flujo o Sentencias de Control, Estructuras Selectivas: if, else, etc;

estructuras Iterativas, Variables, tipos de variables, Operadores,Comentarios

y Literales, Manejo de Excepciones, Metodos(Constructores), Arrays,

Referencias y Listas,Graficos en JAVA, Packages, Hilos, Interfaces, cada uno

de estos aspectos lo vamos aprender con su respectiva definición, como

declararlos, como identificar a cada uno o ver sus diferencias, también con

Ejemplos y algunos de estos Ejemplos tienen su respectiva Explicacion, etc. Y

luego de ya conocer los aspectos anteriores vamos a aprender a utilizar todo

esto para crear una aplicación o programa.

P á g i n a | 5

Programacion para Principiantes JAVA

Objetivos

General

Que el Usuario Aprenda a través de esta manual lo que es el lenguaje de

programación de JAVA

Específicos:

Definir lo que es el lenguaje de Programacion JAVA, que el usuario

conosca la breve Historia de Java, sus características, etc.

Conocer lo que es la estructuración de un programa en JAVA.

Que el usuario aprenda lo que es el gusto de aprender a Programar

correctamente en JAVA.

Que el usuario conosca las especificaciones para aprender a

Programar en JAVA.

Que atraves de los Ejemplos el Usuario conosca los casos de

errores que se pueden observar en un problema al momento de

programar ellos mismos.

P á g i n a | 6

Programación para Principiantes JAVA

Introducción a Java

Antes que nada vamos a conocer en este caso una breve explicación de lo que es un lenguaje de programación

el cual es un lenguaje formal diseñado para realizar procesos que pueden ser llevados a cabo por máquinas

como las computadoras y vamos a definir que en este caso pueden usarse para crear programas que controlen

el comportamiento físico y lógico de una máquina, para expresar algoritmos con precisión, o como modo de

comunicación humana. También podemos decir que está formado por un conjunto de símbolos y reglas

sintácticas y semánticas que definen su estructura y el significado de sus elementos y expresiones. Al proceso

por el cual se escribe, se prueba, se depura, se compila (de ser necesario) y se mantiene el código fuente de un

programa informático a esto se le conoce como programación.

En este caso vamos a aprender un lenguaje de programación conocido como JAVA es un lenguaje orientado a

objetos de propósito general. Aunque más adelante lo que es Java comenzará a ser conocido como un lenguaje

de programación de applets que se ejecutan en el entorno de un navegador web, se puede utilizar para construir

cualquier tipo de proyecto. La principal característica de Java es la de ser un lenguaje compilado e interpretado.

Todo programa en Java ha de compilarse y el código que se genera bytecodes es interpretado por una máquina

virtual. De este modo se consigue la independencia de la máquina, el código compilado se ejecuta en máquinas

virtuales que si son dependientes de la plataforma. Cuando trabajamos con JAVA observamos que su sintaxis

es parecida a C y C++.

El lenguaje Java y los navegadores con soporte Java, proporcionan una forma diferente de hacer que ese

navegador sea capaz de ejecutar programas. Con Java se puede reproducir sonido directamente desde el

navegador, se pueden visitar home pages con animaciones, se puede enseñar al navegador a manejar nuevos

formatos de ficheros, e incluso, cuando se pueda transmitir video por las líneas telefónicas, nuestro navegador

estará preparado para mostrar esas imágenes. Utilizando Java, se pueden eliminar los inconvenientes de la

interfaz CGI y también se pueden añadir aplicaciones que vayan desde experimentos científicos interactivos de

propósito educativo a juegos o aplicaciones especializadas para la televenta. Es posible implementar publicidad

interactiva y periódicos personalizados. Por ejemplo, alguien podría escribir un programa Java que

implementara una simulación química interactiva (una cadena de adn). Utilizando un navegador con soporte

Java, un usuario podría recibir fácilmente esa simulación e interaccionar con ella, en lugar de conseguir

simplemente un dibujo estático y algo de texto. Lo recibido cobra vida. Además, con Java podemos estar

seguros de que el código que hace funcionar el experimento químico no contiene ningún trozo de código

malicioso que dañe al sistema. El código que intente actuar destructivamente o que contenga errores, no podrá

traspasar los muros defensivos colocados por las características de seguridad y robustez de Java. Además, Java

proporciona una nueva forma de acceder a las aplicaciones. El software viaja transparentemente a través de la

red. No hay necesidad de instalar las aplicaciones, ellas mismas vienen cuando se necesitan. Por ejemplo, la

mayoría de los navegadores del Web pueden procesar un reducido número de formatos gráficos (típicamente

GIF y JPEG). Si se encuentran con otro tipo de formato, el navegador estándar no tiene capacidad para

procesarlo, tendría que ser actualizado para poder aprovechar las ventajas del nuevo formato. Sin embargo, un

navegador con soporte Java puede enlazar con el servidor que contiene el algoritmo que procesa ese nuevo

formato y mostrar la imagen. Por lo tanto, si alguien inventa un nuevo algoritmo de compresión para imágenes,

el inventor sólo necesita estar seguro de que hay una copia en código Java de ese algoritmo instalado en el

servidor que contiene las imágenes que quiere publicar. Es decir, los navegadores con soporte Java se actualizan

a sí mismos sobre la marcha, cuando encuentran un nuevo tipo de fichero o algoritmo.

P á g i n a | 7

Programacion para Principiantes JAVA

ORIGEN DE JAVA

El uso principal que se hace de Internet e incluso de las redes internas (corporativas) es correo electrónico (e-

mail), aunque actualmente hay un auge sorprendente de la navegación web. Los documentos web pueden

contener variedad de texto, gráficos de todas clases y proporcionar enlaces hipertexto hacia cualquier lugar de

la red. Los navegadores utilizan documentos escritos en lenguaje HTML. La combinación actual de

navegadores HTML/WWW están limitados pues, a texto y gráficos. Si se quiere reproducir un sonido o ejecutar

un programa de demostración, primero hemos de bajarnos (download) el fichero en cuestión y luego utilizar un

programa en nuestro ordenador capaz de entender el formato de ese fichero, o bien cargar un módulo (plug-in)

en nuestro navegador para que pueda interpretar el fichero que hemos bajado. Hasta ahora, la única forma de

realizar una página web con contenido interactivo, era mediante la interfaz CGI ( Common Gateway Interface

), que permite pasar parámetros entre formularios definidos en lenguaje HTML y programas escritos en Perl o

en C. Esta interfaz resulta muy incómoda de programar y es pobre en sus posibilidades. El lenguaje Java y los

navegadores con soporte Java, proporcionan una forma diferente de hacer que ese navegador sea capaz de

ejecutar programas. Con Java se puede reproducir sonido directamente desde el navegador, se pueden visitar

home pages con animaciones, se puede enseñar al navegador a manejar nuevos formatos de ficheros, e incluso,

cuando se pueda transmitir video por las líneas telefónicas, nuestro navegador estará preparado para mostrar

esas imágenes.

Utilizando Java, se pueden eliminar los inconvenientes de la interfaz CGI y también se pueden añadir

aplicaciones que vayan desde experimentos científicos interactivos de propósito educativo a juegos o

aplicaciones especializadas para la televenta. Es posible implementar publicidad interactiva y periódicos

personalizados. Por ejemplo, alguien podría escribir un programa Java que implementara una simulación

química interactiva (una cadena de adn). Utilizando un navegador con soporte Java, un usuario podría recibir

fácilmente esa simulación e interaccionar con ella, en lugar de conseguir simplemente un dibujo estático y algo

de texto. Lo recibido cobra vida. Además, con Java podemos estar seguros de que el código que hace funcionar

el experimento químico no contiene ningún trozo de código malicioso que dañe al sistema. El código que intente

actuar destructivamente o que contenga errores, no podrá traspasar los muros defensivos colocados por las

características de seguridad y robustez de Java.

P á g i n a | 8

Programación para Principiantes JAVA

Características de JAVA

Las características principales que nos ofrece Java respecto a cualquier otro lenguaje de programación, son:

Es SIMPLE: Java ofrece toda la funcionalidad de un lenguaje potente, pero sin las características menos usadas

y más confusas de éstos. C++ es un lenguaje que adolece de falta de seguridad, pero C y C++ son lenguajes

más difundidos, por ello Java se diseñó para ser parecido a C++ y así facilitar un rápido y fácil aprendizaje.

Java elimina muchas de las características de otros lenguajes como C++, para mantener reducidas las

especificaciones del lenguaje y añadir características muy útiles como el garbage collector (reciclador de

memoria dinámica). No es necesario preocuparse de liberar memoria, el reciclador se encarga de ello y como

es un thread de baja prioridad, cuando entra en acción, permite liberar bloques de memoria muy grandes, lo

que reduce la fragmentación de la memoria. Java reduce en un 50% los errores más comunes de programación

con lenguajes como C y C++ al eliminar muchas de las características de éstos, entre las que destacan:

aritmética de punteros

no existen referencias

registros (struct)

definición de tipos (typedef)

macros (#define)

necesidad de liberar memoria (free)

Aunque, en realidad, lo que hace es eliminar las palabras reservadas (struct, typedef), ya que las clases son algo

parecido. Además, el intérprete completo de Java que hay en este momento es muy pequeño, solamente ocupa

215 Kb de RAM.

Es ORIENTADO A OBJETOS: Java implementa la tecnología básica de C++ con algunas mejoras y elimina

algunas cosas para mantener el objetivo de la simplicidad del lenguaje. Java trabaja con sus datos como objetos

y con interfaces a esos objetos. Soporta las tres características propias del paradigma de la orientación a objetos:

encapsulación, herencia y polimorfismo. Las plantillas de objetos son llamadas, como en C++, clases y sus

copias, instancias. Estas instancias, como en C++, necesitan ser construidas y destruidas en espacios de

memoria.

Java incorpora funcionalidades inexistentes en C++ como por ejemplo, la resolución dinámica de métodos. Esta

característica deriva del lenguaje Objective C, propietario del sistema operativo Next. En C++ se suele trabajar

con librerías dinámicas (DLLs) que obligan a recompilar la aplicación cuando se retocan las funciones que se

encuentran en su interior. Este inconveniente es resuelto por Java mediante una interfaz específica llamada

RTTI (RunTime Type Identification) que define la interacción entre objetos excluyendo variables de instancias

o implementación de métodos. Las clases en Java tienen una representación en el runtime que permite a los

programadores interrogar por el tipo de clase y enlazar dinámicamente la clase con el resultado de la búsqueda.

Es DISTRIBUIDO: Java se ha construido con extensas capacidades de interconexión TCP/IP. Existen librerías

de rutinas para acceder e interactuar con protocolos como http y ftp. Esto permite a los programadores acceder

a la información a través de la red con tanta facilidad como a los ficheros locales. La verdad es que Java en sí

no es distribuido, sino que proporciona las librerías y herramientas para que los programas puedan ser

distribuidos, es decir, que se corran en varias máquinas, interactuando.

Es ROBUSTO: Java realiza verificaciones en busca de problemas tanto en tiempo de compilación como en

tiempo de ejecución. La comprobación de tipos en Java ayuda a detectar errores, lo antes posible, en el ciclo de

desarrollo. Java obliga a la declaración explícita de métodos, reduciendo así las posibilidades de error. Maneja

la memoria para eliminar las preocupaciones por parte del programador de la liberación o corrupción de

memoria. También implementa los arrays auténticos, en vez de listas enlazadas de punteros, con comprobación

de límites, para evitar la posibilidad de sobreescribir o corromper memoria resultado de punteros que señalan a

zonas equivocadas. Estas características reducen drásticamente el tiempo de desarrollo de aplicaciones en Java.

P á g i n a | 9

Programacion para Principiantes JAVA

Además, para asegurar el funcionamiento de la aplicación, realiza una verificación de los byte-codes, que son

el resultado de la compilación de un programa Java. Es un código de máquina virtual que es interpretado por el

intérprete Java. No es el código máquina directamente entendible por el hardware, pero ya ha pasado todas las

fases del compilador: análisis de instrucciones, orden de operadores, etc., y ya tiene generada la pila de

ejecución de órdenes.

Java proporciona, pues:

Comprobación de punteros

Comprobación de límites de arrays

Excepciones

Verificación de byte-codes

Es de ARQUITECTURA NEUTRAL: Para establecer Java como parte integral de la red, el compilador Java

compila su código a un fichero objeto de formato independiente de la arquitectura de la máquina en que se

ejecutará. Cualquier máquina que tenga el sistema de ejecución (run-time) puede ejecutar ese código objeto, sin

importar en modo alguno la máquina en que ha sido generado. Actualmente existen sistemas run-time para

Solaris 2.x, SunOs 4.1.x, Windows 95, Windows NT, Linux, Irix, Aix, Mac, Apple y probablemente haya

grupos de desarrollo trabajando en el porting a otras plataformas.

El código fuente Java se "compila" a un código de bytes de alto nivel independiente de la máquina. Este código

(byte-codes) está diseñado para ejecutarse en una máquina hipotética que es implementada por un sistema run-

time, que sí es dependiente de la máquina. En una representación en que tuviésemos que indicar todos los

elementos que forman parte de la arquitectura de Java sobre una plataforma genérica, obtendríamos una figura

como la siguiente:

En ella podemos ver que lo verdaderamente dependiente del sistema es la Máquina Virtual Java (JVM) y las

librerías fundamentales, que también nos permitirían acceder directamente al hardware de la máquina. Además,

P á g i n a | 10

Programación para Principiantes JAVA

habrá APIs de Java que también entren en contacto directo con el hardware y serán dependientes de la máquina,

como ejemplo de este tipo de APIs podemos citar:

Java 2D: gráficos 2D y manipulación de imágenes

Java Media Framework: Elementos críticos en el tiempo: audio, video...

Java Animation: Animación de objetos en 2D

Java Telephony: Integración con telefonía

Java Share: Interacción entre aplicaciones multiusuario

Java 3D: Gráficos 3D y su manipulación

Es SEGURO: La seguridad en Java tiene dos facetas. En el lenguaje, características como los punteros o el

casting implícito que hacen los compiladores de C y C++ se eliminan para prevenir el acceso ilegal a la

memoria. Cuando se usa Java para crear un navegador, se combinan las características del lenguaje con

protecciones de sentido común aplicadas al propio navegador. El lenguaje C, por ejemplo, tiene lagunas de

seguridad importantes, como son los errores de alineación. Los programadores de C utilizan punteros en

conjunción con operaciones aritméticas. Esto le permite al programador que un puntero referencie a un lugar

conocido de la memoria y pueda sumar (o restar) algún valor, para referirse a otro lugar de la memoria. Si otros

programadores conocen nuestras estructuras de datos pueden extraer información confidencial de nuestro

sistema. Con un lenguaje como C, se pueden tomar números enteros aleatorios y convertirlos en punteros para

luego acceder a la memoria:

Printf( "Escribe un valor entero: " );

scanf( "%u",&puntero );

printf( "Cadena de memoria: %sn",puntero );

Otra laguna de seguridad u otro tipo de ataque, es el Caballo de Troya. Se presenta un programa como una

utilidad, resultando tener una funcionalidad destructiva. Por ejemplo, en UNIX se visualiza el contenido de un

directorio con el comando ls. Si un programador deja un comando destructivo bajo esta referencia, se puede

correr el riesgo de ejecutar código malicioso, aunque el comando siga haciendo la funcionalidad que se le

supone, después de lanzar su carga destructiva. Por ejemplo, después de que el caballo de Troya haya enviado

por correo el /etc/shadow a su creador, ejecuta la funcionalidad de ls persentando el contenido del directorio.

Se notará un retardo, pero nada inusual. El código Java pasa muchos tests antes de ejecutarse en una máquina.

El código se pasa a través de un verificador de byte-codes que comprueba el formato de los fragmentos de

código y aplica un probador de teoremas para detectar fragmentos de código ilegal -código que falsea punteros,

viola derechos de acceso sobre objetos o intenta cambiar el tipo o clase de un objeto-.

Si los byte-codes pasan la verificación sin generar ningún mensaje de error, entonces sabemos que:

El código no produce desbordamiento de operandos en la pila

El tipo de los parámetros de todos los códigos de operación son conocidos y correctos

No ha ocurrido ninguna conversión ilegal de datos, tal como convertir enteros en punteros

El acceso a los campos de un objeto se sabe que es legal: public, private, protected

No hay ningún intento de violar las reglas de acceso y seguridad establecidas

El Cargador de Clases también ayuda a Java a mantener su seguridad, separando el espacio de nombres del

sistema de ficheros local, del de los recursos procedentes de la red. Esto limita cualquier aplicación del tipo

Caballo de Troya, ya que las clases se buscan primero entre las locales y luego entre las procedentes del exterior.

Las clases importadas de la red se almacenan en un espacio de nombres privado, asociado con el origen. Cuando

una clase del espacio de nombres privado accede a otra clase, primero se busca en las clases predefinidas (del

sistema local) y luego en el espacio de nombres de la clase que hace la referencia. Esto imposibilita que una

clase suplante a una predefinida. En resumen, las aplicaciones de Java resultan extremadamente seguras, ya

que no acceden a zonas delicadas de memoria o de sistema, con lo cual evitan la interacción de ciertos virus.

Java no posee una semántica específica para modificar la pila de programa, la memoria libre o utilizar objetos

y métodos de un programa sin los privilegios del kernel del sistema operativo. Además, para evitar

P á g i n a | 11

Programacion para Principiantes JAVA

modificaciones por parte de los crackers de la red, implementa un método ultraseguro de autentificación por

clave pública. El Cargador de Clases puede verificar una firma digital antes de realizar una instancia de un

objeto. Por tanto, ningún objeto se crea y almacena en memoria, sin que se validen los privilegios de acceso.

Es decir, la seguridad se integra en el momento de compilación, con el nivel de detalle y de privilegio que sea

necesario. Dada, pues la concepción del lenguaje y si todos los elementos se mantienen dentro del estándar

marcado por Sun, no hay peligro. Java imposibilita, también, abrir ningún fichero de la máquina local (siempre

que se realizan operaciones con archivos, éstas trabajan sobre el disco duro de la máquina de donde partió el

applet), no permite ejecutar ninguna aplicación nativa de una plataforma e impide que se utilicen otros

ordenadores como puente, es decir, nadie puede utilizar nuestra máquina para hacer peticiones o realizar

operaciones con otra. Además, los intérpretes que incorporan los navegadores de la Web son aún más

restrictivos. Bajo estas condiciones (y dentro de la filosofía de que el único ordenador seguro es el que está

apagado, desenchufado, dentro de una cámara acorazada en un bunker y rodeado por mil soldados de los cuerpos

especiales del ejército), se puede considerar que Java es un lenguaje seguro y que los applets están libres de

virus. Respecto a la seguridad del código fuente, no ya del lenguaje, JDK proporciona un desemsamblador de

byte-code, que permite que cualquier programa pueda ser convertido a código fuente, lo que para el

programador significa una vulnerabilidad total a su código. Utilizando javap no se obtiene el código fuente

original, pero sí desmonta el programa mostrando el algoritmo que se utiliza, que es lo realmente interesante.

La protección de los programadores ante esto es utilizar llamadas a programas nativos, externos (incluso en C

o C++) de forma que no sea descompilable todo el código; aunque así se pierda portabilidad. Esta es otra de las

cuestiones que Java tiene pendientes.

Es PORTABLE: Más allá de la portabilidad básica por ser de arquitectura independiente, Java implementa

otros estándares de portabilidad para facilitar el desarrollo. Los enteros son siempre enteros y además, enteros

de 32 bits en complemento a 2. Además, Java construye sus interfaces de usuario a través de un sistema abstracto

de ventanas de forma que las ventanas puedan ser implantadas en entornos Unix, Pc o Mac.

Es INTERPRETADO: El intérprete Java (sistema run-time) puede ejecutar directamente el código objeto.

Enlazar (linkar) un programa, normalmente, consume menos recursos que compilarlo, por lo que los

desarrolladores con Java pasarán más tiempo desarrollando y menos esperando por el ordenador. No obstante,

el compilador actual del JDK es bastante lento. Por ahora, que todavía no hay compiladores específicos de Java

para las diversas plataformas, Java es más lento que otros lenguajes de programación, como C++, ya que debe

ser interpretado y no ejecutado como sucede en cualquier programa tradicional. Se dice que Java es de 10 a 30

veces más lento que C, y que tampoco existen en Java proyectos de gran envergadura como en otros lenguajes.

La verdad es que ya hay comparaciones ventajosas entre Java y el resto de los lenguajes de programación, y

una ingente cantidad de folletos electrónicos que supuran fanatismo en favor y en contra de los distintos

lenguajes contendientes con Java. Lo que se suele dejar de lado en todo esto, es que primero habría que decidir

hasta que punto Java, un lenguaje en pleno desarrollo y todavía sin definición definitiva, está maduro como

lenguaje de programación para ser comparado con otros; como por ejemplo con Smalltalk, que lleva más de 20

años en cancha. La verdad es que Java para conseguir ser un lenguaje independiente del sistema operativo y

del procesador que incorpore la máquina utilizada, es tanto interpretado como compilado. Y esto no es ningún

contrasentido, me explico, el código fuente escrito con cualquier editor se compila generando el byte-code. Este

código intermedio es de muy bajo nivel, pero sin alcanzar las instrucciones máquina propia de cada plataforma

y no tiene nada que ver con el p-code de Visual Basic. El byte-code corresponde al 80% de las instrucciones de

la aplicación. Ese mismo código es el que se puede ejecutar sobre cualquier plataforma. Para ello hace falta el

run-time, que sí es completamente dependiente de la máquina y del sistema operativo, que interpreta

dinámicamente el byte-code y añade el 20% de instrucciones que faltaban para su ejecución. Con este sistema

es fácil crear aplicaciones multiplataforma, pero para ejecutarlas es necesario que exista el run-time

correspondiente al sistema operativo utilizado.

Es MULTITHREADED: Al ser multithreaded (multihilvanado, en mala traducción), Java permite muchas

actividades simultáneas en un programa. Los threads (a veces llamados, procesos ligeros), son básicamente

pequeños procesos o piezas independientes de un gran proceso. Al estar los threads contruidos en el lenguaje,

son más fáciles de usar y más robustos que sus homólogos en C o C++. El beneficio de ser miltithreaded

consiste en un mejor rendimiento interactivo y mejor comportamiento en tiempo real. Aunque el

comportamiento en tiempo real está limitado a las capacidades del sistema operativo subyacente (Unix,

P á g i n a | 12

Programación para Principiantes JAVA

Windows, etc.), aún supera a los entornos de flujo único de programa (single-threaded) tanto en facilidad de

desarrollo como en rendimiento. Cualquiera que haya utilizado la tecnología de navegación concurrente, sabe

lo frustrante que puede ser esperar por una gran imagen que se está trayendo. En Java, las imágenes se pueden

ir trayendo en un thread independiente, permitiendo que el usuario pueda acceder a la información en la página

sin tener que esperar por el navegador.

Es DINAMICO: Java se beneficia todo lo posible de la tecnología orientada a objetos. Java no intenta conectar

todos los módulos que comprenden una aplicación hasta el tiempo de ejecución. Las librerías nuevas o

actualizadas no paralizarán las aplicaciones actuales (siempre que mantengan el API anterior).

Java también simplifica el uso de protocolos nuevos o actualizados. Si su sistema ejecuta una aplicación Java

sobre la red y encuentra una pieza de la aplicación que no sabe manejar, tal como se ha explicado en párrafos

anteriores, Java es capaz de traer automáticamente cualquiera de esas piezas que el sistema necesita para

funcionar.

Java, para evitar que los módulos de byte-codes o los objetos o nuevas clases, haya que estar trayéndolos de la

red cada vez que se necesiten, implementa las opciones de persistencia, para que no se eliminen cuando de

limpie la caché de la máquina.

P á g i n a | 13

Programacion para Principiantes JAVA

INSTALACION JSDK

Éste manual vamos a aprender a trabajar con el NetBeans with JDK 8, el cual se va a encontrar en esta dirección

web:

http://www.oracle.com/technetwork/java/javase/downloads/index.htmlhttp://www.oracle.com/technetwork/ja

va/javase/downloads/index.html

Y antes de comenzar a descargar debemos de ver la versión que queremos sea de acorde con nuestra máquina,

como por ejemplo: si estuviera descargando el instalador JDK para sistemas de 32 bits para la actualización

1.8.0_01, el nombre del archivo: jdk-8version-windows-i586.exe convierte jdk-8u1-windows-i586.exe. Del

mismo modo, si estuviera descargando el instalador JDK para sistemas de 64 bits para la actualización 1.8.0_01,

el nombre de archivo jdk-8version-windows-x64.exe convierte jdk-8u1-windows-x64.exe. Luego de a ver visto

la versión que se encuentre de acorde con nuestra maquina vamos a seguir unas cuantas instrucciones necesarias

para su instalación. Además, en esa misma dirección podremos descargar el NetBeans, un potente editor de

Java que nos facilitará la tarea de programar, compilar y resolver errores entre otras muchas cosas. Java es

actualmente uno de los lenguajes más populares y existen multitud de editores para él. Los más conocidos son

el JDeveloper, JBuilder, Visual J++ y por supuesto el propio NetBeans, de SUN. Sin embargo, aquí trataremos

solo el uso del SDK, sin editor, ya que es lo más recomendable. Si sabemos utilizar el SDK sin herramientas

adicionales, tendremos mayor facilidad para usar cualquier editor y siempre que estemos faltos de algún editor,

podremos salir del paso sin él. Las herramientas que trae el SDK y que más utilizaremos son:

Java (ejecutable): Ejecuta cualquier programa compilado de Java

Java (compilador): Compilará el código fuente escrito en Java.

Java no se ofrece de forma gratuita. No todas las máquinas disponen de la versión del Java Development Kit

para ejecutarse en ellas. Por ello, solamente comentaré la instalación de JDK en Solaris, Windows y Linux.

Actualmente ya hay entornos de desarrollo integrados completos para Java, diferentes del JDK de Sun. Oracle

dispone de un entorno de desarrollo de Java, la propia SUN ofrece el entorno NetBeans y Borland posee el

JBuilder. Además Microsoft ofrece soporte Java en su plataforma .NET. No obstante, trataremos solamente el

JDK. El entorno básico del JDK de Java que proporciona Sun está formado por herramientas en modo texto,

que son: java, intérprete que ejecuta programas en byte-code. Javac, compilador de Java que convierte el código

fuente en byte-code. Javah, crea ficheros de cabecera para implementar métodos para cualquier clase. Javap, es

un descompilador de byte-code a código fuente Java. Javadoc, es un generador automático de documentos

HTML a partir del código fuente Java. Javaprof, es un profiler para aplicaciones de un solo thread. El entorno

habitual pues, consiste en un navegador que pueda ejecutar applets, un compilador que convierta el código

fuente Java a byte-code y el intérprete Java para ejecutar los programas. Estos son los componenetes básicos

para desarrollar algo en Java. No obstante se necesita un editor para escribir el código fuente, y no son

estrictamente necesarias otras herramientas como el debugger, un entorno visual, la documentación o un

visualizador de jerarquía de clases. Cualquier navegador actual servirá para mostrar los Applets Java que

realicemos. La instalación en un principio es como la de cualquier otro programa, pero una vez lo hayamos

instalado tenemos que incluir en el path del sistema operativo la ruta hacia el directorio bin. Por ejemplo si

hemos instalado Java en:

c:java

En el PATH de nuestro sistema operativo debe estar presente la ruta:

c: javabin

En Windows XP, para cambiar las variables del sistema, se debe ir a Inicio > Configuración

> Panel de Control > Sistema > Opciones Avanzadas > Variables de entorno.

Una vez hecho esto, abrimos la consola, Inicio > Ejecutar > cmd y ya deberían estar

disponibles los comandos "java" y "javac".

En Linux la instalación es muy similar.

P á g i n a | 14

Programación para Principiantes JAVA

Conceptos Básicos con Respecto a la Estructura de un Programa

Ahora que ya hemos visto a grandes rasgos lo que Java puede ofrecernos, y antes de entrar a saco en

la generación de nuestro primer código Java, vamos a echar un vistazo al lenguaje Java en sí. Lo

básico resultará muy familiar a los que tengan conocimientos de C/C++. Los programadores con

experiencia en otros lenguajes procedurales reconocerán la mayor parte de las construcciones.

Esperemos que este capítulo no resulte demasiado intenso, no obstante, sí debe estar presente, porque

más de una vez recurriremos a él como referencia. En posteriores capítulos profundizaremos sobre

aspectos de la programación en Java por los que aquí pasaremos de puntillas e iremos presentando

ejemplos de código de cada uno de esos aspectos de la programación en Java.

Programación:

Debemos saber que cuando se programa en Java, se coloca todo el código en métodos, de la misma

forma que se escriben funciones en lenguajes como C.

Estructura

Vamos a tocar el tema de cómo realizar un programa en JAVA luego de que conozcamos las

instrucciones para instalar Java, es necesario que el usuario sepa cómo desarrollar un Programa en

Java, es necesario:

Editar el programa

Compilarlo

Ejecutarlo

Depurarlo

Tipos de Datos

En java, hay que distinguir esencialmente dos grandes rubros:

Tipos de datos o variables que se utilizan al trabajar en lo que es la Programación Orientada a Objetos.

Tipos de Datos Simples o Datos Basicos : se le va a conocer como datos simples o Datos Simples van

a ser aquellos datos los cuales no son objetos y se pueden utilizar directamente en un programa sin

necesidad de crear objetos de este tipo. La biblioteca Java proporciona clases asociadas a estos tipos

que proporcionan métodos que facilitan su manejo.

Tipos Descripción

Boolean Representa valores TRUE/FALSE. Esta es una

de las grandes diferencias respecto a C

Byte Representa enteros de 8 bits

char Al igual que en C, se utiliza para representar

datos de tipo Carácter.

P á g i n a | 15

Programacion para Principiantes JAVA

double Valores de punto flotante pero con doble

precisión

float Valores de tipo Real con precisión Simple

int Sirve para representar valores de tipo entero

long Entero Largo

short Entero corto

Tabla 2.1

Vamos a conocer un poco acerca del rubro de los datos de tipo Entero:

byte 8 bits Valores numéricos de –128 a 127

short 16 bits Valores numéricos de –32.768 a 32.767

int 32 bits Valores numéricos de –2.147.483.648 a 2.147.483.647

long 64 bits Valores numéricos sin límite.

Tabla 2.2

OJO: JAVA no soporta enteros son signo, el no especificarlos automáticamente los entiende

como si fueran positivos.

Los tipos de datos Orientados a Objetos son:

Clases

Interfaces

Arrays

De los cuales, hablares en su momento.

Un programa en java, debe tener los siguientes elementos:

*LA ZONA DE INCLUSIÓN: que es similar al pre-procesador de C, donde especificamos los

paquetes que vamos a usar en nuestro programa. Los cuales deben ser especificados al inicio del

programa, con ayuda de la sentencia import y acompañado de un punto y coma (;) al final de la

instrucción.

Eje:

Importjavax.swing.JOptionPane;

import java.io.*;

En java, podemos incluir todo el paquete, como en el caso de java.io, al agregarle el asterisco; o

simplemente, especificamos que archivos del paquete que queremos usar, como en el primer caso, en

el cual estamos incluyendo (o mejor dicho importando) el archivo JOptionPane, del paquete

P á g i n a | 16

Programación para Principiantes JAVA

javax.swing. (El cual nos ayuda para poder usar las cajitas de texto para mandar información a la

pantalla o para leerla desde el telado).

*LAS CLASES: Un Programa en java, debe poseer AL MENOS una clase, con la cual se debe

proseguir en la configuración de nuestro programa.

Eje: class Primer Programa

Como puede verse, una clase se especifica con la palabra reservada class.

Una clase puede ser: Pública o Privada.

De lo cual hablares más adelante, por el momento el usuario, debe únicamente especificar una clase,

únicamente con class porque después comprenderá la diferencia y podrá aplicarlo a sus programas.

Además el nombre de la clase, debe iniciar con mayúscula.

*EL PROGRAMA PRINCIPAL: El cual siempre, siempre, siempre se especificará de la siguiente

manera:

Public static void main (String args [])

Lo que está entre los parentesis, indica nada más los argumentos que recibe nuestro programa, el cual

SIEMPRE SERÁ uno del tipo String, el nombre de args, puede ser cambiado, pero NUNCA debe

omitirse los corchetes.

OJO: nunca debemos de olvidar que el main, siempre va después de la declaración de la clase,

y ambos (el main y la clase) contienen información entre llaves.

Ahora veamos un pequeño Ejemplo:

Ejemplo: Diseñe un programa en Java que muestre en pantalla un saludo de Bienvenida al Usuario.

Import java.lang.*;

Class PrimerPrograma {

Public static void main (String args []) {

System.out.println ("Hola! Bienvenido a Java");

}

}

Ahora vamos a Explicar el ejemplo anterior:

En la línea número Uno, encontramos la llamada al paquete, el cual es java.lang (éste paquete nos

ayuda para usar las funciones matemáticas y otras funciones como System.out.println, sin embargo

NO es necesario especificarlo, ya que Java, por defecto, incluye éste paquete en todos los programas

que creamos). Luego encontramos la declaración de la clase, la cual es Primer Programa, como puede

observar la primera letra es mayúscula, y como el nombre está compuesto por dos palabras (Primer y

Programa), es por tal razón que cada una de ellas tiene su primera letra mayúscula. Otra cosa

importante es que, el nombre del archivo, (que tiene extensión *.java), SIEMPRE se debe llamar igual

que la clase; es decir que, este código, está guardado como: PrimerPrograma.java. Posteriormente,

encontramos la sentencia System.out.println (), el cual nos sirve para mandar información a pantalla,

la cual será mostrada en la consola de DOS, y será más o menos así:

P á g i n a | 17

Programacion para Principiantes JAVA

Luego encontramos la llave correspondiente al main y la llave correspondiente a la clase.

OJO: Como puede notar, todas las sentencias en JAVA terminan con punto y coma (;).

CONTROL DE ACCESO O MODIFICADOR DE ACCESO

Cuando se crea una nueva clase en Java, se puede especificar el nivel de acceso que se quiere para

las variables de instancia y los métodos definidos en la clase:

Public

Public void CualquieraPuedeAcceder () {}

Cualquier clase desde cualquier lugar puede acceder a las variables y métodos de instacia públicos.

Protected

Protected void SoloSubClases () {}

Sólo las subclases de la clase y nadie más pueden acceder a las variables y métodos de instancia

protegidos.

Private

Private String NumeroDelCarnetDeIdentidad;

Las variables y métodos de instancia privados sólo pueden ser accedidos desde dentro de la clase. No

son accesibles desde las subclases.

Friendly (sin declaración específica)

Void MetodoDeMiPaquete () {}

Por defecto, si no se especifica el control de acceso, las variables y métodos de instancia se declaran

friendly (amigas), lo que significa que son accesibles por todos los objetos dentro del mismo paquete,

pero no por los externos al paquete. Es lo mismo que protected.

Los métodos protegidos (protected) pueden ser vistos por las clases derivadas, como en C++, y

también, en Java, por los paquetes (packages). Todas las clases de un paquete pueden ver los métodos

protegidos de ese paquete. Para evitarlo, se deben declarar como private protected, lo que hace que

ya funcione como en C++ en donde sólo se puede acceder a las variables y métodos protegidos de las

clases derivadas.

P á g i n a | 18

Programación para Principiantes JAVA

Separadores

Sólo hay un par de secuencias con otros caracteres que pueden aparecer en el código Java; son los

separadores simples, que van a definir la forma y función del código. Los separadores admitidos en

Java son:

() - paréntesis. Para contener listas de parámetros en la definición y llamada a métodos. También se

utiliza para definir precedencia en expresiones, contener expresiones para control de flujo y rodear

las conversiones de tipo.

{} - llaves. Para contener los valores de matrices inicializadas automáticamente. También se utiliza

para definir un bloque de código, para clases, métodos y ámbitos locales.

[] - corchetes. Para declarar tipos matriz. También se utiliza cuando se referencian valores de

matriz.

; - punto y coma. Separa sentencias.

, - coma. Separa identificadores consecutivos en una declaración de variables. También se utiliza

para encadenar sentencias dentro de una sentencia for.

. - punto. Para separar nombres de paquete de su paquetes y clases. También se utiliza para separar

una variable o método de una variable de referencia.

. - punto. Para separar nombres de paquete de su paquetes y clases. También se utiliza para separar

una variable o método de una variable de referencia.

Finalizadores

Java no utiliza destructores (al contrario que C++) ya que tiene una forma de recoger

automáticamente todos los objetos que se salen del alcance. No obstante proporciona un método

que, cuando se especifique en el código de la clase, el reciclador de memoria (garbage collector)

llamará:

// Cierra el canal cuando este objeto es reciclado

Protected void finalize () {

Close ();

}

P á g i n a | 19

Programacion para Principiantes JAVA

OBJETOS

Luego de conocer lo breve de las variables, pues bien, es importante saber esto, ya que iniciaremos

hablando de lo que es la esencia de Java:

Los Objetos

Un Objeto, es una colección de datos y operaciones, que utilizan esos datos.

Declarar un Objeto

Al declarar un objeto, lo único que hacemos es declarar una variable, de ése tipo, la cual hará

referencia a ése objeto. Por tanto, dicha variable contendrá una dirección de memoria (Algo similar a

lo que eran los punteros en C). Un objeto se crea, a partir del operador new y el constructor

correspondiente a la clase, de la cual se está creando el objeto. Por ejemplo, si deseamos crear, un

objeto de la Clase Datos, sería así:

Datos Jefe; //Declaración del Objeto

Jefe=new Datos (); //Creación del Objeto

Pero También podemos hacerlo en una sola línea:

Datos Jefe=new Datos (); //Declaración y Creación del Objeto

Puesto que, de la misma manera que, se puede declarar e inicializar una variable; un objeto puede ser

declarado y creado al mismo tiempo.

Creación de Un Objeto

nomb_clase nomb_objeto=new nomb_clase ([valores]);

Cuando se hace referencia a un método este debe estar declarado y desarrollado al igual que el objeto.

Para declarar y desarrollar un método debe estar dentro de una clase y se debe indicar el valor que

devuelve, el nombre y los valores que se le pasan.

Definición de los Métodos

valor devuelto nombre_método([valores])

{

cuerpo;

}

Si tenemos que hacer referencia a las variables de instancia y los métodos contenidos en un objeto

se necesita el operador punto(.).

Objeto.nomb_método( );

Objeto.nomb_método(valores);

Objeto.variable;

Creación de Un Objeto

nomb_clase nomb_objeto=new nomb_clase ([valores]);

P á g i n a | 20

Programación para Principiantes JAVA

Cuando se hace referencia a un método este debe estar declarado y desarrollado al igual que el objeto.

Para declarar y desarrollar un método debe estar dentro de una clase y se debe indicar el valor que

devuelve, el nombre y los valores que se le pasan.

Herencia

La herencia es una de las características fundamentales de la POO, ya que es la que permite un gran

aumento en la reutilización de código. La posibilidad de crear nuevas clases basadas en otras pre-

existentes permite, entre otras cosas, crear bibliotecas genéricas, en base a las cuales realizar

pequeños ajustes para adaptarlas a las necesidades puntuales de cada aplicación.

Para crear una clase basada en una pre-existente se utiliza la siguiente sintaxis:

Class SubClase extends SuperClase

Una subclase hereda todos los métodos y propiedades que le provee su superclase y puede utilizarlos

como propios. Una superclase puede ser a su vez subclase de otra y así se estructura una jerarquía de

clases, donde hacia abajo aumenta la especialización y hacia arriba la generalidad. Ejemplo:

En este caso, todos los animales tienen, por ejemplo, un método comer, todos los mamíferos un

método mamar y todas las aves un método volar. Aquí el mecanismo de herencia permite desarrollar

una sola vez los métodos de son comunes a todas las subclases y sólo programar en éstas aquellas

características que las diferencian de sus pares.

Se considera que una instancia de una subclase es también instancia de toda superclase de la misma,

en el ejemplo, todo perro es un mamífero y también un animal, lo cual implica que todo perro tiene

todas las propiedades y métodos propios de los mamíferos, así como también aquellas de los animales.

De este modo, una clase puede utilizar métodos que no tiene definidos de la misma forma en que

utilizaría los propios:

class SuperClase

{ protected int unMetodo()

{

return 1;

} }

class SubClase extends SuperClase

{

public void otroMetodo()

{

System.out.println( unMetodo() );

}

P á g i n a | 21

Programacion para Principiantes JAVA

}

A su vez, una subclase podría optar por reemplazar algún método heredado de una superclase, para

especificar un comportamiento diferente. Por ejemplo, todos los animales comen, pero para un perro

no significa lo mismo comer que para un gato. En Java, todas las clases automáticamente heredan de

una clase llamada Object, la cual provee ciertos métodos, entre ellos toString(), un método que

muestra la representación en una cadena de caracteres del objeto en cuestión y que generalmente es

una buena idea sobrescribir.Si una subclase oculta (sobrescribe) un método de su superclase, aún

puede querer en algún caso utilizar el original. Para lograr este objetivo se usa la palabra clave super.

Ejemplo: Programa que crea un objeto llamando persona, el cual lee e imprime el nombre y edad

de una persona.

class Persona{

public String Nombre;

public int edad;

public Persona(String nom, int x)

{

Nombre=nom;

edad=x;

}

}

//clase que se deriva de Persona

class Persona2 extends Persona {

public double sueldo;

public Persona2 (String nom, int x, double sal)

{

super (nom, x);

sueldo=sal;

}

La sentencia super lo que hace es llamar al constructor de la superclase (clase de la que heredamos).

En la función principal es donde se crea el objeto que llama al miembro constructor, al cual hay que

pasar 3 valores (uno para la clase punto2 y dos para la clase punto).

P á g i n a | 22

Programación para Principiantes JAVA

CLASES Una clase es una agrupación de datos (variables o campos) y de funciones (métodos) que operan

sobre esos datos. A estos datos y funciones pertenecientes a una clase se les denomina variables y

métodos o función miembro. La programación orientada a objetos se basa en la programación de

clases. Las clases son lo más simple de Java. Todo en Java forma parte de una clase, es una

clase o describe cómo funciona una clase. El conocimiento de las clases es fundamental para

poder entender los programas Java.

Todas las acciones de los programas Java se colocan dentro del bloque de una clase o un objeto.

Todos los métodos se definen dentro del bloque de la clase, Java no soporta funciones o variables

globales. Esto puede despistar a los programadores de C++, que pueden definir métodos fuera del

bloque de la clase, pero esta posibilidad es más un intento de no separarse mucho y ser compatible

con C, que un buen diseño orientado a objetos. Así pues, el esqueleto de cualquier aplicación Java se

basa en la definición de una clase.

Todos los datos básicos, como los enteros, se deben declarar en las clases antes de hacer uso de ellos.

En C la unidad fundamental son los ficheros con código fuente, en Java son las clases. De hecho son

pocas las sentencias que se pueden colocar fuera del bloque de una clase. La palabra clave import

(equivalente al #include) puede colocarse al principio de un fichero, fuera del bloque de la clase. Sin

embargo, el compilador reemplazará esa sentencia con el contenido del fichero que se indique, que

consistirá, como es de suponer, en más clases. Luego de haber conocido un poco lo que es la clase vamos a deducir que por la definición de una clase se realiza en la siguiente forma:

[Public] class Classname {//lo de public es opcional

// Definición de variables y métodos

...

}

A continuación se enumeran algunas características importantes de las clases:

Todas las variables y funciones de Java deben pertenecer a una clase. No hay variables y

funciones globales.

Si una clase deriva de otra (extends), hereda todas sus variables y métodos.

Java tiene una jerarquía de clases estándar de la que pueden derivar las clases que crean

los usuarios.

Una clase sólo puede heredar de una única clase (en Java no hay herencia múltiple). Si al

definir una clase no se especifica de qué clase deriva, por defecto la clase deriva de Object.

La clase Object es la base de toda la jerarquía de clases de Java.

En un fichero se pueden definir varias clases, pero en un fichero no puede haber más que

una clase public. Este fichero se debe llamar como la clase public que contiene con extensión

*.java. Con algunas excepciones, lo habitual es escribir una sola clase por fichero.

Si una clase contenida en un fichero no es public, no es necesario que el fichero se llame

como la clase.

Los métodos de una clase pueden referirse de modo global al objeto de esa clase al que se

aplican por medio de la referencia this.

Las clases se pueden agrupar en packages, introduciendo una línea al comienzo del fichero

(package packageName;). Esta agrupación en packages está relacionada con la jerarquía de

directorios y ficheros en la que se guardan las clases.

P á g i n a | 23

Programacion para Principiantes JAVA

Para la creación de un objeto se necesita el operador new, y que se declaren las variables de

instancia dentro de una clase. Mediante una clase se pueden declarar varios objetos que tendrán

los mismos atributos.

Ejemplo: Diseñe una Clase, para crear objetos del tipo Alumnos, en el cual, permita ingresar el

nombre, edad y Nota de ciertos objetos de ese tipo.

Solución:

Digite el siguiente código

/*Archivo Alumnos.Java*/

import javax.swing.*;

public class Alumnos{

//declaración de los atributos

public String Nombre;

public int Edad;

public double Nota;

//declaración de los métodos

public void EstablecerNombre()

{

Nombre=JOptionPane.showInputDialog("Ingrese el nombre: ");

}

public void EstablecerEdad(int x)

{

Edad=x;//el valor recibido lo asigna a Edad

}

public void EstablecerNota(double y)

{

Nota=y;

}

/*Este método, muestra todos los datos del del objeto en pantalla*/

public void MostrarDatos()

{

String salida="Nombre del Alumno: "+Nombre+"\nEdad: "+Edad+"\nNota: "+Nota;

JOptionPane.showMessageDialog(null, salida);

}

}

Luego guarde el archivo, Compílelo, pero NO lo ejecute. Con esto estamos creando nuestra Clase,

con la cual, podremos construir Objetos de este tipo. Ahora, y en otro archivo digite las siguientes

sentencias:

/*Archivo UsaAlumnos.java*/

class UsaAlumnos{

public static void main (String args []) {

//declaramos y creamos un objeto del tipo Alumnos

P á g i n a | 24

Programación para Principiantes JAVA

Alumnos Datos=new Alumnos();

//LLamamos a los métodos

Datos.EstablecerNombre();

Datos.EstablecerEdad(20);

Datos.EstablecerNota(9.5);

//Ahora mostramos los Datos

Datos.MostrarDatos();

}

} Luego Guarde el archivo, Compílelo y Ejecútelo.

Ahora vamos a explicar el ejemplo Anterior.

En el ejemplo anterior puede notar que, los atributos, son esas variables simples, es las cuales

almacenaremos información relevante a los objetos que, crearemos a partir de esa clase. Además que,

los estamos declarando como públicos, lo cual indica que tenemos acceso directo desde cualquier

otro archivo a los atributos. Los métodos son del tipo public y no devuelven ningún valor, por tal

razón son declarados como void. Además que. El método EstablecerEdad y EstablecerNota, reciben

un argumento cada uno de ellos, el cual es asignado al respectivo atributo.

CLASES QUE UTILIZAMOS EN JAVA

LA CLASE MATH

La clase Math representa la librería matemática de Java. Las funciones que contiene son las de

todos los lenguajes, parece que se han metido en una clase solamente a propósito de agrupación, por

eso se encapsulan en Math, y lo mismo sucede con las demás clases que corresponden a objetos que

tienen un tipo equivalente (Character, Float, etc.). El constructor de la clase es privado, por los que

no se pueden crear instancias de la clase. Sin embargo, Math es public para que se pueda llamar

desde cualquier sitio y static para que no haya que inicializarla. Veamos la siguiente tabla:

Método Descripción

static double E Valor del número e, base del logaritmo natural.

double PI Valor del número PI (3.1416…..)

Tipo abs(tipo a) Valor absoluto de a.

Tipo max(tipo a, tipo b) Valor mayor entre a y b

Tipo min(tipo a, tipo b) Valor menor entre a y b

double random() Valor aleatorio, comprendido entre 0.0 y 1.0

double rint(double a) Redondeo de a

double sqrt (double a) Devuelve la raíz cuadrada de a

P á g i n a | 25

Programacion para Principiantes JAVA

double exp(double a) Devuelve el avlor de ea

double log (double a) Devuelve el logaritmo a de a

double pow(double a, double b) Devuelve el valor de ab

double acos(double a) Devuelve el arco coseno de a

double asin(double a) Devuelve el arco seno de a

double atan(double a) Devuelve el arco tangente de a

double sin(double a) Devuelve el seno de a

double cos(double a) Devuelve el coseno de a

double tan(double a) Tangente de a

Tabla 4.3

Si se importa la clase, se tiene acceso al conjunto de funciones matemáticas estándar:

Math.abs( x ) para int, long, float y double

Math.sin( double )

Math.cos( double )

Math.tan( double )

Math.asin( double )

Math.acos( double )

Math.atan( double )

Math.atan2( double,double )

Math.exp( double )

Math.log( double )

Math.sqrt( double )

Math.ceil( double )

Math.floor( double )

Math.rint( double )

Math.pow( a,b )

Math.round( x ) para double y float

Math.random() devuelve un double

Math.max( a,b ) para int, long, float y double

Math.min( a,b ) para int, long, float y double

Math.E para la base exponencial

Math.PI para PI

Ejemplo: Diseñe una aplicación en Java que dado el valor de un ángulo, encuentre su seno, coseno,

tangente. Luego, le permita ingresar un dato al usuario, con el cual, pueda calcular su raíz cuadrada.

Import javax. swing.*;

class UsaMetodos

P á g i n a | 26

Programación para Principiantes JAVA

{

public static void main(String args [])

{

String leer;

double angulo, valor;

leer=JOptionPane.showInputDialog("Ingrese el valor del ángulo: ");

angulo=Double.parseDouble(leer);

JOptionPane.showMessageDialog(null, "El valor del seno es: "+Math.sin(angulo)+"\nEl Valor del

Coseno del angulo es: "+Math.cos(angulo)+"\nY la tangente es: "+Math.tan(angulo));

leer=JOptionPane.showInputDialog("Ingrese el valor, al cual le desea calcular la raíz cuadrada:");

valor=Double.parseDouble(leer);

JOptionPane.showMessageDialog(null, "La raíz cuadrada de: "+valor+" es: "+Math.sqrt(valor));

}

}

Ahora vamos a explicar el Ejemplo Anterior:

Recuerde que, le método showInputDialog, devuelve un tipo de dato String, es por esa razón que,

siempre debemos realizar el cambio al tipo de dato que deseamos usar, en nuestro caso double.

Además que, para llamar los diferentes métodos matemáticos, lo hacemos de la siguiente forma:

Math.nombre_de_metodo (parámetro);

Además que, en vez de realizar el cálculo y la impresión en la misma línea (en el método

showMessageDialog), podríamos haber calculado los respectivos valores por separado, asignarlos a

tres variables auxiliares, y mandar a impresión esas variables.

LA CLASE CHARACTER

Al trabajar con caracteres se necesitan muchas funciones de comprobación y traslación. Estas

funciones están empleadas en la clase Character. De esta clase sí que se pueden crear instancias, al

contrario que sucede con la clase Math.

Declaraciones

La primera sentencia creará un variable carácter y la segunda un objeto Character:

Char c;

Character C;

Comprobaciones booleanas

Character.isLowerCase(c)

Character.isUpperCase(c)

Character.isDigit(c)

Character.isSpace(c)

En este caso, si tuviésemos un objeto Character C, no se podría hacer C.isLowerCase,

porque no se ha hecho un new de Character. Estas funciones son estáticas y no conocen al

objeto, por eso hay que crearlo antes.

P á g i n a | 27

Programacion para Principiantes JAVA

Traslaciones de caracteres

Char c2 = Character.toLowerCase(c);

Char c2 = Character.toUpperCase(c);

Traslaciones de carácter/dígito

Int i = Character.digit(c, base);

Char c = Character.forDigit (i, base);

Métodos de la clase Character

C = new Character (‘J’);

Char c = C.charValue ();

String s = C.toString ();

Ejemplo: Diseñe un Programa que, lea una cadena de Caracteres, y luego, muestre esa misma

cadena en minúsculas, mayúsculas y la longitud de la misma.

import javax.swing.*;

public class UsoCadenas {

public static void main (String args []) {

String cadena, aux;

cadena=JOptionPane.showInputDialog("Ingrese la Cadena");

/*En la variable aux, guardamos la nueva cadena

Note la forma en la que llamamos los métodos:

Variable.Nombre_del_Metodo();*/

aux=cadena.toLowerCase();

JOptionPane.showMessageDialog(null, "Cadena en Minúsculas: "+aux);

aux=cadena.toUpperCase();

JOptionPane.showMessageDialog(null, "Cadena en Mayúsculas: "+aux);

JOptionPane.showMessageDialog(null, "La longuitud de la cadena es: "+cadena.length());

}

}

Ahora vamos a explicar el Ejemplo Anterior

Declaramos dos referencias a objetos de la clase String, una de ellas es identificada por "cadena", la

cual guardamos, la cadena que, el usuario ha ingresado. La otra referencia (aux), nos sirve para

guardar, el resultado que devuelven los métodos que hemos llamado. En las líneas 9,10 y 11, puede

observar, la forma en la que se llaman a los métodos correspondientes, para las operaciones que

deseamos realizar. La sintaxis es la siguiente:

Nombre_de_la_refencia_de_objeto. Nombre_del_metodo ();

Existen, algunos métodos que, reciben parámetros, los cuales, deben especificarse, dentro de los

paréntesis del mismo. Pero, en el ejemplo anterior no es el caso. La clase StringBuffer se utiliza

prácticamente siempre que se desee modificar una cadena de caracteres. Completa los métodos de

la clase String ya que éstos realizan sólo operaciones sobre el texto que no conllevan un aumento o

disminución del número de letras del String. Recuérdese que hay muchos métodos cuyos

P á g i n a | 28

Programación para Principiantes JAVA

argumentos deben ser objetos String, que antes de pasar esos argumentos habrá que realizar la

conversión correspondiente. La Tabla 4.2 muestra los métodos más importantes de la clase

StringBuffer.

LA CLASE FLOAT

Cada tipo numérico tiene su propia clase de objetos. Así el tipo float tiene el objeto Float.

De la misma forma que con la clase Character, se han codificado muchas funciones útiles

dentro de los métodos de la clase Float.

Declaraciones

La primera sentencia creará una variable float y la segunda un objeto Float:

Float f;

Float F;

Valores de Float

Float.POSITIVE_INFINITY

Float.NEGATIVE_INFINITY

Float.NaN

Float.MAX_VALUE

Float.MIN_VALUE

Conversiones de Clase/Cadena

String s = Float.toString (f);

f = Float.valueOf (“3.14”);

Comprobaciones

Boolean b = Float.isNaN (f);

Boolean b = Float.isInfinite (f);

La función isNaN () comprueba si f es un No-Número. Un ejemplo de no-número es raiz

cuadrada de -2.

Conversiones de Objetos Float F = new Float (Float.PI);

String s = F.toString ();

Int i = F.intValue ();

Long l = F.longValue ();

Float F = F.floatValue ();

Double d = F.doubleValue ();

Otros Métodos

Int i = F.hashCode ();

Boolean b = F.equals ( Object obj );

Int i = Float.floatToIntBits ( f );

P á g i n a | 29

Programacion para Principiantes JAVA

Float f = Float.intBitsToFloat ( i );

LA CLASE DOUBLE

Cada tipo numérico tiene su propia clase de objetos. Así el tipo double tiene el objeto

Double. De la misma forma que con la clase Character, se han codificado muchas

funciones útiles dentro de los métodos de la clase Double.

Declaraciones

La primera sentencia creará una variable double y la segunda un objeto Double:

Double d;

Double D;

Valores de Double

Double.POSITIVE_INFINITY

Double.NEGATIVE_INFINITY

Double.NaN

Double.MAX_VALUE

Double.MIN_VALUE

Métodos de Double

D.isNaN ();

Double.isNaN (d);

D.isInfinite ();

Double.isInfinite (d);

Boolean D.equals ();

String D.toString ();

int D.intValue();

long D.longValue();

float D.floatValue();

double D.doubleValue();

int i = D.hashCode();

Double V.valueOf( String s );

long l = Double.doubleToLongBits( d );

double d = Double.longBitsToDouble( l );

LA CLASE INTEGER

Cada tipo numérico tiene su propia clase de objetos. Así el tipo int tiene el objeto Integer. De

la misma forma que con la clase Character, se han codificado muchas funciones útiles dentro

de los métodos de la clase Integer.

Declaraciones

La primera sentencia creará una variable int y la segunda un objeto Integer:

Integer.MIN_VALUE;

Integer.MAX_VALUE;

P á g i n a | 30

Programación para Principiantes JAVA

Valores de Integer

Integer.MIN_VALUE;

Integer.MAX_VALUE;

Métodos de Integer

String Integer.toString( int i,int base );

String Integer.toString( int i );

int I.parseInt( String s,int base );

int I.parseInt( String s );

Integer Integer.valueOf( String s,int base );

Integer Integer.valueOf( String s );

int I.intValue();

long I.longValue();

float I.floatValue();

double I.doubleValue();

String I.toString();

int I.hashCode();

boolean I.equals( Object obj );

LA CLASE LONG

Cada tipo numérico tiene su propia clase de objetos. Así el tipo long tiene el objeto Long. De la misma

forma que con la clase Character, se han codificado muchas funciones útiles dentro de los métodos

de la clase Long.

Declaraciones

La primera sentencia creará una variable long y la segunda un objeto Long:

long l;

Long L;

Valores de Long

Long.MIN_VALUE;

Long.MAX_VALUE;

Métodos de Long

String Long.toString( long l,int base );

String Long.toString( long l );

long L.parseLong( String s,int base );

long L.parseLong( String s );

Long Long.valueOf( String s,int base );

Long Long.valueOf( String s );

int L.intValue();

long L.longValue();

float L.floatValue();

double L.doubleValue();

String L.toString();

int L.hashCode();

P á g i n a | 31

Programacion para Principiantes JAVA

boolean L.equals( Object obj );

En los métodos toString (), parseInt () y valueOf () que no se especifica la base sobre la que se trabaja,

se asume que es base 10.

LA CLASE BOOLEAN

Los valores boolean también tienen su tipo asociado Boolean, aunque en este caso hay

menos métodos implementados que para el resto de las clases numéricas.

Declaraciones

La primera sentencia creará una variable boolean y la segunda un objeto Boolean:

boolean b;

Boolean B;

Valores de Boolean

Boolean.TRUE;

Boolean.FALSE;

Métodos de Boolean

boolean B.booleanValue();

String B.toString();

boolean B.equals( Object obj );

LA CLASE STRING

Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y StringBuffer. Un

objeto String representa una cadena alfanumérica de un valor constante que no puede ser cambiada

después de haber sido creada. Un objeto StringBuffer representa una cadena cuyo tamaño puede

variar.

Los Strings son objetos constantes y por lo tanto muy baratos para el sistema. La mayoría

de las funciones relacionadas con cadenas esperan valores String como argumentos y

devuelven valores String.

Hay que tener en cuenta que las funciones estáticas no consumen memoria del objeto, con

lo cual es más conveniente usar Character que char. No obstante, char se usa, por ejemplo,

para leer ficheros que están escritos desde otro lenguaje.

Existen muchos constructores para crear nuevas cadenas:

String();

String( String str );

String( char val[] );

P á g i n a | 32

Programación para Principiantes JAVA

String( char val[],int offset,int count );

String( byte val[],int hibyte );

String( byte val[],int hibyte,int offset,int count );

Tal como uno puede imaginarse, las cadenas pueden ser muy complejas, existiendo muchas

funciones muy útiles para trabajar con ellas y, afortunadamente, la mayoría están

codificadas en la clase String.

Funciones Básicas

La primera devuelve la longitud de la cadena y la segunda devuelve el carácter que se

encuentra en la posición que se indica en indice:

int length();

char charAt( int indice );

Funciones de Comparación de Strings

boolean equals( Object obj );

boolean equalsIgnoreCase( Object obj );

Lo mismo que equals() pero no tiene en cuenta mayúsculas o minúsculas.

int compareTo( String str2 );

Devuelve un entero menor que cero si la cadena es léxicamente menor que str2. Devuelve

cero si las dos cadenas son léxicamente iguales y un entero mayor que cero si la cadena es

léxicamente mayor que str2.

Funciones de Comparación de Subcadenas

boolean regionMatch( int thisoffset,String s2,int s2offset,int len );

boolean regionMatch( boolean ignoreCase,int thisoffset,String s2,

int s2offset,int 1 );

Comprueba si una región de esta cadena es igual a una región de otra cadena.

boolean startsWith( String prefix );

boolean startsWith( String prefix,int offset );

boolean endsWith( String suffix );

Devuelve si esta cadena comienza o termina con un cierto prefijo o sufijo comenzando en

un determinado desplazamiento.

int indexOf( int ch );

int indexOf( int ch,int fromindex );

int lastIndexOf( int ch );

int lastIndexOf( int ch,int fromindex );

int indexOf( String str );

int indexOf( String str,int fromindex );

P á g i n a | 33

Programacion para Principiantes JAVA

int lastIndexOf( String str );

int lastIndexOf( String str,int fromindex );

Devuelve el primer/último índice de un carácter/cadena empezando la búsqueda a partir de

un determinado desplazamiento.

String substring( int beginindex );

String substring( int beginindex,int endindex );

String concat( String str );

String replace( char oldchar,char newchar );

String toLowerCase();

String toUpperCase();

String trim();

Ajusta los espacios en blanco al comienzo y al final de la cadena.

void getChars( int srcBegin,int srcEnd,char dst[],int dstBegin );

void getBytes( int srcBegin,int srcEnd,byte dst[],int dstBegin );

String toString();

char toCharArray();

int hashCode();

Funciones ValueOf

La clase String posee numerosas funciones para transformar valores de otros tipos de datos

a su representación como cadena. Todas estas funciones tienen el nombre de valueOf,

estando el método sobrecargado para todos los tipos de datos básicos.

Veamos un ejemplo de su utilización:

String Uno = new String (“Hola Mundo”);

float f = 3.141592;

String PI = Uno.valueOf( f );

String PI = String.valueOf( f ); // Mucho más correcto

Funciones de Conversión

String valueOf( boolean b );

String valueOf( int i );

String valueOf( long l );

String valueOf( float f );

String valueOf( double d );

String valueOf( Object obj );

String valueOf( char data[] );

String valueOf( char data[],int offset,int count );

Usa arrays de caracteres para la cadena. String copyValueOf( char data[] );

String copyValueOf( char data[],int offset,int count );

Crea un nuevo array equivalente para la cadena.

LA CLASE STRINGBUFFER

P á g i n a | 34

Programación para Principiantes JAVA

Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y

StringBuffer. Un objeto String representa una cadena alfanumérica de un valor constante

que no puede ser cambiada después de haber sido creada. Un objeto StringBuffer representa

una cadena cuyo tamaño puede variar.

La clase StringBuffer dispone de muchos métodos para modificar el contenido de los

objetos StringBuffer. Si el contenido de una cadena va a ser modificado en un programa,

habrá que sacrificar el uso de objetos String en beneficio de StringBuffer, que aunque

consumen más recursos del sistema, permiten ese tipo de manipulaciones.

Al estar la mayoría de las características de los StringBuffers basadas en su tamaño

variable, se necesita un nuevo método de creación:

StringBuffer();

StringBuffer( int len );

StringBuffer( String str );

Se puede crear un StringBuffer vacío de cualquier longitud y también se puede utilizar un

String como punto de partida para un StringBuffer.

StringBuffer Dos = new StringBuffer( 20 );

StringBuffer Uno = new StringBuffer( "Hola Mundo" );

CLASES ABSTRACTAS: Una de las características más útiles de cualquier lenguaje orientado a

objetos es la posibilidad de declarar clases que definen como se utiliza solamente, sin tener que

implementar métodos. Esto es muy útil cuando la implementación es específica para cada usuario,

pero todos los usuarios tienen que utilizar los mismos métodos. Un ejemplo de clase abstracta en Java

es la clase Graphics: public abstract class Graphics {

public abstract void drawLine( int x1,int y1,int x2,

int y2 );

public abstract void drawOval( int x,int y,int width,

int height );

public abstract void drawArc( int x,int y,int width,

int height,int startAngle,int arcAngle );

. . .

}

Los métodos se declaran en la clase Graphics, pero el código que ejecutará el método está en algún

otro sitio:

public class MiClase extends Graphics {

public void drawLine( int x1,int y1,int x2,int y2 ) {

<código para pintar líneas -específico de

la arquitectura->

}

}

Cuando una clase contiene un método abstracto tiene que declararse abstracta. No obstante, no

todos los métodos de una clase abstracta tienen que ser abstractos. Las clases abstractas no pueden

P á g i n a | 35

Programacion para Principiantes JAVA

tener métodos privados (no se podrían implementar) ni tampoco estáticos. Una clase abstracta tiene

que derivarse obligatoriamente, no se puede hacer un new de una clase abstracta.

Una clase abstracta en Java es lo mismo que en C++ virtual func () = 0; lo que obliga a que al

derivar de la clase haya que implementar forzosamente los métodos de esa clase abstracta.

Control General del Flujo o Sentencias de Control

Todo lenguaje de programación cuenta (o al menos debería contar), con una serie de instrucciones

que, le permitan controlar el flujo de ejecución de las instrucciones. Afortunadamente Java posee dos

grandes rubros de dichas sentencias:

Estructuras Selectivas, en las cuales encontramos el if, elseif y switch.

Estructuras Repetitivas o Cilclos, entre las cuales están: while, do… while y for.

Estructuras Selectivas

En la vida, muchas veces, nos toca elegir entre un camino y otro a seguir. En muchas de las actividades

que realizamos día con día, nos enfrentamos a decisiones que debemos tomar y que, de una u otra

forma, alteran el cause normal de nuestra vida (o de nuestro programa).

Sentencia if

La sentencia if (o si condicional), le permite a un programa decidir, mediante la evaluación de una

condición, ejecutar una u otra acción o acciones.

La sintaxis General es La siguiente:

If (condicion1)

Accion1;

En donde:

Condición 1: Representa una expresión que puede ser del tipo booleana.

Acción 1: es la acción que, al evaluar la condición como verdadera, se ejecutará.

Si son varias acciones, van entre llaves.

Ejemplo: Diseñe un programa en Java, que calcule, los descuentos a un trabajador, sabiendo que,

son aplicables, un 6.25% del salario en AFP, sólo si éste es superior a $300.00; Además que, si es un

trabajador hombre, se le descuenta, aparte del AFP, el 3% sobre el sueldo en concepto de ISSS y

10% en concepto de Renta.

import javax.swing.*;

class Descuentos{

public static void main (String args []) {

String datos;

int sexo;

double sueldo, afp=0, isss, totalre, nsueldo, renta;

datos=JOptionPane.showInputDialog("Ingrese el sueldo del empleado (a)");

sueldo=Double.parseDouble(datos);

if(sueldo>300)//Preuntamos si el sueldo es mayor a 300

P á g i n a | 36

Programación para Principiantes JAVA

afp=sueldo*0.0625;// si es mayor, aplicamos descuento

JOptionPane.showMessageDialog(null, "Este empleado tiene un sueldo de: "+sueldo+" y El

descuento del AFP es: "+afp);

datos=JOptionPane.showInputDialog("Ingrese el Sexo: \nSi es Masculino (1)\nSi es Femenino

(2)");

sexo=Integer.parseInt(datos);

if(sexo==1)//Si es de sexo masculino

{

isss=sueldo*0.03;//aplicamos las otras retenciones

renta=sueldo*0.10;

totalre=afp+isss+renta;

nsueldo=sueldo-totalre;

JOptionPane.showMessageDialog(null, "A este empleado, se le retiene: "+isss+" En concepto de

ISSS\nAdemás Se le retiene: "+renta+" En Concepto de Renta\nLo que hace un total de:

"+totalre+"\nY su nuevo sueldo es: "+nsueldo);

}//del if

}//del main

}// de la clase

En las sentencias if, podemos agregar la sentencia else, la cual indica que, si al evaluar la condición,

ésta es falsa, entonces, realizará las acciones, que estén después del else. La sintaxis es la siguiente:

If(condición1)

{

Acciones;

}

Else

{

Condiciones;

}

OJO: Las Condiciones, a evaluar, pueden ser expresiones compuestas. Es decir, usando

operadores and (&&), Or (11), etc.

Ejemplo: Al ingresar la nota de un alumno, se desea saber si éste aprobó o no, una materia en el

colegio. Se sabe que para aprobar, se necesita una nota mayor o igual a 7.0. Diseñe una aplicación en

Java que, al ingresar la nota, muestre con un mensaje, si el alumno, aprobó o no. Además se sabe que

si la nota está entre 6.50 y 6.99, tiene la posibilidad de realizar un examen de suficiencia para aprobar.

import javax.swing.*;

public class NotaAlum{

public static void main (String args []){

String leer;

double Nota;

leer=JOptionPane.showInputDialog("Ingrese la nota del alumno");

Nota=Double.parseDouble(leer);

if(Nota>=7.0)

P á g i n a | 37

Programacion para Principiantes JAVA

JOptionPane.showMessageDialog(null, "El alumno APROBÓ!!!!!!");

else

{

JOptionPane.showMessageDialog(null, "El alumno reprobó");

if(Nota>=6.5 && Nota<=6.99)

JOptionPane.showMessageDialog(null, "Pero tiene la posibilidad de realizar el examen de

suficiencia");

}//del else

}//del main

}//de la clase

Ahora vamos a explicar el Ejemplo Anterior:

En la línea 13, colocamos una condición compuesta, es decir que, si el alumno alcanza una nota

mayor o igual a 6.5, pero menor a 7.0 (es decir 6.99), tiene la posibilidad de realizar el examen. Note

además que, una estructura, puede estar dentro de otra, lo que llamamos Anidamiento, para el

caso, el if de la línea 13, está dentro del else, que inicia en la línea 10.

Sentencia elseif

Esta estructura, es una consecuencia de las estructuras if anidadas, su formato es el siguiente:

if(condicion1)

Sentencia 1;

elseif(condicion2)

Sentencia 2;

elseif(condicion3)

Sentencia 3;

...

else

Sentencia n;

Funciona de la siguiente manera:

Se evalúa la primera condición, si resulta verdadera se ejecuta la sentencia 1, y se continúa con la

ejecución del programa; de lo contrario, de evalúa la condición 2, si resulta verdadera, se ejecuta la

sentencia 2, de lo contrario se evalúa la condición 3 y así sucesivamente. Si al evaluar todas las

condiciones, ninguna resulta verdadera, se ejecuta el bloque del else.

Ejemplo: Cree un Applet que, reciba como ingreso la nota de un alumno y la clasifique, según la

siguiente tabla: Excelente, Muy Bueno, Bueno, Regular, Necesita Mejorar.

Cabe recalcar que dicha escuela, maneja solamente notas cerradas, es decir, sin decimales.

import javax.swing.*;

import java.awt.*;

public class NotasAlumno extends JApplet

{ //declaracion de variables

String leer;

P á g i n a | 38

Programación para Principiantes JAVA

double nota;

public void init()

{

leer=JOptionPane.showInputDialog("Ingrese La Nota:");

nota=Double.parseDouble(leer);

}

public void paint(Graphics g)

{

super.paint(g);

if(nota<=10 && nota>=9)

g.drawString("Excelente!!!!", 50,50);

else if(nota<=8 && nota>=7)

g.drawString("Muy Bueno!!!!", 50,50);

else if(nota<=6 && nota>=5)

g.drawString("Bueno", 50,50);

else if(nota<=4 && nota>=3)

g.drawString("Regular", 50,50);

else if(nota<=2 && nota>=1)

g.drawString("Necesita Mejorar...", 50,50);

else

g.drawString("Nota Incorrecta!!!", 50,50);

}//del paint

}// de la clase

Sentencia switch

Esta sentencia, permite ejecutar, una u otra u otra acción, al evaluar una condición, cuyo resultado es

el que indica que bloque (o bloques) de instrucciones se van a ejecutar. Su sintaxis es la siguiente:

switch(expresión)

{

case 1:

Sentecia 1;

break;

case 2:

Sentecia 2;

break;

. . .

default:

Sentencias;

break;

}

En donde, expresión es una condición que, al evaluarla, nos indicará que camino debemos seguir.

Además ésta puede ser, una expresión entera char, byte, int y short. Además que, la expresión

constante que acompaña a la palabra reservada case debe ser del mismo tipo que expresión. La

cláusula default es opcional y puede omitirse en los programas que desarrollemos.

P á g i n a | 39

Programacion para Principiantes JAVA

Ejemplo: En una tienda, se realizan diferentes descuentos, a sus clientes al momento de cancelar

en caja. Ya que, cuando se disponen a cancelar tienen la oportunidad de sacar una bolita, y

dependiendo del color de la misma, se le aplica su respectivo descuento. Si la bolita es roja, se le

aplica un 10% de descuento sobre la compra; si la bola es verde, se le aplica un 5% de descuento, y

si la bolita es blanca, no se le aplica descuento alguno. Diseñe una aplicación que de soporte a ésta

actividad en el súper mercado.

Import javax. swing.*;

public class SuperMercado

{

public static void main (String args [])

{

String aux;

int bolita;

double compra, descuento=0, monto;

//leemos el import de la compra

aux=JOptionPane.showInputDialog("Ingrese el importe de la compra: ");

compra=Double.parseDouble(aux);

//leemos el color de la bolita

aux=JOptionPane.showInputDialog("Ingrese el color de la Bolita:\nSi es Roja, ingrese 1\nSi fue

Verde, Ingrese 2\nSi fue Blanca, ingrese 3");

bolita=Integer.parseInt(aux);

switch(bolita)

{

case 1:

{

descuento=compra*.10;

monto=compra-descuento;

}

break;

case 2:

{

descuento=compra*.05;

monto=compra-descuento;

}

break;

case 3:

monto=compra;

break;

default:

monto=compra;

break;

}//del switch

JOptionPane.showMessageDialog(null, "El cliente había consumido: "+compra+" Pero sacó una

bolita color: "+bolita+"\nPor lo que se aplicó un descuento de: "+descuento+"\nAhora el saldo a

P á g i n a | 40

Programación para Principiantes JAVA

cancelar es: "+monto);

}//del main

}// de la clase

Estructuras Iterativas

OJO: Puede notar que, la estructura else if, y la estructura switch, realizan prácticamente la

misma función por lo que para el usuario, es invisible la diferencia entre uno y otro. Sin

embargo, el la estructura else if, podemos colocar intervalos de valores, con la ayuda del && y

el 11, lo que no se puede hacer en el switch.

Es muy común encontrar en los programas operaciones que se deben ejecutar un número repetido de

veces en períodos más o menos espaciados. Si bien las instrucciones son las mismas, los datos sobre

los que operan varían. A nuestro alrededor, encontramos problemas que presentan esas características,

por ejemplo: el cálculo de la nota final de los estudiantes de Programación III, se realizará tantas

veces como alumnos hayan inscritos en dicha asignatura, el cálculo del salario de los empleados de

una empresa, etc. En estos casos la solución que se diseñe para un solo grupo de datos se debe repetir

tantas veces como sea necesario (de acuerdo al número de estudiantes y de empleados para los

ejemplos anteriores).Los cálculos simples o la manipulación de pequeños conjuntos de datos se

pueden realizar fácilmente a mano, pero las tareas grandes o repetitivas son realizadas con mayor

eficacia por una computadora, ya que estas están especialmente preparadas para ello.

Para repetir varias veces un proceso determinado haremos uso de los ciclos repetitivos, a los cuales

se les conoce con el nombre de estructura repetitiva, estructura iterativa, lazo o bucle.

En C, al igual que en Java podemos encontrar tres tipos de ciclos:

Entrada Asegurada (while)

Ciclo Controlado Por Contador (for)

Hacer Mientras (do.. while)

Funcionamiento de Un Ciclo

Un ciclo, funciona de la siguiente manera: Evalúa una condición de resultar cierta, realiza una acción

o bloque de acciones, luego vuelve a evaluar la condición y si nuevamente resulta cierta, realiza la (s)

acción (es). Cuando la condición de cómo resultado falso, se sale del ciclo y continúa con la ejecución

normal del programa.

Acumulador:

Es una variable, que , como su nombre lo indica se encarga de acumular valores. Esto se vuelve muy

útil, por ejemplo, cuando queremos encontrar la suma de los números del 0 al 9, en el acumulador,

vamos guardando los valores de dichas cifras. Puede ser tanto real como entera. Su valor inicial, en

la mayoría de los casos es cero.

Contador:

Es una variable de tipo entero, que nos ayuda, en el programa a contabilizar el número de ejecuciones

de una misma acción, de un grupo de alumnos etc. Un acumulador tiene tres valores distintos:

Valor Inicial: es el valor con el cual iniciamos nuestro contador. Generalmente es cero. Esta

asignación puede hacerse cuando se declara la variable.

P á g i n a | 41

Programacion para Principiantes JAVA

Valor Final: después de la ejecución del ciclo, el valor del contador, será distinto a su valor inicial,

este puede ser mayo o menor que el mismo, todo depende si fue una cuenta creciente o decreciente.

Valor de Cambio: Es el valor Constante, en el cual se irá incrementando nuestro contador, este puede

ser positivo o negativo; es decir, si la cuanta se realiza de manera ascendente o descendente.

Bandera:

Las variables tipo bandera son aquellas que sólo admiten dos valores: cierto o falso, true o false,

hombre o mujer... etc

Ciclo de Entrada Asegurada

La sintaxis es la siguiente:

While (condición)

Acción;

Funciona de la siguiente manera: primero evalúa la condición, si da como resultado cierta realiza la

acción, luego vuelve a evaluar la condición, si su resultado es falso, se sale del ciclo y continúa con

la ejecución del programa. Hay que tener mucho cuidado, cuando trabajamos con ciclos, ya que

podemos caer en un ciclo infinito, es decir que nunca se sale de él. Por lo cual en las acciones debemos

siempre colocar algo que haga que se modifique el resultado de la condición, lo cual puede ser una

bandera, un contador o un acumulador.

Ejemplo: En una empresa, se desea se tienen datos correspondientes a los sueldos de 10 empleados,

de los cuales, se desea saber, quien goza del sueldo mayor, quien goza del sueldo menor y cuantos

poseen un sueldo mayor a $300.00

import javax.swing.*;

class UsaWhile{

public static void main (String args []){

String leer;

double sueldo, mayor=0, menor=10000;

int i=1, contador=0;

while(i<=10)

{

leer=JOptionPane.showInputDialog("Ingrese el sueldo del empleado: "+i);

sueldo=Double.parseDouble(leer);

while(sueldo<0)//si el sueldo es negativo

{

leer=JOptionPane.showInputDialog("ERROR, el sueldo no puede ser Negativo\nIngrese el sueldo

del empleado: "+i);

sueldo=Double.parseDouble(leer);

}

if(sueldo>300)

contador=contador+1;

if(sueldo>mayor)

mayor=sueldo;

P á g i n a | 42

Programación para Principiantes JAVA

if(sueldo<menor)

menor=sueldo;

i=i+1;

}

JOptionPane.showMessageDialog(null, "El sueldo mayor es de: "+mayor+"\nEl sueldo menor es:

"+menor+"\n"+contador+" Empleados tienen un sueldo mayor a $300");

}

}

Ciclo Controlado por contador.

En algunas ocasiones, sabemos a ciencia cierta el número de veces que se tiene que repetir una misma

acción o bloque de acciones. Y para ello es que nos sirve, esta estructura. Su sintaxis es la siguiente:

For (valor inicial; condición; incremento) accion;

Donde:

Valor inicial: es el valor con el cual inicializamos nuestra variable de control.

Condición: si la cumple, ejecuta la acción o acciones e incrementa o decrementa la variable

de control, sino la cumple la condición, se sale del ciclo.

Incremento; que puede ser positivo o negativo (decremento).

Ejemplo: Escriba un Applet que dibuje un rectángulo, unas líneas u óvalos en base a la entrada del

usuario.

import java.awt.*;

import javax.swing.*;

public class PruebaFor extends JApplet{

int opcion; //la opcion del usuario

public void init ()

{

String entrada;

//obtener la opcion del usuario

entrada=JOptionPane.showInputDialog("Escriba 1 para dibujer Lineas\nEscriba 2 para dibujar

rectangulos\nEscriba 3 pàra dibujar Ovalos");

opcion=Integer.parseInt(entrada);

}//fin del metodo init

//dibujar figuras en el fondo el Applet

public void paint (Graphics g)

{

super.paint(g);

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

{

switch(opcion)

{

case 1://dibujar lineas

g.drawLine(10,10,250,10+i*10);

break;

P á g i n a | 43

Programacion para Principiantes JAVA

case 2://dibujar rectangulos

g.drawRect(10+i*10,10+i*10,50+i*10, 50+i*10);

break;

case 3: //dibujar un Ovalo

g.drawOval(10+i*10, 10+i*10, 50+i*10, 50+i*10);

break;

default: //Valor Incorrecto

g.drawString("Se escribió un valor Incorrecto", 10,20+i*15);

}//fin del switch

}//fin del for

}//fin del paint

}//fin de la clase

Ciclo Do... while

Es te ciclo funciona de la siguiente manera, realiza la acción o conjunto de acciones, luego evalúa

una condición de resultar cierta vuelve a realizar la/s accion/es. Cuando sea falsa, se sale del ciclo.

Formato:

Do {

Sentencia;

} While(<expL>);

La diferencia fundamental, entre el ciclo while y do...while, es que en este ultimo, las sentencias se

realizarán por lo menos una vez, en cambio, con while, solo se cumplirán mientras se cumpla la

condición, lo cual puede ser nunca.

EjemplO: Programa que suma los valores de n1, mientras estos no sean mayores que 100

class fibo{

public static void main(String args[]){

int n1=0;

do{ n1++;

System.out.println(n1+" ");

}while(n1<100);

}

}

P á g i n a | 44

Programación para Principiantes JAVA

Uso de Variables

En todas las aplicaciones que realizamos, se necesitan entre muchas cosas, valores, datos; que

cambien a medida se ejecuta el programa. Por tal razón, un programa que solo muestre en pantalla

datos (como el ejemplo anterior), no es muy funcional que se diga. Para ello, es necesario hacer uso

de las variables que no son más que una unidad de almacenamiento, la cual tiene la propiedad de

cambiar a medida se ejecuta la aplicación (a diferencia de las constantes cuyo valor NO cambia).y

para eso ya tenemos que tener en mente que una variable es aquella que tiene la propiedad o capacidad

de cambiar de valor. Durante la ejecución del programa. Cuando se utiliza una variable estamos

asignando espacio en memoria (el tamaño viene dado por el tipo de dato, del cual se está declarando.

Ver tabla 2.2). En dicho espacio, se guardará el valor, que almacenará dicha variable.

Por tanto, una variable tiene tres propiedades básicas:

Una posición de memoria para almacenar valor el

El tipo de datos almacenado en la posición de memoria.

Y el identificar (nombre) asociado a ésa posición de memoria.

Luego de conocer las propiedades básicas vamos a conocer como es que se declara una variable en

Java, se prosigue de la siguiente forma:

Tipo identificado=valor;

Donde:

Tipo: Es el tipo de dato que almacenará, el cual puede ser cualquiera de los que se muestran

en la tabla 2.1.

Identificar: que hace referencia al nombre de la variable.

SABER: JAVA distingue entre mayúsculas y minúsculas, por tanto una variable declarada

como Nombre No es igual a otra variable invocada como nombre.

Valor: No es necesario, pero Java permite inicializar variables, por ejemplo, los contadores,

acumuladores, etc.;

Ejemplos:

int i;

float suma=0;

double saldo;

String Nombre

En la línea uno, estamos declarando una variable de tipo entero, identificada por i. en la línea dos,

tenemos una variable del tipo real, inicializada a cero, podemos asumir que se trata de un acumulador.

Luego, se puede hacer notar que saldo, está declarada como real de doble precisión, y finalmente en

la línea 4 se encuentre Nombre que es una variable de tipo String, es decir; una cadena de caracteres,

ya que Java soporta este tipo de datos.

Ejemplo: Programa que Muestra el nombre, edad y sueldo de una persona.

class DatosPersonales {

public static void main (String args[]) {

String Nombre="Manuel Ortez";

P á g i n a | 45

Programacion para Principiantes JAVA

int edad=20;

double sueldo=500.00;

System.out.println("Nombre del empleado: "+Nombre);

System.out.println("Edad: ");//Impresion de la leyenda edad

System.out.println(edad);

System.out.println("Sueldo: "+sueldo);

}//fin del main

}//fin de la clase

Ahora vamos a explicar el ejemplo anterior:

Como puede notarse, la variable Nombre, es una cadena de caracteres, la cual está inicializada, y

todos los valores de una cadena se escriben entre comillas dobles. Además note que, en el método

System.out.printl, podemos hacer varias combinaciones al momento de mandar a la impresión. Para

el caso, si una (o más cadenas) se van a mandar a impresión acompañadas de una (o más variables),

estos argumentos se unen, mediante el operador ‘+’. Sin embargo, esto no es necesario cuando se

trata de la impresión de una sola variable:

System.out.println (edad);

Ejemplo: Programa que calcula el area y el perímetro de un círculo

class Circulo {}

public static void main (String args[]) {

double radio=2.3;

double perimetro;

double area;

area=Math.PI*radio*radio;

perimetro=2*Math.PI*radio;

System.out.println("El area es: "+area+" Y el perímetro es: "+perimetro);

}

}

Ahora vamos a explicar el Ejemplo Anterior.

Me parece que, en lo único que debemos poner atención es en dos cosas.

La primera, es que Math.PI es una constante, (3.14159….), la cual, está dentro del paquete de

java.lang; el cual, como ya lo hemos dicho, está incluido, por defecto, en todos nuestros programas

de manera automática; además que, note que la única impresión que se hace, enlazamos los

parámetros con el operador ‘+’.

System.out.println ("El area es: "+area+" Y el perímetro es: "+perimetro);

THIS Y SUPER

Al acceder a variables de instancia de una clase, la palabra clave this hace referencia a los miembros

de la propia clase. Volviendo al ejemplo de MiClase, se puede añadir otro constructor de la forma

siguiente:

public class MiClase {

P á g i n a | 46

Programación para Principiantes JAVA

int i;

public MiClase() {

i = 10;

}

// Este constructor establece el valor de i

public MiClase( int valor ) {

this.i = valor; // i = valor

}

public void Suma_a_i( int j ) {

i = i + j;

}

}

Aquí this.i se refiere al entero i en la clase MiClase.

Si se necesita llamar al método padre dentro de una clase que ha reemplazado ese método, se puede

hacer referencia al método padre con la palabra clave super:

import MiClase;

public class MiNuevaClase extends MiClase {

public void Suma_a_i( int j ) {

i = i + ( j/2 );

super.Suma_a_i( j );

}

}

En el siguiente código, el constructor establecerá el valor de i a 10, después lo cambiará a 15 y

finalmente el método Suma_a_i () de la clase padre (MiClase) lo dejará en 25:

MiNuevaClase mnc; mnc = new MiNuevaClase (); mnc.Suma_a_i (10);

METODOS NATIVOS

Java proporciona un mecanismo para la llamada a funciones C y C++ desde nuestro código

fuente Java. Para definir métodos como funciones C o C++ se utiliza la palabra clave

native.

public class Fecha {

int ahora;

public Fecha() {

ahora = time();

}

private native int time();

static {

System.loadLibrary( "time" );

}

}

Una vez escrito el código Java, se necesitan ejecutar los pasos siguientes para poder

integrar el código C o C++:

P á g i n a | 47

Programacion para Principiantes JAVA

Utilizar javah para crear un fichero de cabecera (.h)

Utilizar javah para crear un fichero de stubs , es decir, que contiene la declaración

de las funciones

Escribir el código del método nativo en C o C++, es decir, rellenar el código de la

función, completando el trabajo de javah al crear el fichero de stubs

Compilar el fichero de stubs y el fichero .c en una librería de carga dinámica ( DLL

en Windows '95 o libXX.so en Unix)

Ejecutar la aplicación con el appletviewer

Más adelante trataremos en profundidad los métodos nativos, porque añaden una gran

potencia a Java, al permitirle integrar a través de librería dinámica cualquier algoritmo

desarrollado en C o C++, lo cual, entre otras cosas, se utiliza como método de protección

contra la descompilación completa del código Java.

VARIABLES Y METODOS ESTATICOS

En un momento determinado se puede querer crear una clase en la que el valor de una variable de

instancia sea el mismo (y de hecho sea la misma variable) para todos los objetos instanciados a partir

de esa clase. Es decir, que exista una única copia de la variable de instancia. Se usará para ello la

palabra clave static.

class Documento extends Pagina {

static int version = 10;

}

El valor de la variable version será el mismo para cualquier objeto instanciado de la clase Documento.

Siempre que un objeto instanciado de Documento cambie la variable version, ésta cambiará para

todos los objetos. De la misma forma se puede declarar un método como estático, lo que evita que el

método pueda acceder a las variables de instancia no estáticas:

class Documento extends Pagina {

static int version = 10;

int numero_de_capitulos;

static void annade_un_capitulo() {

numero_de_capitulos++; // esto no funciona

}

static void modifica_version( int i ) {

version++; // esto si funciona

}

}

La modificación de la variable numero_de_capitulos no funciona porque se está violando una de las

reglas de acceso al intentar acceder desde un método estático a una variable no estática.

Todas las clases que se derivan, cuando se declaran estáticas, comparten la misma página de variables;

es decir, todos los objetos que se generen comparten la misma zona de memoria. Las funciones

estáticas se usan para acceder solamente a variables estáticas.

P á g i n a | 48

Programación para Principiantes JAVA

class UnaClase {

int var;

UnaClase()

{

var = 5;

}

UnaFuncion()

{

var += 5;

}

}

En el código anterior, si se llama a la función UnaFuncion a través de un puntero a función, no se

podría acceder a var, porque al utilizar un puntero a función no se pasa implícitamente el puntero al

propio objeto (this). Sin embargo, sí se podría acceder a var si fuese estática, porque siempre estaría

en la misma posición de memoria para todos los objetos que se creasen de UnaClase.

Nombre del Método Descripción

StringBuffer() Constructores del Objeto.

capacity() Devuelve el espacio disponible del Objeto StringBuffer

charAt(int) Devuelve el carácter que ocupa la posición especificada.

getChars(int, int, char[], int) Copia los caracteres indicados en la posición indicada de un array de

caracteres

insert(int) Inserta un String (o cualquier otro tipo de dato primitive), en la

posición que se especifica.

length() Devuelve la longitud de la cadena.

reverse() Devuelve una cadena invertida.

setCharAt(int, char) Cambia el carácter char, el la posición int.

toString() Convierte en Objeto del tipo String.

Tabla 4.2

P á g i n a | 49

Programacion para Principiantes JAVA

Operadores, Comentarios y Literales.

Tipos de datos No orientados a Objetos (estos datos son muy parecidos a los de C)

En todas las aplicaciones, No solo en Java, sino en cualquier otro lenguaje de programación, nos

ayudan a enriquecer nuestro código y hacerlo más robusto y funcional.

Operadores

Los operadores de Java son muy parecidos en estilo y funcionamiento a los de C. En la siguiente tabla

aparecen los operadores que se utilizan en Java, por orden de precedencia:

Un Operador, es un símbolo que le indica al compilador que realice una determinada operación, ya

sea lógica. Como consecuencia, nacen los diferentes tipos de operadores que existen. En Java,

podemos encontrar los siguientes tipos:

Operadores Aritméticos

Operadores a nivel de Bit

Operadores Relacionales

Operadores Lógicos

Operadores Aritméticos

Estos operadores se utilizan para realizar diferentes operaciones aritméticas, por tal razón se utilizan

en variables de tipo numéricas.

. [] ()

++ --

! ~ Instanceof

* / %

+ -

<< >> >>>

< > <= >= == !=

& ^ |

&& ||

? :

= op= (*= /= %= += -= etc.) ,

String nombre = "nombre" + "Apellido";

Aritméticos DESCRIPCIÓN

+ Suma

- Resta

* Multiplica

/ Divide

% Devuelve el resto de una división

++ Incrementa en 1

P á g i n a | 50

Programación para Principiantes JAVA

-- Decremento en 1

Tabla 2.2

Ejemplo: Programa que usa varios tipo de instrucciones

class Operadores {

public static void main (String args[]){

int x=10;

int y=12;

int resultado;

resultado=x+y;

System.out.println("El resultado de la suma es: "+resultado);

resultado=y-x;

System.out.println("El resultado de la resta es: "+resultado);

resultado=x/y;

System.out.println("El resultado de la división es: "+resultado);

x++;

y++;

System.out.println("Ahora x es: "+x+"y Y es: "+y);

}

}

Operadores Lógicos

Operador Descripción

&& Y lógico. Condicion1 && Condicion2

|| O lógico. Condicion1 || Condicion2

! Negación. !(Condicion1)

Operadores Relacionales

Operador Descripción

== Es igual a

!= No es igual a (Distinto)

> Mayor que

< Menor que

>= Mayor o Igual a

P á g i n a | 51

Programacion para Principiantes JAVA

<= Menor o igual que

Comentarios

Antes que nada vamos a definir lo que es un comentario el cual es un mensaje cualquiera, que se

escribe entro del código; pero que no es interpretado por el compilador, y que ayuda, al programador

para futuros mantenimientos y para comprender, tiempo después, la secuencia de ejecución del

programa. Java, posee tres tipos de comentarios:

Comienza con /* y termina con */, en él podemos escribir una línea o un párrafo completo. Ejemplo:

/*Ejemplo de un comentario */

/* También podemos escribir

Nuestros comentarios

En varias líneas*/

Tradicional:

De una sola línea:

Comienzan con una doble barra (//), y se extiende hasta el final de la línea. Ejemplo:

//Este comentario es válido sólo para una línea

A su vez tenemos que conocer que en Java hay tres tipos de comentarios:

// Comentarios para una sola línea

/* Comentarios de una o más líneas

*/

/** Comentario de documentación, de una o más líneas

*/

Los dos primeros tipos de comentarios son los que todo programador conoce y se utilizan del mismo

modo. Los comentarios de documentación, colocados inmediatamente antes de una declaración (de

variable o función), indican que ese comentario ha de ser colocado en la documentación que se genera

automáticamente cuando se utiliza la herramienta de Java, javadoc. Dichos comentarios sirven como

descripción del elemento declarado permitiendo generar una documentación de nuestras clases escrita

al mismo tiempo que se genera el código.

En este tipo de comentario para documentación, se permite la introducción de algunos tokens o

palabras clave, que harán que la información que les sigue aparezca de forma diferente al resto en la

documentación.

Comentario de Documentación

Comienza con /** y termina con */ son comentario especiales que javadoc utiliza para generar,

documentación acerca del programa.

Ejemplo:

/** Programa Visor 3.11

San Salvador, El Salvador

P á g i n a | 52

Programación para Principiantes JAVA

Por ejemplo: a t u???? [????] Es un número

Diciembre de 2006*/

OJO: JAVA, por defecto, hace que todas las literales de tipo Flotante, sean doublé. Para

especificarla como flotante, se debe agregar una f o una F al final del valor. Ejemplo: 12.85F,

8.75F

Luego de conocer lo que son los Literales de tipo cadena y cuales son, se especifican entre comillas

dobles. Así: "Ejemplo de una cadena"; Además, un literal de tipo String, puede contener una o más

secuencias de escape. Por ejemplo, la secuencia de escape ‘\n’, se utiliza para cambiar de línea. Así:

"Manuel\nOrtez";

Si mandamos a imprimir esa literal, veremos el siguiente resultado:

Ejemplo: Note, las secuencias de escape que, también se pueden utilizar en éste método

Import javax.swing.*;

class Mensaje1 {

public static void main (String args []) {

JOptionPane.showMessageDialog (null,"Manual de Java\nUna forma Facil de Aprender a

Programar\n\n\t\tDiciembre de 2006");

JOptionPane.showMessageDialog (null, "Creado por Manuel Ortez");

}

}

Leer Datos: Para leer los datos, usamos el método ShowInputDialog, de la forma siguiente:

Var=JOptionPane.showInputDialog ("Mensaje");

Donde:

Var: es el nombre de la variable que hace referencia al valor leído.

Mensaje: Es el mensaje que aparecerá, en la caja de diálogo.

Pero debemos tener presente que, éste método devuelve un tipo de dato String, por tal razón

cuando leamos un flotante, double, int, etc, debemos realizar la conversión.

Ejemplo: Se desea Crear una Mini-calculadora, que permita, sumar, restar y multiplicar dos números

ingresados por el usuario.

import javax.swing.*;

class MiniCalcu{

public static void main (String args[]){

P á g i n a | 53

Programacion para Principiantes JAVA

double n1, n2, resultado;//Estos son los numeros

String leer;//variable auxiliar con la cual leeremos los datos

leer=JOptionPane.showInputDialog("Escriba el primer Número");

//Esta es la forma para hacer el cambio de cadena a doble

n1=Double.parseDouble(leer);

leer=JOptionPane.showInputDialog("Escriba el primer Número");

n2=Double.parseDouble(leer);

resultado=n1+n2;

JOptionPane.showMessageDialog(null, "El resultado de la suma es: "+resultado);

resultado=n1-n2;

JOptionPane.showMessageDialog(null, "El resultado de la resta es: "+resultado);

resultado=n1*n2;

JOptionPane.showMessageDialog(null, "El resultado de la multiplicación es: "+resultado);

resultado=n1/n2;

JOptionPane.showMessageDialog(null, "El resultado de la división es: "+resultado);

}

}

Ahora vamos a explicar el Ejemplo Anterior:

El lector, debe notar, la forma en que debe hacer la conversión de un carácter a un valor diferente.

Para el caso, la línea 8 y 13, después de haber leído los valores correspondiente, hacemos el cambio

así:

N1=Double.parseDouble (leer);

Double, es la clase que contiene al tipo de dato double, luego se escribe el método parse, y le pasamos

como argumento, la variable leer, que contiene el número (en cadena de caracteres), que deseamos

convertir a double.

Si queremos convertir a entero:

N1=Integer.parseInt(leer);

Si lo que queremos es convertirlo a float:

N1=Float.parseFloat(leer);

Sobrecarga

Cuando en una clase, se definen un mismo método, con diferente número de parámetros, o bien con

el mismo número de parámetros pero diferenciándose en la definición, en la cual, al menos un

parámetro sea de diferente tipo, cuando esto sucede, se dice que el método está sobrecargado.

Ejemplo: Cree una aplicación en Java, que imprima un número imaginario. Nota, los números

imaginarios, poseen una parte real y otra imaginaria, acompañada por la constante i.

class Imaginario {

private int real, imag;

public Imaginario()

{

real=0;

P á g i n a | 54

Programación para Principiantes JAVA

imag=0;

}

public Imaginario(int x, int y)

{

real=x;

imag=y;

}

public void Mostrar()

{

System.out.println("El Numero Imaginario es: "+real+" + "+imag+"i");

}

}

EXCEPCIONES

MANEJO DE EXCEPCIONES

Vamos a mostrar cómo se utilizan las excepciones, reconvirtiendo nuestro applets de saludo

a partir de la versión iterativa de HolaIte.java: Antes que nada vamos a explicar lo que es una

excepción es una condición anormal que surge en una secuencia de código durante la ejecución. La

gestión de excepciones lleva a la gestión de errores en tiempo de ejecución. Cuando surge una

condición excepcional se crea un objeto Exception. El trabajo con excepciones se realiza mediante

las siguientes palabras clave:

import java.awt.*;

import java.applet.Applet;

public class HolaIte extends Applet {

private int i = 0;

private String Saludos[] = {

"Hola Mundo!",

"HOLA Mundo!",

"HOLA MUNDO!!"

};

public void paint( Graphics g ) {

g.drawString( Saludos[i],25,25 );

i++;

}

}

Vamos a reescribir el método paint () de nuestra versión iterativa del saludo:

public void paint( Graphics g ) {

try {

g.drawString( Saludos[i],25,25 );

P á g i n a | 55

Programacion para Principiantes JAVA

} catch( ArrayIndexOutOfBoundsException e ) {

g.drawString( "Saludos desbordado",25,25 );

} catch( Exception e ) {

// Cualquier otra excepción

System.out.println( e.toString() );

} finally {

System.out.println( "Esto se imprime siempre!" );

}

i++;

}

La palabra clave finally define un bloque de código que se quiere que sea ejecutado siempre,

de acuerdo a si se capturó la excepción o no. En el ejemplo anterior, la salida en la consola,

con i=4 sería: Normalmente, un programa termina con un mensaje de error cuando se lanza una

excepción. Sin embargo, Java tiene mecanismos para excepciones que permiten ver qué excepción se

ha producido e intentar recuperarse de ella.

Normalmente, un programa termina con un mensaje de error cuando se lanza una excepción. Sin

embargo, Java tiene mecanismos para excepciones que permiten ver qué excepción se ha producido

e intentar recuperarse de ella.

GENERAR EXCEPCIONES

Cuando se produce un error se debería generar, o lanzar, una excepción. Para que un método en Java,

pueda lanzar excepciones, hay que indicarlo expresamente.

void MetodoAsesino() throws NullPointerException,CaidaException

Se pueden definir excepciones propias, no hay por qué limitarse a las predefinidas; bastará con

extender la clase Exception y proporcionar la funcionalidad extra que requiera el tratamiento de esa

excepción. También pueden producirse excepciones no de forma explícita como en el caso anterior,

sino de forma implícita cuando se realiza alguna acción ilegal o no válida. Las excepciones, pues,

pueden originarse de dos modos: el programa hace algo ilegal (caso normal), o el programa

explícitamente genera una excepción ejecutando la sentencia throw (caso menos normal). La

sentencia throw tiene la siguiente forma:

throw ObtejoExcepction;

El objeto ObjetoException es un objeto de una clase que extiende la clase Exception. El

siguiente código de ejemplo origina una excepción de división por cero:

class melon {

public static void main( String[] a ) {

int i=0, j=0, k;

k = i/j; // Origina un error de division-by-zero

}

}

Si compilamos y ejecutamos esta aplicación Java, obtendremos la siguiente salida por

pantalla:

P á g i n a | 56

Programación para Principiantes JAVA

> javac melon.java

> java melon

java.lang.ArithmeticException: / by zero

at melon.main(melon.java:5)

Las excepciones predefinidas, como ArithmeticException, se conocen como excepciones runtime.

Actualmente, como todas las excepciones son eventos runtime, sería mejor llamarlas excepciones

irrecuperables. Esto contrasta con las excepciones que generamos explícitamente, que suelen ser

mucho menos severas y en la mayoría de los casos podemos recuperarnos de ellas. Por ejemplo, si un

fichero no puede abrirse, preguntamos al usuario que nos indique otro fichero; o si una estructura de

datos se encuentra completa, podremos sobreescribir algún elemento que ya no se necesite.

EXCEPCIONES PREDEFINIDAS

Las excepciones predefinidas y su jerarquía de clases es la que se muestra en la figura:

Los nombres de las excepciones indican la condición de error que representan. Las siguientes son

las excepciones predefinidas más frecuentes que se pueden encontrar:

ArithmeticException

Las excepciones aritméticas son típicamente el resultado de una división por 0:

int i = 12 / 0;

NullPointerException

Se produce cuando se intenta acceder a una variable o método antes de ser definido:

class Hola extends Applet {

Image img;

paint( Graphics g ) {

g.drawImage( img,25,25,this );

}

}

P á g i n a | 57

Programacion para Principiantes JAVA

IncompatibleClassChangeException

El intento de cambiar una clase afectada por referencias en otros objetos, específicamente

cuando esos objetos todavía no han sido recompilados.

ClassCastException

El intento de convertir un objeto a otra clase que no es válida.

y = (Prueba) x; // donde

X no es de tipo Prueba

NegativeArraySizeException

Puede ocurrir si hay un error aritmético al intentar cambiar el tamaño de un array.

OutOfMemoryException

¡No debería producirse nunca! El intento de crear un objeto con el operador new ha fallado

por falta de memoria. Y siempre tendría que haber memoria suficiente porque el garbage

collector se encarga de proporcionarla al ir liberando objetos que no se usan y devolviendo

memoria al sistema.

NoClassDefFoundException

Se referenció una clase que el sistema es incapaz de encontrar.

ArrayIndexOutOfBoundsException

Es la excepción que más frecuentemente se produce. Se genera al intentar acceder a un

elemento de un array más allá de los límites definidos inicialmente para ese array.

UnsatisfiedLinkException

Se hizo el intento de acceder a un método nativo que no existe. Aquí no existe un método

a.kk

class A {

native void kk();

}

InternalException

Este error se reserva para eventos que no deberían ocurrir. Por definición, el usuario nunca

debería ver este error y esta excepción no debería lanzarse.

CREAR EXCEPCIONES

P á g i n a | 58

Programación para Principiantes JAVA

También podemos lanzar nuestras propias excepciones, extendiendo la clase

System.exception. Por ejemplo, consideremos un programa cliente/servidor. El código

cliente se intenta conectar al servidor, y durante 5 segundos se espera a que conteste el

servidor. Si el servidor no responde, el servidor lanzaría la excepción de time-out:

class ServerTimeOutException extends Exception {}

public void conectame( String nombreServidor ) throws Exception {

int exito;

int puerto = 80;

exito = open( nombreServidor,puerto );

if( exito == -1 )

throw ServerTimeOutException;

}

Si se quieren capturar las propias excepciones, se deberá utilizar la sentencia try:

public void encuentraServidor() {

...

try {

conectame( servidorDefecto );

catch( ServerTimeOutException e ) {

g.drawString(

"Time-out del Servidor, intentando alternativa",

5,5 );

conectame( servidorAlterno );

}

...

}

Cualquier método que lance una excepción también debe capturarla, o declararla como

parte de la interface del método. Cabe preguntarse entonces, el porqué de lanzar una

excepción si hay que capturarla en el mismo método. La respuesta es que las excepciones

no simplifican el trabajo del control de errores. Tienen la ventaja de que se puede tener muy

localizado el control de errores y no tenemos que controlar millones de valores de retorno,

pero no van más allá.

CAPTURAR EXCEPCIONES

Las excepciones lanzadas por un método que pueda hacerlo deben recoger en bloque

try/catch o try/finally.

int valor;

try {

for( x=0,valor = 100; x < 100; x ++ )

valor /= x;

}

catch( ArithmeticException e ) {

System.out.println( "Matemáticas locas!" );

}

catch( Exception e ) {

P á g i n a | 59

Programacion para Principiantes JAVA

System.out.println( "Se ha producido un error" );

}

Try: Es el bloque de código donde se prevé que se genere una excepción. Es como si dijésemos

"intenta estas sentencias y mira a ver si se produce una excepción". El bloque try tiene que ir seguido,

al menos, por una cláusula catch o una cláusula finally

Catch: Es el código que se ejecuta cuando se produce la excepción. Es como si dijésemos "controlo

cualquier excepción que coincida con mi argumento". En este bloque tendremos que asegurarnos de

colocar código que no genere excepciones. Se pueden colocar sentencias catch sucesivas, cada una

controlando una excepción diferente. No debería intentarse capturar todas las excepciones con una

sola cláusula, como esta: catch( Excepcion e ) { ...

Esto representaría un uso demasiado general, podrían llegar muchas más excepciones de las

esperadas. En este caso es mejor dejar que la excepción se propague hacia arriba y dar un mensaje de

error al usuario.

Se pueden controlar grupos de excepciones, es decir, que se pueden controlar, a través del

argumento, excepciones semejantes. Por ejemplo:

class Limites extends Exception {}

class demasiadoCalor extends Limites {}

class demasiadoFrio extends Limites {}

class demasiadoRapido extends Limites {}

class demasiadoCansado extends Limites {}

.

.

.

try {

if( temp > 40 )

throw( new demasiadoCalor() );

if( dormir < 8 )

throw( new demasiado Cansado() );

} catch( Limites lim ) {

if( lim instanceof demasiadoCalor )

{

System.out.println( "Capturada excesivo calor!" );

return;

}

if( lim instanceof demasiadoCansado )

{

System.out.println( "Capturada excesivo cansancio!" );

return;

}

} finally

System.out.println( "En la clausula finally" );

La cláusula catch comprueba los argumentos en el mismo orden en que aparezcan en el

programa. Si hay alguno que coincida, se ejecuta el bloque. El operador instanceof se

utiliza para identificar exactamente cual ha sido la identidad de la excepción.

Finally: Es el bloque de código que se ejecuta siempre, haya o no excepción. Hay una cierta

controversia entre su utilidad, pero, por ejemplo, podría servir para hacer un log o un

P á g i n a | 60

Programación para Principiantes JAVA

seguimiento de lo que está pasando, porque como se ejecuta siempre puede dejarnos grabado

si se producen excepciones y nos hemos recuperado de ellas o no. Este bloque finally puede

ser útil cuando no hay ninguna excepción. Es un trozo de código que se ejecuta

independientemente de lo que se haga en el bloque try.

Cuando vamos a tratar una excepción, se nos plantea el problema de qué acciones vamos a

tomar. En la mayoría de los casos, bastará con presentar una indicación de error al usuario y

un mensaje avisándolo de que se ha producido un error y que decida si quiere o no

continuar con la ejecución del programa.

Por ejemplo, podríamos disponer de un diálogo como el que se presenta en el código

siguiente:

public class DialogoError extends Dialog {

DialogoError( Frame padre ) {

super( padre,true );

setLayout( new BorderLayout() );

// Presentamos un panel con continuar o salir

Panel p = new Panel();

p.add( new Button( "¿Continuar?" ) );

p.add( new Button( "Salir" ) );

add( "Center",new Label(

"Se ha producido un error. ¿Continuar?" ) )

add( "South",p );

}

public boolean action( Event evt,Object obj ) {

if( "Salir".equals( obj ) )

{

dispose();

System.exit( 1 );

}

return false;

}

}

Y la invocación, desde algún lugar en que se suponga que se generarán errores, podría ser

como sigue:

try {

// Código peligroso

}

catch( AlgunaExcepcion e ) {

VentanaError = new DialogoError( this );

VentanaError.show();

}

PROPAGACION DE EXCEPCIONES

La cláusula catch comprueba los argumentos en el mismo orden en que aparezcan en el programa. Si

hay alguno que coincida, se ejecuta el bloque y sigue el flujo de control por el bloque finally (si lo

P á g i n a | 61

Programacion para Principiantes JAVA

hay) y concluye el control de la excepción. Si ninguna de las cláusulas catch coincide con la

excepción que se ha producido, entonces se ejecutará el código de la cláusula finally (en caso de que

la haya). Lo que ocurre en este caso, es exactamente lo mismo que si la sentencia que lanza la

excepción no se encontrase encerrada en el bloque try. El flujo de control abandona este método y

retorna prematuramente al método que lo llamó. Si la llamada estaba dentro del ámbito de una

sentencia try, entonces se vuelve a intentar el control de la excepción, y así continuamente.

Veamos lo que sucede cuando una excepción no es tratada en la rutina en donde se produce. El sistema

Java busca un bloque try...Catch más allá de la llamada, pero dentro del método que lo trajo aquí. Si

la excepción se propaga de todas formas hasta lo alto de la pila de llamadas sin encontrar un

controlador específico para la excepción, entonces la ejecución se detendrá dando un mensaje. Es

decir, podemos suponer que Java nos está proporcionando un bloque catch por defecto, que imprime

un mensaje de error y sale.

No hay ninguna sobrecarga en el sistema por incorporar sentencias try al código. La

sobrecarga se produce cuando se genera la excepción.

Hemos dicho ya que un método debe capturar las excepciones que genera, o en todo caso, declararlas

como parte de su llamada, indicando a todo el mundo que es capaz de generar excepciones. Esto debe

ser así para que cualquiera que escriba una llamada a ese método esté avisado de que le puede llegar

una excepción, en lugar del valor de retorno normal. Esto permite al programador que llama a ese

método, elegir entre controlar la excepción o propagarla hacia arriba en la pila de llamadas. La

siguiente línea de código muestra la forma general en que un método declara excepciones que se

pueden propagar fuera de él:

tipo_de_retorno( parametros ) throws e1,e2,e3 { }

Los nombres e1,e2,... deben ser nombres de excepciones, es decir, cualquier tipo que sea

asignable al tipo predefinido Throwable . Observar que, como en la llamada al método se

especifica el tipo de retorno, se está especificando el tipo de excepción que puede generar

(en lugar de un objeto exception).

He aquí un ejemplo, tomado del sistema Java de entrada/salida:

byte readByte() throws IOException;

short readShort() throws IOException;

char readChar() throws IOException;

void writeByte( int v ) throws IOException;

void writeShort( int v ) throws IOException;

void writeChar( int v ) throws IOException;

Lo más interesante aquí es que la rutina que lee un char, puede devolver un char; no el

entero que se requiere en C. C necesita que se devuelva un int, para poder pasar cualquier

valor a un char, y además un valor extra (-1) para indicar que se ha alcanzado el final del

fichero. Algunas de las rutinas Java lanzan una excepción cuando se alcanza el fin del

fichero.

P á g i n a | 62

Programación para Principiantes JAVA

En el siguiente diagrama se muestra gráficamente cómo se propaga la excepción que se

genera en el código, a través de la pila de llamadas durante la ejecución del código:

Cuando se crea una nueva excepción, derivando de una clase Exception ya existente, se

puede cambiar el mensaje que lleva asociado. La cadena de texto puede ser recuperada a

través de un método. Normalmente, el texto del mensaje proporcionará información para

resolver el problema o sugerirá una acción alternativa. Por ejemplo:

class SinGasolina extends Exception {

SinGasolina( String s ) { // constructor

super( s );

}

....

// Cuando se use, aparecerá algo como esto

try {

if( j < 1 )

Throw new SinGasolina (“Usando deposito de reserva" );

} catch (SinGasolina e) {

System.out.println (o.getMessage ());

}

Esto, en tiempo de ejecución originaría la siguiente salida por pantalla:

> Usando depósito de reserva

Otro método que es heredado de la superclase Throwable es printStackTrace (). Invocando

a este método sobre una excepción se volcará a pantalla todas las llamadas hasta el

momento en donde se generó la excepción (no donde se maneje la excepción). Por ejemplo:

// Capturando una excepción en un método

class testcap {

static int slice0[] = { 0,1,2,3,4 };

public static void main( String a[] ) {

try {

P á g i n a | 63

Programacion para Principiantes JAVA

uno();

} catch( Exception e ) {

System.out.println( "Captura de la excepcion en main()" );

e.printStackTrace();

}

}

static void uno() {

try {

slice0[-1] = 4;

} catch( NullPointerException e ) {

System.out.println( "Captura una excepcion diferente" );

}

}

}

Cuando se ejecute ese código, en pantalla observaremos la siguiente salida:

> Captura de la excepcion en main()

> java.lang.ArrayIndexOutOfBoundsException: -1

at testcap.uno(test5p.java:19)

at testcap.main(test5p.java:9)

Con todo el manejo de excepciones podemos concluir que proporciona un método más

seguro para el control de errores, además de representar una excelente herramienta para

organizar en sitios concretos todo el manejo de los errores y, además, que podemos

proporcionar mensajes de error más decentes al usuario indicando qué es lo que ha fallado

y por qué, e incluso podemos, a veces, recuperarnos de los errores. La degradación que se

produce en la ejecución de programas con manejo de excepciones está ampliamente

compensada por las ventajas que representa en cuanto a seguridad de funcionamiento de

esos mismos programas.

Métodos y Constructores Un Constructor es una función, método, etc, de las clases, la cual es llamada automáticamente cuando

se crea un objeto de esa clase. Por ser métodos, los constructores también aceptan parámetros. Cuando

en una clase no especificamos ningún tipo de constructor, el compilador añade uno público por

omisión sin parámetros, el cual NO hace nada. Cuando se declara una clase en Java, se pueden

declarar uno o más constructores opcionales que realizan la inicialización cuando se instancia (se crea

una ocurrencia) un objeto de dicha clase.

Utilizando el código de ejemplo anterior, cuando se crea una nueva instancia de MiClase, se crean

(instancian) todos los métodos y variables, y se llama al constructor de la clase:

MiClase mc;

mc = new MiClase();

La palabra clave new se usa para crear una instancia de la clase. Antes de ser instanciada con new no

consume memoria, simplemente es una declaración de tipo. Después de ser instanciado un nuevo

objeto mc, el valor de i en el objeto mc será igual a 10. Se puede referenciar la variable (de instancia)

i con el nombre del objeto:

P á g i n a | 64

Programación para Principiantes JAVA

mc.i++; // incrementa la instancia de i de mc

Al tener mc todas las variables y métodos de MiClase, se puede usar la primera sintaxis

para llamar al método Suma_a_i() utilizando el nuevo nombre de clase mc:

mc.Suma_a_i( 10 );

Y ahora la variable mc.i vale 21.

Características de los Constructores

Un constructor, tiene el mismo nombre de la clase a la cual pertenece.

No puede ser Heredado.

No retorna ningún valor (Ni void), por lo cual no debe especificarse ningún tipo de dato.

Debe declararse como public, sólo en casos realmente extraordinarios será de otro tipo.

Supongamos una clase llamada Datos

public class Datos

{

//declaracion de atributos

public Datos();//constructor sin parametros

public Datos(int Edad)

{//Constructor con parámetros

EdadM=Edad;

}

}

Ejemplo: Se Desea crear un objeto del tipo Coordenadas, que indique, la posición de un punto en el

plano cartesiano, y permita calcular la distancia existente con otro punto, además del punto medio

entre ellos.

/*Archivo Coordenadas.java*/

public class Coordenadas {

private int x,y;//Atributos

public Coordenadas (int x1 , int y1)//constructor

{

//asignamos esos valores

x=x1;

y=y1;

}

public double Distancia (int x1, int y1)

{

//este método recibe como parametros

//las coordenadas del segundo punto

double D;

D=Math.sqrt((x-x1)*(x-x1)+(y-y1)*(y-y1));

return D;//Retornamops el valor de la distancia

P á g i n a | 65

Programacion para Principiantes JAVA

}

public void Pmedio(int x1, int y1)

{

double p1, p2;

p1=(x+x1)/2;

p2=(y+y1)/2;

System.out.println("El puntomedio es: "+p1+","+p2);

}

}

Ahora vamos a explicar el Ejemplo Anterior:

Un método, si va a devolver algún valor, éste debe especificarse cuando se hace la definición del

mismo, para el caso, el método Distancia, devuelve el valor de la distancia, es por ello que lo

especificamos como public double. Además que, cuando realizamos la llamada de ese método, es en

ese preciso lugar que aparecerá el valor que devuelve. Por otra parte, los atributos, son de acceso

privado, lo cual implica que, sólo podemos acceder a ellos, en la clase Coordenadas.

ARRAYS

Los arreglos en Java son dinámicos, pero no extensibles, lo cual significa que deben ser creados con

el tamaño que tendrán hasta el final de su vida. Algunas de sus características más importantes de

los arrays son las siguientes:

Los arrays se crean con el operador new seguido del tipo y número de elementos.

Se puede acceder al número de elementos de un array con la variable miembro implícita

length (por ejemplo, vect.length).

Se accede a los elementos de un array con los corchetes [] y un índice que varía de length-

Se pueden crear arrays de objetos de cualquier tipo. En principio un array de objetos es un

array de referencias que hay que completar llamando al operador new.

Los elementos de un array se inicializan al valor por defecto del tipo correspondiente (cero

para valores numéricos, el carácter nulo para char, false para boolean, null para Strings y

para referencias).

Como todos los objetos, los arrays se pasan como argumentos a los métodos por

referencia.

Se pueden crear arrays anónimos (por ejemplo, crear un nuevo array como argumento

actual en la llamada a un método).

Luego podemos mostrar cómo se declara un array de la siguiente forma:

<Tipo> [] <nombre>;

Se pueden declarar en Java arrays de cualquier tipo:

char s[];

P á g i n a | 66

Programación para Principiantes JAVA

int iArray[];

Incluso se pueden construir arrays de arrays:

int tabla[][] = new int[4][5];

Los límites de los arrays se comprueban en tiempo de ejecución para evitar

desbordamientos y la corrupción de memoria. En Java un array es realmente un objeto,

porque tiene redefinido el operador []. Tiene una función miembro: length. Se puede

utilizar este método para conocer la longitud de cualquier array.

int a[][] = new int[10][3];

a.length; /* 10 */

a[0].length; /* 3 */

Para crear un array en Java hay dos métodos básicos. Crear un array vacío:

int lista[] = new int[50];

O se puede crear ya el array con sus valores iniciales:

String nombres [] = {

"Juan","Pepe","Pedro","Maria"

};

Esto que es equivalente a:

String nombres [];

Nombres = new String [4];

Nombres [0] = new String (“Juan”);

nombres [1] = new String( "Pepe" );

nombres[2] = new String( "Pedro" );

nombres[3] = new String( "Maria" );

No se pueden crear arrays estáticos en tiempo de compilación:

int lista[50]; // generará un error en tiempo de compilación

Tampoco se puede rellenar un array sin declarar el tamaño con el operador new:

int lista[];

for( int i=0; i < 9; i++ )

lista[i] = i;

Es decir, todos los arrays en Java son estáticos. Para convertir un array en el equivalente a

un array dinámico en C/C++, se usa la clase vector, que permite operaciones de inserción,

borrado, etc. en el array.

O sea, para declarar, por ejemplo, un arreglo de números enteros utilizaremos la siguiente sentencia:

P á g i n a | 67

Programacion para Principiantes JAVA

int[] arrInt;

Es importante notar que el arreglo aún no ha sido creado, sino meramente declarado. Para crear el

arreglo (reservar su memoria e inicializarlo) deberemos recurrir al operador new:

arrInt = new int[10];

Este comportamiento debe comprenderse de esta forma: en Java todo es un objeto, y los objetos deben

ser creados mediante el operador new. El caso de los arreglos no es diferente, el tipo de datos del

arreglo (int [] en este caso) es una clase y cada una de sus instancias debe ser creada explícitamente,

el tamaño puede pensarse como un parámetro al constructor de la clase.

A partir de este momento podemos utilizar arrInt como un arreglo de cualquier otro lenguaje. Una de

las características que hacen de Java un entorno de programación seguro, y que se relaciona con el

manejo de los arreglos es que el lenguaje no permite la indexación de arreglos fuera de rango, o sea,

una asignación de este tipo generará una excepción:

ArrInt[25] = 1;

Otra forma de declararlos es la siguiente:

UNIDIMENSIONALES:

tipo nombre_array[]=new tipo[nº];

tipo nombre_array[]={valores};

BIDIMENSIONALES:

tipo nombre_array[][]=new tipo[nº][nº];

tipo nombre_array[][]={valores};

Como de deben de Realizar los arrays:

Los arrays se pueden inicializar con valores entre llaves {...} separados por comas.

También los arrays de objetos se pueden inicializar con varias llamadas a new dentro de

unas llaves {...}.

Si se igualan dos referencias a un array no se copia el array, sino que se tiene un array con

dos nombres, apuntando al mismo y único objeto.

Creación de una referencia a un array. Son posibles dos formas:

double[] x; // preferible

double x[];

Creación del array con el operador new:

x = new double[100];

Las dos etapas 4 y 5 se pueden unir en una sola:

double[] x = new double[100];

Ejemplo: Se sabe que la velocidad de un proyectil está dada por la ecuación, en forma vectorial: V=

ai+ bj+ ck. Diseñe una aplicación que sea capaz de leer los valores de las constantes a, b y c. y

muestre la magnitud y dirección de dicho proyectil.

P á g i n a | 68

Programación para Principiantes JAVA

import javax.swing.*;

public class Proyectil{

public static void main (String args []){

String leer;

double magnitud, direccion, sum;

double vector[]=new double[3];

int ban=1;

while(ban==1)//miestras hayan datos a procesar

{

//leemos el valor de las constantes

leer=JOptionPane.showInputDialog("Ingrese el valor de a:");

vector[0]=Double.parseDouble(leer);

leer=JOptionPane.showInputDialog("Ingrese el valor de b:");

vector[1]=Double.parseDouble(leer);

leer=JOptionPane.showInputDialog("Ingrese el valor de c:");

vector[2]=Double.parseDouble(leer);

//calculamos la magnitud

//la cual es la raíz cuadrada de las suma+

//de las componentes al cuadrado

sum=(vector[0]*vector[0])+(vector[1]*vector[1])+(vector[2]*vector[2]);

magnitud=Math.sqrt(sum);

//La dirección viene dada por la tangente inversa

//del cociente de las componentes x,y

direccion=Math.atan(vector[1]/vector[0]);

JOptionPane.showMessageDialog(null, "El valor de la magnitud es: "+magnitud+"\n y con un

angulo direccional de: "+direccion+" Radianes");

leer=JOptionPane.showInputDialog("¿Hay más datos a procesar?\n\nSi=1 y No=0");

ban=Integer.parseInt(leer);

}//del while

}//del main

}//de la clase

Ejemplo: Se tienen las notas de 5 exámenes de 10 alumnos, y se desea promediar la nota final de

cada uno de ellos. Diseñe una aplicación que solucione este problema.

import javax.swing.*;

public class MatrizNotas{

public static void main (String args []) {

int f,c;

double suma, promedio;

double notas [][]=new double[10][5];

String leer;

for(f=0; f<10; f++)//las filas

{

suma=0;

P á g i n a | 69

Programacion para Principiantes JAVA

for(c=0; c<5; c++)

{

leer=JOptionPane.showInputDialog("Ingrese la nota: "+c+" del alumno: "+f);

notas[f][c]=Double.parseDouble(leer);

while(notas[f][c]>10 || notas [f][c]<0)

{

leer=JOptionPane.showInputDialog("Ingrese la nota: "+c+" del alumno: "+f);

notas[f][c]=Double.parseDouble(leer);

}

suma=suma+notas[f][c];

}

promedio=suma/5;

JOptionPane.showMessageDialog(null, "El alumno, tiene un promedio de: "+promedio);

}

}

}

OJO: Los arreglos en JAVA, se tratan de la misma forma que en C/C++, pero la única

diferencia que existe es que, se debe creae (new). Además que, al hacer eso, JAVA inicializa los

arreglos (u objetos9 a cero (o su correspondiente equivalente a cero: null, cero, etc).

REFERENCIAS Y LISTAS

Las referencias en Java no son punteros ni referencias como en C++. Este hecho crea un poco de

confusión entre los programadores que llegan por primera vez a Java. Las referencias en Java son

identificadores de instancias de las clases Java. Una referencia dirige la atención a un objeto de un

tipo específico. No tenemos por qué saber cómo lo hace ni necesitamos saber qué hace ni, por

supuesto, su implementación. Pensemos en una referencia como si se tratase de la llave electrónica

de la habitación de un hotel. Vamos a utilizar precisamente este ejemplo del Hotel para demostrar el

uso y la utilización que podemos hacer de las referencias en Java. Primero crearemos la clase

Habitacion, implementada en el fichero Habitacion.java, mediante instancias de la cual

construiremos nuestro Hotel:

public class Habitacion {

private int numHabitacion;

private int numCamas;

public Habitacion() {

habitacion( 0 );

}

public Habitacion( int numeroHab ) {

habitacion( numeroHab );

}

public Habitacion( int numeroHab,int camas ) {

habitacion( numeroHab );

camas( camas );

}

public synchornized int habitacion() {

return( numHabitacion );

}

public synchronized void habitacion( int numeroHab ) {

numHabitacion = numeroHab;

P á g i n a | 70

Programación para Principiantes JAVA

}

public synchronized int camas() {

return( camas );

}

public syncronized void camas( int camas ) {

numCamas = camas;

}

}

El código anterior sería el corazón de la aplicación. Vamos pues a construir nuestro Hotel

creando Habitaciones y asignándole a cada una de ellas su llave electrónica; tal

comomuestra el código siguiente, Hotel1.java:

public class Hotel1 {

public static void main( String args[] ) {

Habitacion llaveHab1; // paso 1

Habitacion llaveHab2;

llaveHab1 = new Habitacion ( 222 ); // pasos 2, 3,

4 y 5

llaveHab2 = new Habitacion ( 1144,3 );

// ^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^

// A B y D C

}

}

Para explicar el proceso, dividimos las acciones en los cinco pasos necesarios para

poder entrar en nuestra habitación. Aunque no se incluye, podemos también

considerar el caso de que necesitemos un cerrajero, para que cuando perdamos la

llave, nos abra la puerta; y que en nuestro caso sería el garbage collector, que recicla

la habitación una vez que se hayan perdido todas las llaves.

El primer paso es la creación de la llave, es decir, definir la variable referencia, por

defecto nula.

El resto de los pasos se agrupan en una sola sentencia Java. La parte B en el código

anterior indica al gerente del Hotel que ya dispone de una nueva habitación. La parte

C llama al decorador de interiores para que " vista " la habitación según un patrón

determinado, para que no desentonen unas habitaciones con otras y no se pierdan las

señas de identidad del hotel. El código electrónico que nos permitirá acceder a la

habitación se genera en la parte D, una vez conocido el interior de la habitación y se

programa en la llave en la parte A.

Si dejamos el ejemplo real a un lado y nos vamos a lo que ocurre en la ejecución del

código, vemos que el operador new busca espacio para una instancia de un objeto de

una clase determinada e inicializa la memoria a los valores adecuados. Luego invoca

al método constructor de la clase, proporcionándole los argumentos adecuados. El

operador new devuelve una referencia a sí mismo, que es inmediatamente asignada a

la variable referencia.

Podemos tener múltiples llaves para una misma habitación:

. . . Habitacion llaveHab3,llaveHab4; llaveHab3 = llaveHab1; llaveHab4 = llavehab2;

De este modo conseguimos copias de las llaves. Las habitaciones en sí mismas no se

han tocado en este proceso. Así que, ya tenemos dos llaves para la habitación 222 y

otras dos para la habitación 1144.

P á g i n a | 71

Programacion para Principiantes JAVA

Una llave puede ser programada para que funcione solamente con una habitación en

cualquier momento, pero podemos cambiar su código electrónico para que funcione

con alguna otra habitación; por ejemplo, para cambiar una habitación anteriormente

utilizada por un empedernido fumador por otra limpia de olores y con vistas al mar.

Cambiemos pues la llave duplicada de la habitación del fumador (la 222) por la

habitación con olor a sal marina, 1144:

. . . llaveHab3 = llaveHab2;

Ahora tenemos una llave para la habitación 222 y tres para la habitación 1144.

Mantendremos una llave para cada habitación en la conserjería, para poder utilizarla

como llave maestra, en el caso de que alguien pierda su llave propia.

Alguien con la llave de una habitación puede hacer cambios en ella, y los compañeros

que tengan llave de esa misma habitación, no tendrán conocimiento de esos cambios

hasta que vuelvan a entrar en la habitación. Por ejemplo, vamos a quitar una de las

camas de la habitación, entrando en ella con la llave maestra:

. . . llaveHab2.camas ( 2 );

Ahora cuando los inquilinos entren en la habitación podrán comprobar el cambio

realizado:

llaveHab4.printData ();

Mediante la clase List crearemos el objeto. Este tipo de lista puede admite más de una selección, el

orden de sus elementos es según han sido añadidos. Los miembros son los mismos que en el control

anterior solo cambia el modo de construirlos. En este control aparecen unas barras de desplazamiento

verticales automáticamente.

CREAR:

List nombre_objeto=new List(0,true); múltiple selección.

List nombre_objeto=new List(0,false); selección simple.

EJEMPLO:

import java.awt.*;

import java.applet.*;

public class lista extends Applet{

Label eti1=new Label("",Label.LEFT);

Label eti2=new Label("",Label.LEFT);

Button mira=new Button("Mostrar");

List lista=new List(0,true);

public void init(){

setLayout(null);

add(eti1);

add(eti2);

add(mira);

add(lista);

eti1.reshape(120,10,40,50);

eti2.reshape(160,10,40,50);

mira.reshape(10,90,75,40);

P á g i n a | 72

Programación para Principiantes JAVA

lista.reshape(10,10,100,75);

lista.addItem("Uno");

lista.addItem("Dos");

lista.addItem("Tres");

lista.addItem("Cuatro");

lista.addItem("Cinco");

lista.addItem("Seis");

}

public boolean action(Event evento,Object obj)

{

if (evento.target instanceof Button)

{

int num=lista.getSelectedIndex();

String cad1=lista.getSelectedItem();

String cad2=String.valueOf(num);

eti1.setText(cad2);

eti2.setText(cad1);

return true;

// int num1=lista.countItems();

// String cad2=String.valueOf(num1);

// eti1.setText(cad2);

}

return false;

}

}

Gráficos en Java

Elementos Estamos a punto de iniciar uno de los aspectos más llamativos de Java, como lo es la

parte gráfica, el tratamiento de imágenes… En muchas páginas web, nos llaman la atención las

animaciones, sonidos, y aspectos gráficos de las mismas. Y muchos de esos efectos han sido creados

en Java, o al menos la base de los

g.drawImage (img1, 20, 20, this);

Componentes Un Componente es un elemento visual con el cual el usuario puede interactuar a

través del ratón o el teclado; mientras que un contenedor, es un área visual, en la cual se encuentran

los componentes.

Ejemplo de Componentes:

Rótulo: es un área en la cual se puede colocar texto NO editable.

Botón: Es un área que dispara un evento al dar clic sobre él.

Lista: Es un área en la cual se exhiben una serie de elementos.

Campo de Texto: Es un área en la cual el usuario puede ingresar información mediante el

teclado.

P á g i n a | 73

Programacion para Principiantes JAVA

Las clases que vamos a usar para crear los componentes, forman parte del paquete java.awt.

PORCIÓN DE LA JERARQUIA DE JAVA.AWT

Toda clase que hereda de la clase Component es un componente. Cualquier clase que hereda de la

clase Container es un contenedor. Un contenedor es un área en la que podemos colocar

componentes.

Rótulos Como Ya se dijo, en los rótulos podemos colocar texto no editable. Un rótulo se crea a partir

de la clase Label. Dicha clase tiene dos constructores:

Public Label(); El cual construye un rótulo vacío que no exhibe ningún texto.

Public Label (String S); El cual construye un rótulo con el texto S.

Métodos:

public String getText()

Devuelve el texto del rótulo.

public void setText( String s)

Fija el texto del rótulo

Ejemplo: Muestra el uso de los Labels.

import java.awt.*;

import javax.swing.*;

public class UsaLabel extends JApplet {

Label rotulo1, rotulo2, rotulo3;

public void init()

{

//inicializamos los rótulos

rotulo1=new Label();//rotulo vacío

rotulo2=new Label("Este es un Rótulo");

/*ahora debemos agregar estos componentes al

contenedor, lo que se hace mediante la

instrucción add*/

add(rotulo1);

add(rotulo2);

P á g i n a | 74

Programación para Principiantes JAVA

}//del init

}//del Applet

Botones

Los Botones disparan un evento (acción), cuando son accionados (al dar un clic sobre él). Los

botones se construyen mediante la Clase Button:

Public Button(); //Crea un Botón sin rótulo

Public Button(String S); //Crea un Botón con el rótulo S

Para asociar los controles como botones, listas, casillas, etc... a un método debemos implementar

el método action. En dicho método deberemos escribir las acciones que van a realizar cada uno de

los controles que tengamos en el applet, teniendo en cuenta lo siguiente. El método action recibe

dos parámetros, el primero es un objeto de la clase Event que recoge el evento producido en el

applet. El segundo es un objeto de la clase Object que recoge cual a sido el control que a producido

la acción. Con estos dos objetos lo primero que debemos escribir en el método action son sentencias

if para determinar el tipo de control que a producido la acción (línea 1). Si hay más controles del

mismo tipo, deberemos distinguir uno de otro con más sentencias if dentro de cada if que gestiona

el tipo de control (línea 2). Por último, cada uno de estos if deben llevar una sentencia return true

para indicar que todo ha ido bien (lineal). Al final del método se debe incluir la sentencia return false

para no hacer nada en caso de que la acción realizada no tenga interés para nuestra aplicación (línea

4).

public boolean action(Event nombre_ev, Object nombre_obj) {

if (nombre_ev.target instanceof Button) {

cuerpo con if para cada uno de ese tipo;

return true; }

return false;}

Ejemplo:

Muestra como usar los botones.

//creacion de botones para pulsar

import java.awt.*;

import java.applet.Applet;

public class MisBotones extends Applet

{

private Button boton1, boton2, boton3;

public void init()

{

boton1 = new Button("Pulse aqui");

boton2 = new Button("Yo no hago nada");

boton3 = new Button("Sin rotulo");

//agregar botones

P á g i n a | 75

Programacion para Principiantes JAVA

add(boton1);

add(boton2);

add(boton3);

}

//manejar los eventos de boton

public boolean action (Event e, Object o)

{

//verificar si un boton disparo el evento

if (e.target instanceof Button) {

//comprobar si se pulso boton1 o boton2

//no se hara nada si se pulso boton2

// En o se guarda el nombre del boton que se pulsó

if (e.target == boton1)

showStatus ("Usted pulso: "+ o.toString());

else if (e.target == boton3)

showStatus ("Usted pulso: "+ e.arg);

return true; //el evento se manejo aqui

}

return true;

}

}

Campos de Texto

TextField implementa un área de entrada de texto de una sola línea. Todo aquello que escribimos en

una caja de texto es de tipo String por tanto si queremos realizar operaciones matemáticas deberemos

transformarlo a un valor numérico.

CREACIÓN:

TextField nombre_objeto=new TextField (ancho);

Add (nombre_objeto);

POSICIONAMIENTO:

nombre_objeto.reshape(x, y, ancho, alto);

GUARDAR TEXTO: valido para etiquetas.

Variable=nombre_objeto.getText ();

MOSTRAR TEXTO: valido para etiquetas.

nombre_objeto.setText (variable);

Ejemplo:

import java.awt.*;

import javax.swing.*;

public class Contrsena extends JApplet {

P á g i n a | 76

Programación para Principiantes JAVA

Label rotulo;

Button boton1;

TextField text1;

public void init()

{

rotulo=new Label("Ingrese su contraseña");

text1=new TextField(10);

boton1=new Button("Aceptar");

add(rotulo);

add(text1);

add(boton1);

}

public boolean action ( Event e, Object o)

{

if(e.target instanceof Button)

if(e.target==boton1)

{

String password=text1.getText();

if(password.equals("Carolina"))

JOptionPane.showMessageDialog(null, "Contraseña Correcta");

else

JOptionPane.showMessageDialog(null, "Contraseña Incorrecta");

}

return true;

}

}

Interfaces

Vuélvalo a Compilar y Ejecútelo.

Una interfaz, pareceriera que no tiene ningún tipo de aplicación o implementación, dentro de los

programas que, creamos en Java. Sin embargo no es así. Ya que, una interfaz indica, como será la

"apariencia", que la clase tendrá. Además que, establece cierto "protocolo" entre las clases.

Para declarar una clase haremos uso de la palabra reservada interface (la cual sustituye a la palabra

class). Y para implementar la interfaz, haremos uso de la palabra reservada implements la cual debe

especificarse, al momento de declarar la clase que, implementará dicha interfaz.

Ejemplo: Supongamos que queremos crear un programa que, dadas la base y la altura de un

rectángulo, nos devuelva su area, su perímetro y su volumen. Pero haciendo uso de una interfaz.

Solución:

En archivo nuevo digite el siguiente código:

//declaración de la interfaz

public interface Calculos {

P á g i n a | 77

Programacion para Principiantes JAVA

public double Perimetro (); //calcula el Perímetro

public double Area (); //calcula Area

public double Volumen (); //calcula el volumen

}//fin de la interfaz

Guarde este archivo y compílelo.

En otro archivo digite el siguiente código:

//Declaración de la clase que implementa la Interfaz Calculos

public class Rectangulo extends Object implements Calculos{

private double base, altura;

public Rectangulo()//constructor

{

base=0;

altura=0;

}

//establece la base

public void AignarBase(double x)

{

base=x;

}

//estabece el valor de la altura

public void AsignarAltura(double y)

{

altura=y;

}

//Calculamos el Perímetro

public double Perimetro()

{

return 2*base+2*altura;

}

//calculamos el area

public double Area()

{

return base*altura;

}

public double Volumen()

{

double espesor=5;

return base*altura*espesor;

}

}

Guarde y compile.

P á g i n a | 78

Programación para Principiantes JAVA

Quizá el lector piense que, una interfaz no tiene mayor uso, y a lo mejor, ni se perciba su

funcionamiento y mucho menos su implementación. Y siendo franco, al principio, ni yo entendía el

por que usar una interfaz. Sin embargo Las interfaces son útiles para:

Capturar similitudes entre clases no relacionadas sin forzar una relación entre ellas.

Declarar métodos que una o varias clases necesitan implementar.

Revelar la interface de programación de un objeto sin recelar sus clases (los objetos de este

tipo son llamados objetos anónimos y pueden ser útiles cuando se comparte un paquete de

clases con otros desarrolladores). El objetivo de definir interfaces es permitir una mayor

abstracción de datos, por ejemplo, permitiendo que un método reciba un objeto de una

instancia de alguna clase que implementa una interface, de modo que pueda invocarse a un

método definido en esta, aunque no se conozca la clase real que se está utilizando.

Hilos

Los procesadores y los Sistemas Operativos modernos permiten la multitarea, es decir, la realización

simultánea de dos o más actividades (al menos aparentemente). En la realidad, un ordenador con

una sola CPU no puede realizar dos actividades a la vez. Sin embargo los Sistemas Operativos

actuales son capaces de ejecutar varios programas "simultáneamente" aunque sólo se disponga de

una CPU: reparten el tiempo entre dos (o más) actividades, o bien utilizan los tiempos muertos de

una actividad (por ejemplo, operaciones de lectura de datos desde el teclado) para trabajar en la

otra. En ordenadores con dos o más procesadores la multitarea es real, ya que cada procesador

puede ejecutar un hilo o thread diferente. La Figura tomada del Tutorial de Sun, muestra los

esquemas correspondientes a un programa con uno o dos hilos.

Los métodos de la clase Thread:

currentThread: Representa al hilo que esta ejecutándose en ese momento.

yield: Asegura que los hilos de menor prioridad no sufran inanición.

sleep: Pone a dormir al hilo en curso durante n milisegundos.

start: Crea un hilo de sistema y ejecuta. Luego llama al método run.

run: Es el cuerpo del hilo. Es llamado por el método start.

stop: Provoca la destrucción del hilo.

suspend: Detiene el hilo, pero no lo destruye. Puede ejecutarse de nuevo.

resume: Para revivir un hilo suspendido.

setName: Asigna un nombre al hilo en curso.

getName: Devuelve el nombre del hilo en ejecución.

setPriority () Establece la prioridad del hilo. De 1 a 10.

getPriority: Devuelve la prioridad del hilo en curso.

P á g i n a | 79

Programacion para Principiantes JAVA

Ejemplo:

public class ContadorAdelante extends Thread {

public ContadorAdelante(String nombre) // constructor

{

if (nombre != null)

setName(nombre);

start(); //el hilo ejecuta su propio método run

}

public ContadorAdelante() { this(null); } // constructor

public void run()

{

for (int i=1; i<=1000; i++)

System.out.print(getName() + " "+i+"\r");

System.out.println();

}

}

El operador new crea un hilo cuenta Adelante (el hilo está en el estado nuevo). El método start

cambia el estado del hilo a preparado. De ahora en adelante y hasta que finalice la ejecución del

hilo cuentaAdelante, será el planificador de hilos el que determine cuando éste pasa al estado de

ejecución y cuando lo abandona para permitir que se ejecuten simultáneamente otros hilos. El

método start no hace que se ejecute inmediatamente el método run del hilo, sino que lo sitúa en el

estado preparado para que compita por la UCP junto con el resto de los hilos que haya en este

estado. Solo el planificador puede asignar tiempo de UCP a un hilo y lo hará con cuenta Adelante en

cualquier instante después de que haya recibido el mensaje start. Por lo tanto, un hilo durante su

tiempo de vida, gasta parte de él en ejecutarse y el resto en alguno de los otros estados. Lo que no

se debe hacer es llamar directamente al método run; esto ejecutaría el código de este método sin

que intervenga el planificador. Quiere esto decir que es el método start el que registra el hilo en el

planificador de hilos.

Ejemplo: Dos hilos se crean utilizando el método setPriority con dos niveles de prioridad distintos.

Se inician ambos y se les permite la ejecución durante 10 segundos. Cada hilo gira en torno a un

bucle que cuenta cuantas veces se ejecuto el mismo.

class pulso implements Runnable{

int pulsa=0;

private Thread hilo;

private boolean corre=true;

public pulso(int p){

hilo=new Thread(this);

hilo.setPriority(p);

}

public void run(){

while(corre){

pulsa++;

P á g i n a | 80

Programación para Principiantes JAVA

}

}

public void stop(){

corre=false;

}

public void start(){

hilo.start();

}

}

ALCANCE DE OBJETOS Y RECICLADO DE MEMORIA

Los objetos tienen un tiempo de vida y consumen recursos durante el mismo. Cuando un objeto no

se va a utilizar más, debería liberar el espacio que ocupaba en la memoria de forma que las

aplicaciones no la agoten (especialmente las grandes).

En Java, la recolección y liberación de memoria es responsabilidad de un thread llamado automatic

garbage collector (recolector automático de basura). Este thread monitoriza el alcance de los objetos

y marca los objetos que se han salido de alcance. Veamos un ejemplo:

String s; // no se ha asignado todavia

s = new String (“abc”); // memoria asignada

s = "def"; // se ha asignado nueva memoria

// (Nuevo objeto)

Más adelante veremos en detalle la clase String , pero una breve descripción de lo que hace esto es;

crear un objeto String y rellenarlo con los caracteres "abc" y crear otro (nuevo) String y colocarle

los caracteres "def".

En esencia se crean dos objetos:

Objeto String "abc"

Objeto String "def"

Al final de la tercera sentencia, el primer objeto creado de nombre s que contiene "abc" se ha salido

de alcance. No hay forma de acceder a él. Ahora se tiene un nuevo objeto llamado s y contiene "def".

Es marcado y eliminado en la siguiente iteración del thread reciclador de memoria.

Paquetes (Packages)

Un package es una agrupación de clases. En la API de Java 1.1 había 22 packages; en Java 1.2 hay

59 packages, lo que da una idea del "crecimiento" experimentado por el lenguaje. Además, el usuario

puede crear sus propios packages. Para que una clase pase a formar parte de un package llamado

pkgName, hay que introducir en ella la sentencia:

Package pkgName;

Que debe ser la primera sentencia del fichero sin contar comentarios y líneas en blanco.

P á g i n a | 81

Programacion para Principiantes JAVA

Los nombres de los packages se suelen escribir con minúsculas, para distinguirlos de las clases, que

empiezan por mayúscula. El nombre de un package puede constar de varios nombres unidos por

puntos (los propios packages de Java siguen esta norma, como por ejemplo java.awt.event). Todas

las clases que forman parte de un package deben estar en el mismo directorio. Los nombres

compuestos de los packages están relacionados con la jerarquía de directorios en que se guardan las

clases. Es recomendable que los nombres de las clases de Java sean únicos en Internet. Es el nombre

del package lo que permite obtener esta característica. Una forma de conseguirlo es incluir el nombre

del dominio (quitando quizás el país), como por ejemplo en el package siguiente:

es.ceit.jgjalon.infor2.ordenar

Las clases de un package se almacenan en un directorio con el mismo nombre largo (path)

que el package. Por ejemplo, la clase,

es.ceit.jgjalon.infor2.ordenar.QuickSort.class

Debería estar en el directorio, CLASSPATH\es\ceit\jgjalon\infor2\ordenar\QuickSort.class

Donde CLASSPATH es una variable de entorno del PC que establece la posición absoluta de

los directorios en los que hay clases de Java (clases del sistema o de usuario), en este caso

la posición del directorio es en los discos locales del ordenador.

Pasos Para Crear un Paquete

Seleccionar el Nombre de Paquete. Ejemplo: MiPaquete.es; misClases.Utilidades. Para ello cree una

carpeta llamada Ejemplo, en el disco duro. Crear una estructura Jerárquica de carpetas en el disco

duro. Esta estructura jerárquica se hace corresponder con una estructura en el disco duro con una

estructura jerárquica de carpetas, de tal forma que los nombres de las carpetas coinciden con los

nombres de los elementos del paquete. (Para ello, dentro de la carpeta Ejemplo, cree una carpeta

llamada MIsClases, y dentro de ella, una llamada es) Lo cual se especifica con la variable

CLASSPATH. Para nuestro ejemplo, la variable CLASSPATH debe indicar, entre otras, la ruta de la

carpeta MisClases. En JGRASP en Settings escoger Path/Classpath luego escoger la carpeta

CLASSPATH.

Copie en esta carpeta (Carpeta es) los archivos correspondientes a Alumnos.java, Coordenadas.java

e Imaginario.java (los cuales han sido creados en el capítulo anterior).

Package MisClases.es;

Modifique estos archivos, colocándole a cada uno de ellos la instrucción:

Vuélvalos a compilar.

Luego copie el archivo que utiliza la clase Coordenadas.java (Nos referimos al archivo

UsaCoordendas.java). este archivo puede guardarlo en la dirección: C:\Ejemplo. Import

MisClases.es.Coordenadas;

Import Los paquetes de clases se cargan con la palabra clave import, especificando el nombre del paquete

como ruta y nombre de clase (es lo mismo que #include de C/C++). Se pueden cargar varias clases

utilizando un asterisco.

Import java.Date;

import java.awt.*;

P á g i n a | 82

Programación para Principiantes JAVA

Si un fichero fuente Java no contiene ningún package, se coloca en el paquete por defecto

sin nombre. Es decir, en el mismo directorio que el fichero fuente, y la clase puede ser

cargada con la sentencia import:

Import MiClase;

Paquetes de Java El lenguaje Java proporciona una serie de paquetes que incluyen ventanas, utilidades, un

sistema de entrada/salida general, herramientas y comunicaciones. En la versión actual del

JDK, los paquetes Java que se incluyen son:

java.applet

Este paquete contiene clases diseñadas para usar con applets. Hay una clase Applet y tres

interfaces: AppletContext, AppletStub y AudioClip.

java.awt

El paquete Abstract Windowing Toolkit (awt) contiene clases para generar widgets y

componentes GUI (Interfaz Gráfico de Usuario). Incluye las clases Button, Checkbox,

Choice, Component, Graphics, Menu, Panel, TextArea y TextField.

java.io

El paquete de entrada/salida contiene las clases de acceso a ficheros: FileInputStream y

FileOutputStream.

java.lang

Este paquete incluye las clases del lenguaje Java propiamente dicho: Object, Thread,

Exception, System, Integer, Float, Math, String, etc.

java.net

Este paquete da soporte a las conexiones del protocolo TCP/IP y, además, incluye las clases

Socket, URL y URLConnection.

java.util

Este paquete es una miscelánea de clases útiles para muchas cosas en programación. Se

incluyen, entre otras, Date (fecha), Dictionary (diccionario), Random (números aleatorios)

y Stack (pila FIFO).

Modifique este archivo colocándole la sentencia:

Con lo Anterior ya hemos creado, nuestro primer paquete, lo cual, es de manera similar, que Java

controla, los paquetes que dispone para la realización de nuestros programas.

P á g i n a | 83

Programacion para Principiantes JAVA

UNA MíNIMA APLICACIóN

La aplicación más pequeña posible es la que simplemente imprimir un mensaje en la pantalla.

Tradicionalmente, el mensaje suele ser "Hola Mundo!". Esto es justamente lo que hace el siguiente

fragmento de código:

//

// Aplicación HolaMundo de ejemplo

//

class HolaMundoApp {

public static void main( String args[] ) {

System.out.println( "Hola Mundo!" ) ;

}

}

HolaMundo

Vamos ver en detalle la aplicación anterior, línea a línea. Esas líneas de código contienen los

componenetes mínimos para imprimir Hola Mundo! en la pantalla.

//

// Aplicación HolaMundo de ejemplo

//

Estas tres primeras líneas son comentarios. Hay tres tipos de comentarios en Java, // es un comentario

orientado a línea.

class HolaMundoApp {

P á g i n a | 84

Programación para Principiantes JAVA

Esta línea declara la clase HolaMundoApp . El nombre de la clase especificado en el fichero fuente

se utiliza para crear un fichero nombredeclase.class en el directorio en el que se compila la aplicación.

En nuestro caso, el compilador creará un fichero llamado HolaMundoApp.class.

public static void main( String args[] ) {

Esta línea especifica un método que el intérprete Java busca para ejecutar en primer lugar. Igual que

en otros lenguajes, Java utiliza una palabra clave main para especificar la primera función a ejecutar.

En este ejemplo tan simple no se pasan argumentos.

public significa que el método main puede ser llamado por cualquiera, incluyendo el intérprete Java.

static es una palabra clave que le dice al compilador que main se refiere a la propia clase

HolaMundoApp y no a ninguna instancia de la clase. De esta forma, si alguien intenta hacer otra

instancia de la clase, el método main no se instanciaría.

void indica que main no devuelve nada. Esto es importante ya que Java realiza una estricta

comprobación de tipos, incluyendo los tipos que se ha declarado que devuelven los métodos.

args[] es la declaración de un array de Strings. Estos son los argumentos escritos tras el nombre de la

clase en la línea de comandos:

%java HolaMundoApp arg1 arg2 ...

System.out.println( "Hola Mundo!" );

Esta es la funcionalidad de la aplicación. Esta línea muestra el uso de un nombre de clase y método.

Se usa el método println() de la clase out que está en el paquete System .

El método println() toma una cadena como argumento y la escribe en el stream de salida estándar; en

este caso, la ventana donde se lanza la aplicación.

}

}

Finalmente, se cierran las llaves que limitan el método main () y la clase HolaMundoApp.

COMPILACION Y EJECUCION DE HOLA MUNDO

Vamos a ver a continuación como podemos ver el resultado de nuestra primera aplicación Java en

pantalla. Generaremos un fichero con el código fuente de la aplicación, lo compilaremos y

utilizaremos el intérprete java para ejecutarlo.

Ficheros Fuente Java

Los ficheros fuente en Java terminan con la extensión " .java”. Crear un fichero utilizando cualquier

editor de texto ascii que tenga como contenido el código de las ocho líneas de nuestra mínima

aplicación, y salvarlo en un fichero con el nombre de HolaMundoApp.java. Para crear los ficheros

con código fuente Java no es necesario un procesador de textos, aunque puede utilizarse siempre que

tenga salida a fichero de texto plano o ascii, sino que es suficiente con cualquier otro editor.

P á g i n a | 85

Programacion para Principiantes JAVA

Compilación

El compilador javac se encuentra en el directorio bin por debajo del directorio java, donde se haya

instalado el JDK. Este directorio bin, si se han seguido las instrucciones de instalación, debería formar

parte de la variable de entorno PATH del sistema. Si no es así, tendría que revisar la Instalación del

JDK. El compilador de Java traslada el código fuente Java a byte-codes, que son los componentes

que entiende la Máquina Virtual Java que está incluida en los navegadores con soporte Java y en

appletviewer.

Una vez creado

%javac HolaMundoApp el fichero fuente HolaMundoApp.java, se puede compilar con la línea

siguiente: .java

Si no se han cometido errores al teclear ni se han tenido problemas con el path al fichero fuente ni al

compilador, no debería aparecer mensaje alguno en la pantalla, y cuando vuelva a aparecer el prompt

del sistema, se debería ver un fichero HolaMundoApp.class nuevo en el directorio donde se encuentra

el fichero fuente. Si ha habido algún problema, en Problemas de compilación al final de esta sección,

hemos intentado reproducir los que más frecuentemente se suelen dar, se pueden consultar por si

pueden aportar un poco de luz al error que haya aparecido.

Ejecución

Para ejecutar la aplicación HolaMundoApp, hemos de recurrir al intérprete java, que también se

encuentra en el directorio bin , bajo el directorio java . Se ejecutará la aplicación con la línea: %java

HolaMundoApp. Y debería aparecer en pantalla la respuesta de Java: %Hola Mundo!

El símbolo % representa al prompt del sistema, y lo utilizaremos para presentar las respuestas que

nos ofrezca el sistema como resultado de la ejecución de los comandos que se indiquen en pantalla o

para indicar las líneas de comandos a introducir.

A continuación presentamos una lista de los errores más frecuentes que se presentan a la hora de

compilar un fichero con código fuente Java, nos basaremos en errores provocados sobre nuestra

mínima aplicación Java de la sección anterior, pero podría generalizarse sin demasiados problemas.

%javac: Command not found. No se ha establecido correctamente la variable PATH del sistema para

el compilador javac . El compilador javac se encuentra en el directorio bin , que cuelga del directorio

java , que cuelga del directorio donde se haya instalado el JDK (Java Development Kit).

%HolaMundoApp.java:3: Method printl(java.lang.String) not found in class java.io.PrintStream.

System.out.printl( "HolaMundo!); ^ Error tipográfico, el método es println no printl. %In class

HolaMundoApp: main must be public and static. Error de ejecución, se olvidó colocar la palabra

static en la declaración del método main de la aplicación. %Can´t find class HolaMundoApp.

Este es un error muy sutil. Generalmente significa que el nombre de la clase es distinto al del fichero

que contiene el código fuente, con lo cual el fichero nombre_fichero.class que se genera es diferente

del que cabría esperar. Por ejemplo, si en nuestro fichero de código fuente de nuestra aplicación

HolaMundoApp.java colocamos en vez de la declaración actual de la clase HolaMundoApp, la línea:

class HolaMundoapp {

Se creará un fichero HolaMundoapp.class, que es diferente del HolaMundoApp.class, que es el

nombre esperado de la clase; la diferencia se encuentra en la a minúscula y mayúscula.

P á g i n a | 86

Programación para Principiantes JAVA

UN APPLET BASICO

Vamos a comenzar la creación del código fuente del un applet que satisfaga nuestras necesidades.

Recordamos que Java utiliza la extensión .java para designar los ficheros fuente.

HolaMundo

A continuación está el código fuente del applet HolaMundo, que es la versión applet de la mínima

aplicación Java que antes habíamos escrito. Guardar este código en un fichero fuente Java como

HolaMundo.java .

//

// Applet HolaMundo de ejemplo

//

import java.awt.Graphics;

import java.applet.Applet;

public class HolaMundo extends Applet {

public void paint( Graphics g ) {

g.drawString( "Hola Mundo!",25,25 ) ;

}

}

Componentes básicos de un Applet

El lenguaje Java implementa un modelo de Programación Orientada a Objetos. Los objetos sirven de

bloques centrales de construcción de los programas Java. De la misma forma que otros lenguajes de

programación, Java tiene variables de estado y métodos.

Veamos como se descompone un applet en sus piezas/objetos:

/*

Sección de importaciones

*/

public class NombreDelNuevoApplet extends Applet {

/*

Aquí se declaran las variables de estado (public y private)

*/

/*

Los métodos para la interacción con los objetos se

declaran y definen aquí

*/

public void MetodoUno( parámetros ) {

/*

Aquí viene para cada método, el código Java que

desempeña la tarea.

Qué código se use depende del applet

*/

}

}

P á g i n a | 87

Programacion para Principiantes JAVA

Para HolaMundo, se importan las dos clases que necesita. No hay variables de estado, y sólo se tiene

que definir un método para que el applet tenga el comportamiento esperado.

Clases incluidas

El comando import carga otras clases dentro de nuestro código fuente. El importar una clase desde

un paquete de Java hace que esa clase importada esté disponible para todo el código incluido en el

fichero fuente Java que la importa. Por ejemplo, en el applet HolaMundo se importa la clase

java.awt.Graphics, y podremos llamar a los métodos de esta clase desde cualquier método de nuestro

programa que se encuentre en el fichero HolaMundo.java. Esta clase define un área gráfica y métodos

para poder dibujar dentro de ella. La función paint () declara a g como un objeto de tipo Graphics;

luego, paint () usa el método drawString () de la clase Graphics para generar su salida.

La clase Applet

Se puede crear una nueva clase, en este caso HolaMundo, extendiendo la clase básica de Java:

Applet. De esta forma, se hereda todo lo necesario para crear un applet. Modificando determinados

métodos del applet, podemos lograr que lleve a cabo las funciones que deseamos.

import java.applet.Applet;

public class HolaMundo extends Applet {

Métodos de Applet

La parte del applet a modificar es el método paint (). En la clase Applet, se llama al método paint ()

cada vez que el método arranca o necesita ser refrescado, pero no hace nada. En nuestro caso, lo

que hacemos es:

public void paint( Graphics g ) {

g.drawString( "Hola Mundo!",25,25 );

}

De acuerdo a las normas de sobrecarga, se ejecutará este último paint () y no el paint () vacío de la

clase Applet . Luego, aquí se ejecuta el método drawString (), que le dice al applet cómo debe

aparecer un texto en el área de dibujo. Otros métodos básicos para dibujar son:

drawLine( int x1,int y1,int x2,int y2 )

drawRect( int x,int y,int ancho,int alto )

drawOval( int x,int y,int ancho,int alto )

Tanto para drawRect () como para drawOval () , las coordenadas ( x,y ) son la esquina superior

izquierda del rectángulo (para drawOval, el óvalo es encajado en el rectángulo que lo circunscribe).

Cambio de Tamaño

El cambio de tamaño de un StringBuffer necesita varias funciones específicas para

manipular el tamaño de las cadenas:

int length();

P á g i n a | 88

Programación para Principiantes JAVA

char charAt( int index );

void getChars( int srcBegin,int srcEnd,char dst[],int dstBegin );

String toString();

void setLength( int newlength );

void setCharAt( int index,char ch );

int capacity();

void ensureCapacity( int minimum );

void copyWhenShared();

Obervar que una de las funciones devuelve una cadena constante normal de tipo String. Este objeto

se puede usar con cualquier función String, como por ejemplo, en las funciones de comparación.

Modificación del Contenido

Para cambiar el contenido de un StringBuffer, se pueden utilizar dos métodos: append () e

insert ().

En el ejemplo CadAppend.java, vemos el uso de estos dos métodos:

class CadAppend {

public static void main( String args[] ) {

StringBuffer str = new StringBuffer( "Hola" );

str.append( " Mundo" );

System.out.println( str );

}

}

En este otro ejemplo, CadInversa.java, mostramos un método muy simple que le da la vuelta a una

cadena:

class CadInversa {

public static String cadenaInversa( String fuente ) {

int longitud = fuente.length();

StringBuffer destino = new StringBuffer( longitud );

for( int i=(longitud-1); i >= 0; i-- )

destino.append( fuente.charAt( i ) );

return( destino.toString() );

}

public static void main( String args[] ) {

System.out.println( cadenaInversa( "Hola Mundo" ) );

}

}

Las funciones que cambian el tamaño son pues:

StringBuffer append( Object obj );

StringBuffer append( String str );

StringBuffer append( char str[] );

StringBuffer append( char str[],int offset,int len );

StringBuffer append( boolean b );

P á g i n a | 89

Programacion para Principiantes JAVA

StringBuffer append( int i );

StringBuffer append( long l );

StringBuffer append( float f );

StringBuffer append( double d );

StringBuffer append( char ch );

StringBuffer insert( int offset,Object obj );

StringBuffer insert( int offset,String str );

StringBuffer insert( int offset,char str[] );

StringBuffer insert( int offset,boolean b );

StringBuffer insert( int offset,int i );

StringBuffer insert( int offset,long l );

StringBuffer insert( int offset,float f );

StringBuffer insert( int offset,double d );

StringBuffer insert (int offset,char ch );

Operadores de Concatenación

Hay que recordar que los operadores " + " y " += " también se pueden aplicar a cadenas.

Ambos realizan una concatenación y están implementados con objetos StringBuffer.

Por ejemplo, la sentencia:

String s = "¿Qué" + " tal?";

Es interpretada por el compilador como:

String s =

new StringBuffer().append( "¿Qué" ).append( " tal ?" ).ToString

();

Y se marcaría el StringBuffer para borrarlo ya que el contenido pasa al objeto String.

También, la sentencia:

s += " por ahí!";

Sería interpretada por el sistema como:

String s =

New StringBuffer ().append(s).append( " por ahí!" ).ToString ();

Y volvería a marcar para borrar el nuevo StringBuffer.

USO DE CONVERSIONES

Veamos un ejemplo de utilidad de estas funciones. En el applet Conversion.java, que se muestra en

el código que sigue, se usan estas funciones para producir una salida útil en un programa, presentando

las coordenadas en las que se ha hecho click con el botón del ratón.

public class Conversion extends Applet {

P á g i n a | 90

Programación para Principiantes JAVA

int RatonX = 25;

int RatonY = 25;

String Status = "Haz click con el ratón";

public void paint( Graphics g ) {

g.drawString( Status,RatonX,RatonY );

}

public boolean mouseDown( Event evt,int x,int y ) {

Integer X = new Integer( x );

Integer Y = new Integer( y );

RatonX = x;

RatonY = y;

Status = X.toString()+","+Y.toString();

repaint();

return true;

}

}

ENTRADA/SALIDA ESTANDAR

Los usuarios de Unix, y aquellos familiarizados con las líneas de comandos de otros sistemas como

DOS, han utilizado un tipo de entrada/salida conocida comúnmente por entrada/salida estándar. El

fichero de entrada estándar (stdin ) es simplemente el teclado. El fichero de salida estándar (stdout)

es típicamente la pantalla (o la ventana del terminal). El fichero de salida de error estándar (stderr)

también se dirige normalmente a la pantalla, pero se implementa como otro fichero de forma que se

pueda distinguir entre la salida normal y (si es necesario) los mensajes de error.

La clase System: Java tiene acceso a la entrada/salida estándar a través de la clase

System. En concreto, los tres ficheros que se implementan son:

Stdin: System.in implementa stdin como una instancia de la clase InputStream.

Con System.in, se accede a los métodos read () y skip( ). El método read () permite

leer un byte de la entrada. skip (long n ) , salta n bytes de la entrada.

Stdout: System.out implementa stdout como una instancia de la clase PrintStream.

Se pueden utilizar los métodos print () y println () con cualquier tipo básico Java

como argumento.

Stderr: System.err implementa stderr de la misma forma que stdout. Como con

System.out, se tiene acceso a los métodos de PrintStream.

Vamos a ver un pequeño ejemplo de entrada/salida en Java. El código siguiente, miType.java,

reproduce, o funciona como la utilidad cat de Unix o type de DOS:

import java.io.*;

class miType {

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

int c;

int contador = 0;

while( (c = System.in.read() ) != 'n' )

{

contador++;

System.out.print( (char)c );

}

System.out.println(); // Línea en blanco

P á g i n a | 91

Programacion para Principiantes JAVA

System.err.println( "Contados "+ contador +" bytes en

total." );

}

}

Clases comunes de Entrada/Salida

Además de la entrada por teclado y salida por pantalla, se necesita entrada/salida por

fichero, como son:

FileInputStream

DataInputStream

FileOutputStream

DataOutputStream

También existen otras clases para aplicaciones más específicas, que no vamos a tratar, por

ser de un uso muy concreto:

PipedInputStream

BufferedInputStream

PushBackInputStream

StreamTokenizer

PipedOutputStream

BufferedOutputStream

Ficheros

Antes de realizar acciones sobre un fichero, necesitamos un poco de información sobre ese

fichero. La clase File proporciona muchas utilidades relacionadas con ficheros y con la

obtención de información básica sobre esos ficheros.

FICHEROS DE ACCESO ALEATORIO

A menudo, no se desea leer un fichero de principio a fin; sino acceder al fichero como una base de

datos, donde se salta de un registro a otro; cada uno en diferentes partes del fichero. Java proporciona

una clase RandomAccessFile para este tipo de entrada/salida.

Creación de un Fichero de Acceso Aleatorio

Hay dos posibilidades para abrir un fichero de acceso aleatorio:

Con el nombre del fichero:

miRAFile = new RandomAccessFile( String nombre,String modo );

Con un objeto File:

miRAFile = new RandomAccessFile( File fichero,String modo );

P á g i n a | 92

Programación para Principiantes JAVA

El argumento modo determina si se tiene acceso de sólo lectura (r) o de lectura/escritura

(r/w). Por ejemplo, se puede abrir un fichero de una base de datos para actualización:

RandomAccessFile miRAFile;

miRAFile = new RandomAccessFile( "/tmp/kk.dbf","rw" );

Acceso a la Información

Los objetos RandomAccessFile esperan información de lectura/escritura de la misma manera que los

objetos DataInput/DataOutput. Se tiene acceso a todas las operaciones read() y write() de las clases

DataInputStream y DataOutputStream . También se tienen muchos métodos para moverse dentro de

un fichero:

long getFilePointer();

Devuelve la posición actual del puntero del fichero

void seek( long pos );

Coloca el puntero del fichero en una posición determinada. La posición se da como

un desplazamiento en bytes desde el comienzo del fichero. La posición 0 marca el

comienzo de ese fichero.

long length();

Devuelve la longitud del fichero. La posición length () marca el final de ese fichero.

Actualización de Información

Se pueden utilizar ficheros de acceso aleatorio para añadir información a ficheros

existentes:

miRAFile = new RandomAccessFile( "/tmp/kk.log","rw" );

miRAFile.seek( miRAFile.length() );

// Cualquier write() que hagamos a partir de este punto del código

// añadirá información al fichero

Vamos a ver un pequeño ejemplo, Log.java, que añade una cadena a un fichero existente:

import java.io.*;

// Cada vez que ejecutemos este programita, se incorporara una nueva

// linea al fichero de log que se crea la primera vez que se ejecuta

//

class Log {

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

RandomAccessFile miRAFile;

String s = "Informacion a incorporarnTutorial de Javan";

// Abrimos el fichero de acceso aleatorio

miRAFile = new RandomAccessFile( "/tmp/java.log","rw" );

// Nos vamos al final del fichero

miRAFile.seek( miRAFile.leng

Creación de un objeto File

P á g i n a | 93

Programacion para Principiantes JAVA

Para crear un objeto File nuevo, se puede utilizar cualquiera de los tres constructores

siguientes:

File miFichero;

miFichero = new File( "/etc/kk" );o

miFichero = new File( "/etc","kk" );o File miDirectorio = new File( "/etc" );

miFichero = new File( miDirectorio,"kk" );

El constructor utilizado depende a menudo de otros objetos File necesarios para el acceso. Por

ejemplo, si sólo se utiliza un fichero en la aplicación, el primer constructor es el mejor. Si en

cambio, se utilizan muchos ficheros desde un mismo directorio, el segundo o tercer constructor

serán más cómodos. Y si el directorio o el fichero es una variable, el segundo constructor será el

más útil.

Comprobaciones y Utilidades

Una vez creado un objeto File, se puede utilizar uno de los siguientes métodos para reunir

información sobre el fichero:

Nombres de fichero

String getName()

String getPath()

String getAbsolutePath()

String getParent()

boolean renameTo( File nuevoNombre )

Comprobaciones

boolean exists()

boolean canWrite()

boolean canRead()

boolean isFile()

boolean isDirectory()

boolean isAbsolute()

Información general del fichero

long lastModified()

long length()

Utilidades de directorio

boolean mkdir()

String[] list()

Vamos a desarrollar una pequeña aplicación que muestra información sobre los ficheros

pasados como argumentos en la línea de comandos, InfoFichero.java:

P á g i n a | 94

Programación para Principiantes JAVA

import java.io.*;

class InfoFichero {

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

if( args.length > 0 )

{

for( int i=0; i < args.length; i++ )

{

File f = new File( args[i] );

System.out.println( "Nombre: "+f.getName() );

System.out.println( "Camino: "+f.getPath() );

if( f.exists() )

{

System.out.print( "Fichero existente " );

System.out.print( (f.canRead() ?

" y se puede Leer" : "" ) );

System.out.print( (f.canWrite() ?

" y se puese Escribir" : "" ) );

System.out.println( "." );

System.out.println( "La longitud del fichero son "+

f.length()+" bytes" );

}

else

System.out.println( "El fichero no existe." );

}

}

else

System.out.println( "Debe indicar un fichero." );

}

}

STREAMS DE ENTRADA

Hay muchas clases dedicadas a la obtención de entrada desde un fichero. Este es el

esquema de la jerarquía de clases de entrada por fichero:

Objetos FileInputStream

Los objetos FileInputStream típicamente representan ficheros de texto accedidos en orden secuencial,

byte a byte. Con FileInputStream, se puede elegir acceder a un byte, varios bytes o al fichero

completo.

Apertura de un FileInputStream Para abrir un FileInputStream sobre un fichero, se le da al constructor un String o un objeto

File:

P á g i n a | 95

Programacion para Principiantes JAVA

FileInputStream mi FicheroSt;

miFicheroSt = new FileInputStream( "/etc/kk" );

También se puede utilizar: File miFichero FileInputStream miFicheroSt;

miFichero = new File( "/etc/kk" );

miFicheroSt = new FileInputStream(

miFichero );

Lectura de un FileInputStream Una vez abierto el FileInputStream, se puede leer de él. El método read() tiene muchas

opciones:

int read();

Lee un byte y devuelve -1 al final del stream.

int read( byte b[] );

Llena todo el array, si es posible. Devuelve el número de bytes leídos o -1 si se

alcanzó el final del stream.

int read( byte b[],int offset,int longitud );

Lee longitud bytes en b comenzando por b[offset]. Devuelve el número de bytes

leídos o -1 si se alcanzó el final del stream.

Cierre de FileInputStream Cuando se termina con un fichero, existen dos opciones para cerrarlo: explícitamente, o

implícitamente cuando se recicla el objeto (el garbage collector se encarga de ello).

Para cerrarlo explícitamente, se utiliza el método close():

miFicheroSt.close();

Ejemplo: Visualización de un fichero Si la configuración de la seguridad de Java permite el acceso a ficheros, se puede ver el

contenido de un fichero en un objeto TextArea. El código siguiente contiene los elementos

necesarios para mostrar un fichero:

FileInputStream fis;

TextArea ta;

public void init() {

byte b[] = new byte[1024];

int i;

// El buffer de lectura se debe hacer lo suficientemente grande

// o esperar a saber el tamaño del fichero

String s;

try {

fis = new FileInputStream( "/etc/kk" );

} catch( FileNotFoundException e ) {

/* Hacer algo */

}

try {

i = fis.read( b );

} catch( IOException e ) {

P á g i n a | 96

Programación para Principiantes JAVA

/* Hacer algo */

}

s = new String( b,0 );

ta = new TextArea( s,5,40 );

add( ta );

}

Hemos desarrollado un ejemplo, Agenda.java, en el que partimos de un fichero agenda que dispone

de los datos que nosotros deseamos de nuestros amigos, como son: nombre, teléfono y dirección. Si

tecleamos un nombre, buscará en el fichero de datos si existe ese nombre y presentará la información

que se haya introducido. Para probar, intentar que aparezca la información de Pepe.

Objetos DataInputStream

Los objetos DataInputStream se comportan como los FileInputStream. Los streams de datos

pueden leer cualquiera de las variables de tipo nativo, como floats, ints o chars. Generalmente

se utilizan DataInputStream con ficheros binarios.

Apertura y cierre de DataInputStream Para abrir y cerrar un objeto DataInputStream, se utilizan los mismos métodos que

para FileInputStream: DataInputStream miDStream;

FileInputStream miFStream;

// Obtiene un controlador de fichero

miFStream = new FileInputStream "/etc/ejemplo.dbf" );

//Encadena un fichero de entrada de datos

miDStream = new DataInputStream( miFStream );

// Ahora se pueden utilizar los dos streams de entrada para

// acceder al fichero (si se quiere...)

miFStream.read( b );

i = miDStream.readInt();

// Cierra el fichero de datos explícitamente

//Siempre se cierra primero el fichero stream de mayor nivel

miDStream.close();

miFStream.close();

Lectura de Un DataInputStream

Al acceder a un fichero como DataInputStream, se pueden utilizar los mismos métodos read()

de los objetos FileInputStream. No obstante, también se tiene acceso a otros métodos

diseñados para leer cada uno de los tipos de datos:

byte readByte()

int readUnsignedByte()

short readShort()

int readUnsignedShort()

char readChar()

int readInt()

long readLong()

float readFloat()

P á g i n a | 97

Programacion para Principiantes JAVA

double readDouble()

String readLine()

Cada método leerá un objeto del tipo pedido.

Para el método String readLine (), se marca el final de la cadena con n, r, rn o con EOF.

Para leer un long, por ejemplo:

long numeroSerie;

...

numeroSerie = miDStream.readLong();

Streams de entrada de URLs: Además del acceso a ficheros, Java proporciona la posibilidad de

acceder a URLs como una forma de acceder a objetos a través de la red. Se utiliza implícitamente un

objeto URL al acceder a sonidos e imágenes, con el método getDocumentBase () en los applets:

String imagenFich = new String( "imagenes/pepe.gif" );

imagenes[0] = getImage( getDocumentBase(),imagenFich );

No obstante, se puede proporcionar directamente un URL, si se quiere:

URL imagenSrc;

imagenSrc = new URL( "http://enterprise.com/~info" );

imagenes[0] = getImage( imagenSrc,"imagenes/pepe.gif" );

Apertura de un Stream de entrada de URL También se puede abrir un stream de entrada a partir de un URL. Por ejemplo, se puede

utilizar un fichero de datos para un applet:

ImputStream is;

byte buffer[] = new byte[24];

is = new URL( getDocumentBase(),datos).openStream();

Ahora se puede utilizar is para leer información de la misma forma que se hace con un

objeto FileInputStream:

is.read( buffer,0,buffer.length );

NOTA: Debe tenerse muy en cuenta que algunos usuarios pueden haber configurado la

seguridad de sus navegadores para que los applets no accedan a ficheros.

STREAMS DE SALIDA

La contrapartida necesaria de la lectura de datos es la escritura de datos. Como con los

Stream de entrada, las clases de salida están ordenadas jerárquicamente:

P á g i n a | 98

Programación para Principiantes JAVA

Examinaremos las clases FileOutputStream y DataOutputStream para complementar los streams de

entrada que se han visto. En los ficheros fuente del directorio $JAVA_HOME/src/java/io se puede

ver el uso y métodos de estas clases, así como de los streams de entrada ($JAVA_HOME es el

directorio donde se haya instalado el Java Development Kit, en sistemas UNIX).

Objetos FileOutputStream Los objetos FileOutputStream son útiles para la escritura de ficheros de texto. Como con

los ficheros de entrada, primero se necesita abrir el fichero para luego escribir en él.

Apertura de un FileOutputStream Para abrir un objeto FileOutputStream, se tienen las mismas posibilidades que para abrir un

fichero stream de entrada. Se le da al constructor un String o un objeto File.

FileOutputStream miFicheroSt;

MiFicheroSt = new FileOutputStream (“/etc/kk”);

Como con los streams de entrada, también se puede utilizar:

File miFichero FileOutputStream miFicheroSt; File miFichero FileOutputStream miFicheroSt;

MiFichero = new File (“/etc/kk”);

MiFicheroSt = new FileOutputStream (miFichero);

Escritura en un FileOutputStream: Una vez abierto el fichero, se pueden escribir bytes de

datos utilizando el método write (). Como con el método read () de los streams de entrada,

tenemos tres posibilidades:

void write( int b );

Escribe un byte.

void write( byte b[] );

Escribe todo el array, si es posible.

void write( byte b[],int offset,int longitud );

Escribe longitud bytes en b comenzando por b [offset].

Cierre de FileOutputStream Cerrar un stream de salida es similar a cerrar streams de entrada. Se puede utilizar el

método explícito: miFicheroSt.close ();

O, se puede dejar que el sistema cierre el fichero cuando se recicle miFicheroSt.

P á g i n a | 99

Programacion para Principiantes JAVA

Ejemplo: Almacenamiento de Información

Este programa, Telefonos.java, pregunta al usuario una lista de nombres y números de teléfono. Cada

nombre y número se añade a un fichero situado en una localización fija. Para indicar que se ha

introducido toda la lista, el usuario específica "Fin" ante la solicitud de entrada del nombre. Una vez

que el usuario ha terminado de teclear la lista, el programa creará un fichero de salida que se mostrará

en pantalla o se imprimirá. Por ejemplo:

95-4751232, Juanito

564878, Luisa

123456, Pepe

347698, Antonio

91-3547621, María

El código fuente del programa es el siguiente:

import java.io.*;

class Telefonos {

static FileOutputStream fos;

public static final int longLinea = 81;

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

byte tfno[] = new byte[longLinea];

byte nombre[] = new byte[longLinea];

fos = new FileOutputStream( "telefono.dat" );

while( true )

{

System.err.println( "Teclee un nombre ('Fin' termina)" );

leeLinea( nombre );

if( "fin".equalsIgnoreCase( new String( nombre,0,0,3 ) ) )

break;

System.err.println( "Teclee el numero de telefono" );

leeLinea( tfno );

for( int i=0; tfno[i] != 0; i++ )

fos.write( tfno[i] );

fos.write( ',' );

for( int i=0; nombre[i] != 0; i++ )

fos.write( nombre[i] );

fos.write( 'n' );

}

fos.close();

}

private static void leeLinea( byte linea[] ) throws IOException {

int b = 0;

int i = 0;

while( (i < ( longLinea-1) ) &&

( ( b = System.in.read() ) != 'n' ) )

linea[i++] = (byte)b;

linea[i] = (byte)0;

}

P á g i n a | 100

Programación para Principiantes JAVA

Conclusion En este manual se busco que el usuario conociera todo lo que es el Lenguaje de

programacion de JAVA, y esto se aprendio conociendo primero una breve

introduccion de lo que es JAVA, conocimos el Origen de JAVA, las

características de este lenguaje de Programacion JAVA estos aspectos son

breves para que el usuario aprenda lo que es JAVA. También se aprendio como

es que el usuario puede instalar JSKD = JAVA para su maquina. También con

este manual el usuario aprendio que la estructuración de un programa para JAVA

consta de Editar el Programa, Compilarlo, Ejecutarlo y Depurarlo.

En este manual conocimos lo que son los temas de Clases, Herencia,

Constructores, modificadores de Acceso,Objetos, Clases, tipos de clases,

Control de Flujo o Sentencias de Control, Estructuras Selectivas: if, else, etc;

estructuras Iterativas, Variables, tipos de variables, Operadores,Comentarios

y Literales, Manejo de Excepciones, Metodos(Constructores), Arrays,

Referencias y Listas,Graficos en JAVA, Packages, Hilos, Interfaces, y como

cada uno de estos aspectos nos ayudan al momento de realizar un programa y

esto se busca que lo aprendael usuario buscando que el conosca la definición,

como declararla, como identificando a cada uno ubicando sus diferencias, y esto

lo aprendimos también por medio de ver ejemplos y algunos de estos ejemplos

los aprendimos a explicar mejor ya que estos tenían una breve explicacion, etc.

P á g i n a | 101

Programacion para Principiantes JAVA

Bibliografía

Autor: Alvin Steve Padilla Meza

Programacion para Principiantes JAVA

Lugar: Mazatenango, Suchitepequez

Editorial: A.S.P.M

Fecha: 26/11/2015

Edición 2016