View
63
Download
9
Category
Preview:
DESCRIPTION
manual
Citation preview
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
Recommended