Manualjava STC

JAVA BSICO
Av. Juan de Dios Btiz s/n esq. Miguel Othn de Mendizbal,

Col. Nueva Industrial Vallejo, Del. Gustavo A. Madero.C.P 07738, Mxico D.F.
Tel.5729-6000 Extensiones: 56529, 56596,
ddep@cic.ipn.mx ; www.cursos.cic.ipn.mx.
Pgina 1 de 267
Av. Juan de Dios Btiz s/n esq. Miguel Othn de Mendizbal, Col. Nueva Industrial Vallejo, Delegacin Gustavo A. Madero.
C.P 07738, Mxico D.F. Tel.5729-6000 Extensiones: 56529, 56596, email: ddep@cic.ipn.mx ; www.cursos.cic.ipn.mx.
JAVA BSICO
Pgina 2 de 267
JAVA BSICO
Contenido
1. INTRODUCCION A LA TECNOLOGIA Y PLATAFORMA JAVA ...................... 6
1.1 Historia de Java ............................................................................................... 6
1.2 Panorama actual y tipos de ediciones del lenguaje.................................. 8
1.2.1Caractersticas del Lenguaje de programacin Java .......................... 9
1.3 Instalacin de Java SE .............................................................................. 15
1.4 Elementos que integran JAVA SE ............................................................ 23
1.5 Variables de ambiente .............................................................................. 28
1.6 Prueba de instalacin ................................................................................ 31
1.7 Obtencin del IDE NetBeans 6.0 ............................................................... 36
1.8 Desarrollo de una aplicacin Java con el IDE NetBeans 6.0 .................. 39
1.9 Tipos de programas en Java .................................................................... 46
1.10 Estructura de un programa de tipo aplicacin en Java ........................ 48
1.11 Como se crean aplicaciones Java con JDK .......................................... 53
1.12 Como se crean applets Java con SDK ................................................... 55
2. ELEMENTOS BSICOS DEL LENGUAJE JAVA ............................................ 57
2.1 Comentarios ............................................................................................... 57
2.1.1 Comentarios de tipo del C y C++ ........................................................ 58
2.1.2 Comentarios para el javadoc y sus etiquetas principales ............... 59
2.2 Identificadores........................................................................................... 63
2.3 Palabras reservadas .................................................................................. 68
2.4 Tipos de datos en Java ............................................................................. 69
2.5 Literales ...................................................................................................... 71
2.6 Secuencias de escape de carcter ........................................................... 73
2.7 Sentencias y expresiones ......................................................................... 74
2.7.1 De expresin de asignacin ............................................................... 80
2.7.2 De incremento o decremento ............................................................. 81
2.7.3 De invocacin a un mtodo ................................................................ 85
Pgina 3 de 267
JAVA BSICO
2.7.4 De creacin de un objeto .................................................................... 86

2.7.5 De control de flujo. .............................................................................. 86
3. CLASES Y OBJETOS ...................................................................................... 87
3.1 Definicin de clase Estructura de una clase ........................................... 87
3.1.1 Sentencia Packaged ............................................................................ 89
3.1.2 Sentencia import .................................................................................. 90
3.2 Miembros de una clase. ............................................................................. 91
3.2.1 Campos (fields) .................................................................................... 91
3.2.2 Mtodos (Methods) .............................................................................. 93
3.2.3 Constructores ( Constructors )........................................................... 95
3.4 Proteccin de miembros. .......................................................................... 97
3.5 Constructores y creacin de objetos ....................................................... 98
3.6 Niveles de acceso para una clase .......................................................... 100
3.7 Niveles de acceso para un miembro ...................................................... 101
3.7.1 Acceso privado .................................................................................. 103
3.7.2 Acceso protegido............................................................................... 103
3.7.3 Acceso de paquete ............................................................................ 103
3.7.4 Acceso pblico .................................................................................. 104
3.8 Recursividad............................................................................................. 105
3.9 Mtodos sobrecargados .......................................................................... 106
4. PAQUETES..................................................................................................... 109
4.1 Definicin y uso de paquetes.................................................................. 109
4.2 Uso del API de programacin. ................................................................ 115
4.3 Paquete java.lang ..................................................................................... 116
4.3.1 Clase String ........................................................................................ 118
4.3.2 Clase StringBuffer ............................................................................. 120
4.3.3 Clase Math .......................................................................................... 124
4.4 Paquete java.util ....................................................................................... 126
4.4.1 Arrays ..................................................................................................... 126
4.4.2 Creacin y uso de arrays ..................................................................... 127
Pgina 4 de 267
JAVA BSICO
4.4.3 Arrays multidimensionales ............................................................... 132

4.4.4 Clase Arrays. ...................................................................................... 134
4.5 Paquete java.io ......................................................................................... 142
4.5.1 Introduccin a los flujos ................................................................... 143
4.5.2 Flujos Estndar .................................................................................. 144
5. HERENCIA Y POLIFORMISMO .................................................................... 148
5.1 Herencia .................................................................................................... 148
5.2 Uso de la palabra reservada Extends .................................................... 155
5.3 Uso de la palabra reservada This ........................................................... 156
5.4 Uso de la palabra reservada Super ........................................................ 157
5.5
Creacin y destruccin de objetos en una jerarqua de herencia ... 160
5.6 Redefinicin de miembros ...................................................................... 161

5.7 Clases finales ........................................................................................... 162
5.8 Clases abstractas..................................................................................... 162
5.9 Polimorfismo ............................................................................................ 165
5.10 Interfaces ................................................................................................ 166
5.11 Clases internas....................................................................................... 167
5.12 Clases annimas .................................................................................... 169
5.13 Clases interfaces ................................................................................... 171
5.14 Implementacin interfaces .................................................................... 172
6. MANEJO DE EXCEPCIONES ........................................................................ 173
6.1 Modelo del manejo de excepciones ....................................................... 173
6.2 Clausula Finally ........................................................................................ 179
6.3 Encadenamiento de excepciones ........................................................... 180
6.4 Generacin de excepciones propias ...................................................... 183
PRESENTACIONES ........................................................................................... 186
PRACTICAS ....................................................................................................... 208
Pgina 5 de 267
JAVA BSICO
1. INTRODUCCION A LA TECNOLOGIA Y PLATAFORMA JAVA

1.1 Historia de Java
En enero de 1991 la empresa Sun Microsystems comenz un proyecto con el
nombre de Green. El propsito del proyecto Green era descubrir un modo de
controlar consolas de televisin, esas cajas para acceder a la televisin por cable.
Como el hardware de los dispositivos para el consumidor siempre estaba
cambiando, James Gosling, el "padre del Java. Ver Figura 1. Pens que C++ no
era lo ms apropiado para dicho trabajo. Como resultado, se cre el lenguaje
llamado Oak en honor a un roble que se vea desde la ventana de su oficina. Este
lenguaje era menos susceptible a errores y no bloqueaba todo el sistema. Se
ejecutaba inicialmente en un dispositivo de tecnologa Hammer llamado *7 (star7).
Haciendo piruetas por toda la pantalla tctil estaba ese pequeo personaje digital
llamado Duke, un asistente que poda aparecer y realizar varias tareas y que ms
tarde se convertira en la mascota de Java.
Figura 1. James Gosling y su mascota en la camiseta Duke.
Oak se us para solicitar un proyecto sobre un sistema operativo para consolas de

televisin. La solicitud no prosper y Sun rechaz una oferta de compra de Trip Hawkins
(que era el jefe oficial ejecutivo de Gamemaker / 3DO), de modo que Sun tena ese
Pgina 6 de 267
JAVA BSICO
desecho y no saba qu hacer con l. Por suerte, la revolucin de Internet haba

comenzado con el lanzamiento de Mosaic, el predecesor del navegador Web Netscape
Navigator. En 1994 se le busca una nueva utilidad a Oak para la Web y se crea el
navegador llamado WebRunner (anteriormente renombrado HotJava) para exhibir
la reciente tecnologa de lo que terminara convirtindose en Java.
Por cierto, Oak se le cambio el nombre a Java, porque ya exista un lenguaje de
programacin denominado Oak, entonces, en una junta de emergencia donde se
tena que decidir un nuevo nombre, y en esa junta estaban tomando caf.
En algunas partes de EUA se denomina Java a un caf de buena calidad,
entonces James Gosling y sus colegas decidieron darle ese nombre.
Para hacer pblico el lenguaje, en la conferencia SunWorld, John Gage de Sun y
Marc Andreesen de Netscape presentaron Java al mundo. Netscape se
comprometi a incorporar Java en la siguiente versin de su navegador y al final
del ao empresas como IBM, Oracle, Borland, Adobe, Macromedia, Lotus,
Spyglass e Intuit haban incorporando Java a sus productos. Incluso Microsoft
autoriz Java, comprometindose a incorporar Java a sus productos, sistemas
operativos y herramientas de desarrollo.
La versin original de Java era tan pequea que caba en un disquete. El
intrprete del ncleo tena casi 100 Kb. La biblioteca matemtica sumaba otros 20
Kb. El cdigo para la integracin con bibliotecas C eran otros 50 Kb. La mayora
de las bibliotecas de clase caban en 375 Kb, dejando slo las bibliotecas de
grficos especficas de plataforma que variaban en tamao. En conjunto Java
solamente tena alrededor de 1 Mb de ROM y 1 Mb de RAM.
Pgina 7 de 267
JAVA BSICO
1.2 Panorama actual y tipos de ediciones del lenguaje

Actualmente Java se utiliza en un amplio abanico de posibilidades y casi cualquier
cosa que se puede hacer en cualquier lenguaje se puede hacer tambin en Java y
muchas veces con grandes ventajas. Con Java podemos programar pginas web
dinmicas, con accesos a bases de datos, utilizando XML, con cualquier tipo de
conexin de red entre cualquier sistema.
Hoy en da, puede encontrar la tecnologa Java en redes y dispositivos que
comprenden desde Internet y superordenadores cientficos hasta porttiles y
telfonos mviles; desde simuladores de mercado en Wall Street hasta juegos de
uso domstico y tarjetas de crdito: java est en todas partes
A Sun se le ocurri hablar de diferentes ediciones de Java. Bsicamente dividi la
tecnologa en tres ediciones:
Java Standard Edition o Java SE
Esto da el nombre a la distribucin normal de Java.
Java Enterprise Edition o Java EE
Es la edicin estndar anterior, pero con el agregado de distintas tecnologas

asociadas a la creacin de aplicaciones consideradas "empresariales" .Todas
estas tecnologas estn disponibles por separado, as que da lo mismo usar esto o
bajar el Java normal y simplemente bajar las APIs extra que uno necesite. Un uso
interesante, sin embargo, de esta denominacin es poder hacer referencia a una
coleccin de nmeros de versin, ya que estos nmeros son distintos para cada
API. Es decir que hablando de una versin en particular de la plataforma "Java
EE" uno est siendo claro acerca de qu versiones de Java Mail, servelets y EJB
habla.
Pgina 8 de 267
JAVA BSICO
1.2.1Caractersticas del Lenguaje de programacin Java

De acuerdo con los objetivos del diseo de los creadores de Java este cumple
con ser "un lenguaje de programacin sencillo, orientado a objetos, distribuido,
interpretado, robusto, seguro, de arquitectura neutral, porttil, de gran rendimiento,
multitarea y dinmico".
De acuerdo a stos objetivos, podemos ver lo que tenan en mente sus creadores,
y que en la actualidad pueden an aplicarse.
Simple: Java es simple porque elimina la complejidad de los lenguajes de
programacin como el C y el C++. Java incorpora nuevas caractersticas como un
recolector automtico de elementos no utilizados y elimina aspectos confusos y
poco utilizados del C++ como la sobrecarga de operadores. Tambin por
supuesto, elimina el manejo difcil y complejo de los apuntadores y su aritmtica
de apuntadores.
Incorpora un conjunto de caractersticas ya utilizadas en la historia de los
lenguajes de programacin como son:
Las clases que vienen de C++ y SmallTalk pero limitadas a herencia simple.
Las interfaces que proceden de Objetive-C y proporcionan a Java herencia
mltiple de interfaces.
Los paquetes de clases vienen de Modula
La concurrencia y la multitarea que estaban ya en varios lenguajes, Java lo
incorpora.
El control de excepciones del Modula-3
Vnculos dinmicos y la recogida automtica de elementos no utilizados
provienen del Lisp.
Orientado a Objetos
Pgina 9 de 267
JAVA BSICO
Java es un lenguaje Orientado a Objetos porque ste paradigma de la

programacin es una forma de desarrollar software describiendo los problemas
mediante el uso de elementos u objetos del espacio del problema y no mediante
un conjunto de pasos secuenciales que se ejecutan en la computadora. Un buen
diseo Orientado a Objetos produce componentes reutilizables, extensibles y
sostenibles.
Estos componentes de software son lo bastante flexibles para controlar los
cambios que se puedan producir en el ambiente a lo largo del tiempo, porque su
trabajo principal es el de intercambiar mensajes entre s.
Los API Core de Java son una coleccin de stos componentes, previamente
creados, denominados bibliotecas de clases. El programador no necesita crear
todo de nuevo, simplemente utiliza stas bibliotecas estndar que han ido
evolucionando a lo largo del tiempo, obteniendo ms componentes con una nueva
versin o liberacin de Java.
Distribuido: Java es distribuido porque adems de que puede acceder a objetos
distribuidos en distintas computadoras u equipos mediante protocolos estndar
basados en TCP/IP como HTTP, con las ltimas versiones de Java, se pueden
invocar mtodos en un equipo remoto tan fcil e invisiblemente como podra
hacerse en su mismo equipo o espacio de ejecucin mediante protocolos
comunes como CORBA (que es una arquitectura intermediaria para solicitar
objetos comunes) y RMI (que son invocaciones a mtodos remotos), adems de
los recin incorporados servicios Web.
Para cada protocolo de comunicacin, Java se encarga de toda la conversin y
transporte de manera automtica.
Pgina 10 de 267
JAVA BSICO
Interpretado: Java es un lenguaje interpretado, porque sus cdigos de programas

fuente en lugar de ser compilados y traducidos en ejecutables nativos, son
traducidos en cdigos de bytes (bytecode) no asociados a una plataforma
especfica.
Este bytecode es transferido a cualquier plataforma que tenga Java Runtime
Environment (JRE), y que consiste en una Mquina Virtual de Java (JVM) y de
ste modo pueden ejecutarse sin volver a compilarlos (Compile una vez y
Ejectelo n veces).
Puede pensarse que Java es lento, sin embargo los cdigos neutrales de bytes
contienen informacin adicional que puede utilizarse para optimizar la ejecucin en
tiempo de ejecucin, segn decisiones que no pueden realizarse en tiempo de
compilacin.
Robusto: La robustez es la fiabilidad de un programa. Java es fiable o robusto
porque incorpora las siguientes caractersticas:
Es un lenguaje "tipeado" o basado en tipos. El compilador y cargador de clases
aseguran la correccin de todas las llamadas de mtodo, lo que evita las
diferencias implcitas entre tipos y las incompatibilidades entre versiones.
No tiene apuntadores o punteros. En Java hay referencias en lugar de
apuntadores, y no se pueden mover una referencia para manipular directamente
espacios de memoria. Esto evita que la memoria se corrompa accidentalmente,
como por ejemplo pasarse el final de una pila, etc.
Java tiene un colector automtico de basura (garbage collector). Los
programadores pueden olvidarse de liberar memoria y con Java ya no tienen que
preocuparse por decidir las partes de memoria que deben liberarse ya que el
colector lo hace automticamente.
En Java se fomenta el uso de interfaces en lugar de clases. Las interfaces definen
un conjunto de comportamientos (mtodos). En lugar de pasar clases, se pasan
Pgina 11 de 267
JAVA BSICO
interfaces, ocultando as las implementaciones. Si la implementacin cambia como

sucede a menudo, y no se tiene la nueva clase que implementa la vieja interfaz,
todo lo dems funcionar perfectamente.
Seguro: El sistema de Java tiene ciertas polticas que evitan se puedan codificar
virus con este lenguaje. Existen muchas restricciones, especialmente para los
applets, que limitan lo que se puede y no puede hacer con los recursos crticos de
una computadora y poner los sistemas en riesgo.
Java no permite el manejo de apuntadores, y evita que un programa malicioso
corrompa los espacios de memoria.
En cuanto a la ejecucin de programas Java integra funciones de seguridad: el
verificador de cdigo de bit, el cargador de clases y el gestor de seguridad. Esto
garantiza que el cdigo no seguro realice operaciones seguras, como leer el disco
duro. Otro aspecto de la seguridad recientemente incorporado a Java tiene que
ver con la autentificacin, autorizacin y encriptacin para proteger la privacidad y
asegurar la integridad de los datos.
De arquitectura neutral: Para establecer Java como parte integral de la Word
Wide Web, el compilador Java compila su cdigo a un archivo objeto de formato
independiente de la arquitectura de la mquina en que se ejecutar. Cualquier
mquina que tenga el sistema de ejecucin (JRE) puede ejecutar ese cdigo
objeto, sin importar en modo alguno la mquina 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 ya hay grupos de desarrollo trabajando
en la portabilidad a otras plataformas.
Si una compaa desarrolla nuevo hardware, no tiene que desechar sus
inversiones en software, sino que slo debe colocar un JRE en la nueva
plataforma. Tambin si una empresa desarrolla hardware completamente nuevo o
un nuevo sistema operativo, no tienen que comenzar desde cero sin ningn
Pgina 12 de 267
JAVA BSICO
software para el producto, con tan solo agregar el JRE, a la plataforma recin
diseada puede ejecutar todos los programas de Java existentes.
Porttil: Como el cdigo compilado de Java (conocido como byte code) o que es
un cdigo de bytes de plataforma neutral, es interpretado, y un programa
compilado de Java puede ser utilizado por cualquier computadora que tenga
implementado el interprete de Java (JRE). Esto ltimo hace honor a la promesa de
sus desarrolladores sintetizado en las frases "Escribir una vez, Ejecutarse en
cualquier sitio" (EE).
De esta manera, es posible confiarse en que todas las implementaciones
numricas en tamao, orden de byte y manipulacin son generales o neutrales, y
estas
estn
definidas
en
la
documentacin
de
Java
en
(http://java.sun.com/docs/books/jls/) Language Specification.

Alto rendimiento: Puede suponerse que un cdigo interpretado y de alto
rendimiento es una contradiccin. No obstante, los cdigos de bytes de la
plataforma neutral realmente pueden convertirse en tiempo de ejecucin en cdigo
de mquina especfico de la CPU, ejecutndose casi tan rpidamente (es posible
que ms) como cdigo compilado nativo de C y C++.
En adicin a esto hay dos herramientas de traduccin incluidas en Java que lo
hacen automticamente: La herramienta de 1ra. generacin recibe el nombre de
compilador justo a tiempo (just in time) (JIT). La otra herramienta de 2da
generacin de Sun se denomina HotSpot y el compilador JIT hacen lo mismo:
Traducir en tiempo de ejecucin al conjunto de instrucciones nativas.
Sin embargo, HotSpot tambin supervisa el cdigo mientras se ejecuta y optimiza
la velocidad en los bloques ms frecuentemente ejecutados, en lugar de en todo el
cdigo.
Pgina 13 de 267
JAVA BSICO
Multitarea: Java es un lenguaje que soporta mltiples threads (hilos, procesos,

tareas), esto es, Java es un lenguaje que puede ejecutar diferentes lneas de
cdigo al mismo tiempo.
Los programas multitarea comparten memoria y deben tener comunicacin entre
los subprocesos. Java tiene bibliotecas estndar con muchos recursos para
ayudar al programador en este proceso de comunicacin, asegurando la
seguridad de los subprocesos.
Lenguaje Dinmico: Java es un lenguaje dinmico porque continuamente est
evolucionando, esto es, sus bibliotecas de clases e interfaces estn cambiando, y
mejorando continuamente.
Podra pensarse que los programas que hacen uso de ellas ya no funcionaran,
pero no es as. Los primeros cdigos de bytes de plataforma neutral seguirn
funcionando despus de que aparezcan nuevas bibliotecas, ya sea porque Sun
presente una nueva versin de Java o porque alguna otra compaa cree alguna
biblioteca.
Mientras las partes de la biblioteca empleadas no desaparezcan, los programas
seguirn funcionando, incluso aunque se agreguen nuevos elementos a las
bibliotecas. Adems gracias a la preferencia de Java por las interfaces sobre las
clases, como se mencion en la caracterstica de robustez.
Pgina 14 de 267
JAVA BSICO
1.3 Instalacin de Java SE
El alumno obtendr el software gratuito (freeware) Java SDK 6 del sitio de Sunsoft,
transferir los archivos necesarios, los instalar y comprobar su instalacin
ejecutando un pequeo programa de Java.
Obtener JDK 1.6 y el NetBeans 6.9 (o la versin ms reciente)
La versin 1.6.X_XX de JDK (Kit de Desarrollo de Java) est disponible
actualmente para las siguientes plataformas:
Windows
Linux
Solaris
Mac OS
Descargue el SDK para estas plataformas del sitio Web de Sun, en la siguiente
direccin http://java.sun.com En esta otra direccin podrs bajarte la ltima versin
del JDK:
http://java.sun.com/javase/downloads/index.jsp
Elegir la versin ms actual del JDK 1.6.X_XX. Peridicamente, Sun publica
reparaciones de fallas que agregan un nuevo dgito al nmero, como cuando a
Java 1.1 le sigue 1.1.1, 1.1.2, 1.2.0, 1.3.0, 1.4.0, 1.4.0_01,, 1.6.0_01 etctera.
Obtener la versin ms reciente ( 4 de junio 2010 ) del JDK 1.6.0_20 disponible
para su plataforma.
Los requerimientos JDK 6 Actualizacin 20 con el NetBeans 6.9 (o la versin ms
reciente)
Pgina 15 de 267
JAVA BSICO
Estos requerimientos estn publicados en:

http://java.sun.com/javase/6/webnotes/install/system-configurations.html
Ver Figura 1-2.
Figura 1-2. Los requerimientos estn publicados de acuerdo a la plataforma en que se va a instalar
el JDK 6.
Pgina 16 de 267
JAVA BSICO
El JDK es un conjunto de herramientas y utileras que en resumen son:

Javac El compilador Java por excelencia, un compilador de lnea de comandos,
que te permitir crear tus programas y Applets en Java.
Appletviewer Un visualizador de Applets para no tener que cargarlos en un
navegador.
Java El intrprete que te permitir ejecutar tus aplicaciones creadas en Java.
javadoc El documentador de Java
jdb El depurador de Java
Pgina 17 de 267
JAVA BSICO
El entorno de programacin integrado ms popular es el NetBeans y la versin

ms reciente (4 de junio 2010) es la 6.9.
Este software est disponible en
http://www.netbeans.org ver Figura 1-3.
Figura 1-3. Sitio web para descargar la versin NetBeans IDE 6.9
Pgina 18 de 267
JAVA BSICO
Los requerimientos para instalar el NetBeans IDE 6.9 estn publicados en

http://netbeans.org/community/releases/69/install.html#requiredsoftware
ver Figura 1-4:
Estos requerimientos varan de acuerdo a lo que se desea desarrollar con el IDE
NetBeans ya que no solo sirve para desarrollos Java sino tambin para otras
tecnologas.
Figura 1-4. Pgina web donde se ven los requerimientos del NetBeans y otra documentacin
tcnica del NetBeans.
Pgina 19 de 267
JAVA BSICO
Instalacin de JDK 6 Actualizacin 20 con el NetBeans 6.9 (o la versin ms

reciente)
Para Instalar el Java 2 JDK 6 en Windows haga doble clic en el archivo de
instalacin o usar el comando Start | Run (Inicio | Ejecutar) del men de inicio de
Windows para encontrar y ejecutar el archivo. Al terminar la instalacin el rbol de
carpetas y subcarpetas se ver similar a la siguiente, ver Figura 1-5
Figura 1-5. rbol de directorios o carpetas de instalacin del JDK 6
Pgina 20 de 267
JAVA BSICO
En el cuadro de dilogo que le pregunta si desea instalar el JDK, SE 1.6.0_20, se

despliega el Asistente de configuracin del JDK 6 ver Figura 1-6.
Figura 1-6. Cuadro de dialogo de configuracin de la instalacin del JDK 6
El asistente instalar los siguientes componentes del JDK 6:

Herramientas de desarrollo Son los programas ejecutables necesarios para
crear, compilar y verificar el funcionamiento de sus proyectos de Java.
Demos y ejemplos Archivos usados como ejemplos de las capacidades del
JDK 6.
Cdigo Fuente. Al ser un software libre usted puede disponer de las fuentes.
Java DB. Es un motor de base de datos de Apache Foundation conocida
como Derby.
Pgina 21 de 267
JAVA BSICO
Por default el asistente le creara la siguiente ruta

C:\Archivos de programa\Java\jdk1.6.0_20\
Para la instalacin de los componentes previamente seleccionados.
Despus de haber instalado JDK, notar que hay varios archivos instalados en el
subdirectorio C:\Archivos de programa\Java\jdk1.6.0_20\lib
la mayora con
extensin .jar. Aunque son archivos.jar, no debe descomprimirlos. El JDK puede

leer los archivos .jar en su formato de archivo en este directorio.
Se escoger la unidad destino donde se va a instalar el software de Java 2 SE JDK
6 dndole clic al botn Browse...En este caso se opto por la ruta default, y es por
eso que en la figura 1-6 el rbol de carpetas y subcarpetas de la unidad C:
muestra que el directorio para la variable de ambiente JAVAHOME es C:\Archivos
de programa\Java\jdk1.6.0_20\.
Pgina 22 de 267
JAVA BSICO
1.4 Elementos que integran JAVA SE

Java Enterprise Edition: Conjunto de estndares y APIs con el objetivo de
proveer servicios orientados a desarrollar aplicaciones empresariales con las
siguientes caractersticas:
Potables
De fcil mantenimiento
Distribuidos en varios contenedores
Escalables
Seguras
Robustas
Pgina 23 de 267
JAVA BSICO
Plataforma de desarrollo (Windows, Linux, Mac OS X, o cualquier otro):

necesitamos saber cul es la arquitectura Hardware de nuestro ordenador y que
sistema operativo utilizamos para poder instalar la MVJ (Maquina Virtual Java) que
corresponda a nuestra plataforma.
IDE entorno de desarrollo (NetBeans o cualquier otro): en el mercado hay
muchos entornos de desarrollo disponibles y de muy alta calidad.
Utilizaremos el IDE NetBeans que es un entorno de desarrollo Open Source
escrito en Java y auspiciado por Sun Microsystems.
MVJ (Maquina Virtual de Java): La MVJ no existe como tal fsicamente. Es en
realidad un conjunto de comandos y programas que se ejecutan en un
direccionamiento de memoria separado del resto de procesos que se puedan estar
ejecutando en paralelo en ese momento en nuestro ordenador.
Cdigo Java: el cdigo fuente de las aplicaciones Java que creamos est
separado por diferentes ficheros con extensin .java
Las clases estn contenidas en los archivos con extensin .java
Cada clase tiene su propio archivo
Compilacin: al poco tiempo de aparecer en escena el lenguaje Java, las

aplicaciones se escriban en un procesador de texto y la compilacin del cdigo
fuente se realizaba desde una consola de comandos propia del sistema operativo
que se estaba utilizando. Se tena que escribir en la lnea de comando el comando
javac seguido de las clases que queras compilar.
Debido a que el IDE de NetBeans est situado en una capa por encima de la MVJ
no nos hace falta una consola de comandos para poder compilar las clases java.
Pgina 24 de 267
JAVA BSICO
En este caso simplemente se hace clic sobre un botn de compilacin, esta accin
desencadena que el ID invoque de forma transparente el comando javac que est
incluido en la MVJ para compilar dichas clases.
Cdigo Byte: el resultado de la compilacin genera archivos con extensin .class,
estos archivos contienen cdigo byte, este cdigo byte es universal, es decir no
importa con que plataforma estemos desarrollando que el cdigo de bajo nivel es
100% compatible con la MVJ
Interpretacin: a diferencia de otros lenguajes que sus aplicaciones se arrancan
directamente ejecutando un archivo con extensin normalmente .exe, para
ejecutar una aplicacin java desde la lnea de comandos se tiene que ejecutar
primeramente el comando java; este comando crea un entorno de ejecucin java
en memoria y transforma el cdigo byte de los archivos con extensin .class en
cdigo de bajo nivel propio de cada plataforma, en este caso el IDE de NetBeans
tiene un botn, que ya veremos en su momento para interpretar el cdigo byte y
ejecutar la aplicacin para que el usuario final la pueda utilizar.
Libreras estndar Java: sera impensable que todo el cdigo de una aplicacin
estuviera escrito por nosotros, java tiene una nutrida API (Application Program
Interface) que contiene libreras estndar Java, en el proceso de interpretacin el
interpretador Java invoca las Clases de la mencionada librera estndar Java y las
interpreta.
Las aplicaciones Java desde sus principios siempre se han ganado la mala fama
de ser ms lentas que otras aplicaciones convencionales. Pero hay que decir que
el tiempo corre a favor de Java debido a que los ordenadores cada vez tienen
frecuencias de reloj ms rpidas y capacidades de memoria cada vez ms
grandes tampoco se descarta que en un futuro la MVJ est implementada
directamente en un procesador. Esta es una carta que se guarda Sun y que Intel
Pgina 25 de 267
JAVA BSICO
tambin la tiene en mente. Podrn surgir placas base compartiendo procesadores

Pentium con procesadores MVJ o procesadores Risk con procesadores MVJ.
Ante esta perspectiva a partir de la versin 1.2 el JDK (Java Development Kit) se
especializa en 3 reas diferenciadas:
Java SE (Estndar Edition):
Contiene las APIS bsicas del lenguaje Java
Contiene el Java Runtime Environment (JRE)
Java EE (Enterprice Edition):

Especializada para crear aplicaciones Cliente/Servidor WEB
JAVA ME (Micro Edition):

Especializada para micro-dispositivos como telfonos Mviles y PDAs
A medida que vayamos progresando en el curso se irn desvelando otras
caractersticas relevantes que explicaran la razn por la cual las diferentes
versiones se han ido sucediendo.
Escribe una vez y ejecuta en cualquier plataforma

Cuando tenemos que instalar una aplicacin creada por nosotros mismos en casa
de un cliente, este tiene que ser instalado en su ordenador de produccin la MVJ
correspondiente en su plataforma.
La MVJ se puede descargar de internet como un JDK (Java Development Kit) o un
JRE (Java Runtime Environment).
JRE: en el caso que solo queramos ejecutar las aplicaciones en el ordenador de
produccin.
Pgina 26 de 267
JAVA BSICO
JDK: en el caso de que adems de ejecutar las aplicaciones en el ordenador de

produccin tambin queramos compilar en el citado ordenador de produccin,
cuando se instala un jdk el wizard o asistente tambin instala automticamente su
correspondiente JRE.
As pues este es el esquema del ordenador de produccin que ejecutara nuestras
aplicaciones Java en casa de un cliente.
El quid de la cuestin est en tener instalada la MVJ propia de cada plataforma

para poder conseguir la magia de Java "escribe una vez y ejecuta en cualquier
plataforma"
El cdigo byte de nuestra aplicacin junto con el cdigo byte de las libreras
estndar Java actan como input al ejecutar el comando java, y entonces la MVJ
propia de esa plataforma hace la traduccin a cdigo de bajo nivel propio del
Sistema Operativo y del hardware subyacente.
Pgina 27 de 267
JAVA BSICO
1.5 Variables de ambiente
Son dos variables de ambiente del sistema operativo Windows que tienen que ser
configuradas, estas son PATH y CLASSPATH.
Configuracin de la variable de ambiente PATH.
La variable de ambiente PATH indica al sistema operativo donde se ubican o se
encuentran los programas ejecutables del kit de herramientas del Java 2 JDK, en
la documentacin indica que debe apuntar a la carpeta bin, que es donde se
alojan los archivos ejecutables, as por ejemplo si instalaste el Java en el disco
duro C: se tiene que poner:
SET PATH = C:\Archivos de programa\Java\jdk1.6.0_20\bin
Entonces el sistema operativo sabr dnde buscar esos archivos.
Es recomendable establecer otra variable de ambiente conocida como
JAVAHOME que apunta a donde instalaste el Java, as:
JAVAHOME = C:\Archivos de programa\Java\jdk1.6.0_20\.
Entonces puedes establecer tu variable de ambiente PATH, as:
SET PATH =%JAVAHOME%\bin
lo cual resulta ms prctico a la larga cuando instalas mas software que trabaje
con Java como el servidor de Servlets y JSP Tomcat de Apache.
Configuracin de la variable de ambiente CLASSPATH
La variable CLASSPATH indica al compilador, e intrprete de Java y a otras
aplicaciones que utilicen las API's de Java donde ubicarlas o encontrarlas para
cargarlas a Memoria y utilizarlas. En la versin Java 2 JDK 1.6.0_20 las API's
Pgina 28 de 267
JAVA BSICO
estn en la carpeta lib en formato .jar (Java Archive) y es el archivo tools.jar,

entonces hay que configurar la variable CLASSPATH para que apunte a ese
archivo porque ah estn las clases compactadas de las API's, no basta que
apunten a la carpeta, tienen que apuntar a los archivos as:
SET CLASSPATH=.;
C:\Archivos de programa\Java\jdk1.6.0_20\lib\tools.jar
o si ya creaste la variable JAVAHOME
para apuntar a C:\Archivos de
programa\Java\jdk1.6.0_20\. se puede hacer lo siguiente:

SET CLASSPATH=.;%JAVA_HOME%\lib\tools.jar
la parte de la ruta de configuracin del CLASSPATH (.;) (punto y punto y coma)
es necesaria para apuntar a la carpeta o directorio actual de trabajo con el fin de
que podamos compilar y ejecutar nuestros programas de Java en la carpeta donde
estemos ubicados en ese momento y tome las clases generadas en esa carpeta.
Nota:
Para establecer las variables de ambiente PATH y CLASSPATH en sistemas
Windows 98 y Windows 2000 hay que editar el archivo autoexec.bat con un editor
de texto como el block de notas, y modificarlas variables PATH y CLASSPATH
como se explic antes y hay que inicializar de nuevo el sistema para que el
sistema operativo de los valores nuevos a dichas variables.
Para establecer las variables de ambiente PATH YCLASSPATH Microsoft
Windows NT, 2000, y XP, Vista y Windows 7.
Hay que seguir los pasos siguientes (En Windows XP, Vista y Windows 7 puede
variar un poco pero son en esencia los mismos pasos):
Pgina 29 de 267
JAVA BSICO
Inicio->Configuracin ->Panel de Control ->Sistema ->Ventana de "Propiedades

del Sistema"; ficha o pestaa "Avanzado"; botn "Variables de entorno" ->Ventana
de "Variables de entorno".
En la ventana Variables de entorno se encuentran las variables de usuario en la
parte superior, pulsando el botn "Nueva" aparece un cuadro de dialogo donde se
debe introducir el Nombre de la variable y el Valor de la Variable.
Vea la siguiente Figura 1-7. Para el caso de Windows XP profesional:
Figura 1-7. Configuracin de variables de entorno son en esencia son los mismos pasos para
sistemas Windows XP, Vista y Windows 7. Una vez instalado el JDK 6 puede instalar al NetBeans
6.9
Pgina 30 de 267
JAVA BSICO
1.6 Prueba de instalacin

Los usuarios de Windows pueden verificar su instalacin del JDK al usar el
comando de MS-DOS en la mayora de los sistemas. El indicador de MS-DOS
tambin se le conoce como el indicador de comandos debido a que lo puede usar
para escribir comandos que ejecuta el sistema operativo.
Escrbalo siguiente en un indicador de comandos para verificar que su sistema
pueda encontrar la versin correcta del JDK en l:
Javaversin
B) Si est usando el JDK 1.6.0_20, en respuesta usted debera ver el siguiente
mensaje, vea la Figura 1-8.
Figura 1-8. Prueba de que esta ejecutndose el JRE versin 1.6.0_20
Pgina 31 de 267
JAVA BSICO
Su primera aplicacin de Java

Las aplicaciones de Java son programas independientes que no requieren un
navegador Web para correr.
Son ms parecidos a los programas que usted.
Suele usar en su computadora (los ejecuta localmente con su ratn o escribiendo

el nombre en la lnea de comandos)
A) Escriba el programa. Puede utilizar el block de notas de Windows o cualquier
editor de texto que usted conozca.
class Hola {
public static void main(String[] arguments) {
System.out.println("Hola bienvenido a tu curso bsico
de Java");
}
}
B) Cree una carpeta que se llame C:\j2010curso. En ella guarde el archivo del
programa con el nombre de Hola.java. Es importante que el programa se llame
exactamente igual al nombre de la clase para que pueda compilarse, de lo
contrario habr un error. Cuando guarde el archivo utilice comillas antes y
despus del nombre para evitar que el programa guarde el archivo con su
extensin .TXT, tal y como se ve en la Figura 1-9:
Pgina 32 de 267
JAVA BSICO
Figura 1-9. Usando el NotePad como editor para cdigo fuente Java.
Compilacin y ejecucin del programa en Windows.

Cambiar el directorio actual al J2010curso con la ventana de una sesin de MSDOS con el comando:
cd\j2010curso
Si est en la carpeta correcta, puede compilar Hola.java escribiendo lo siguiente
en el indicador de lnea de comandos:
javac Hola.java
Pgina 33 de 267
JAVA BSICO
La Figura 1-10. Muestra los comandos de MS-DOS que se usaron para cambiarse a
la carpeta\j2010curso, listar los archivos de las carpetas y compilar Hola.java
Figura 1-10. Compilando Hola.java en la consola de MSDOS.
Si el compilador del SDK no despliega ningn mensaje de error quiere decir que
se compil con xito. Esto quiere decir que se crear un archivo Hola.class en el
mismo directorio que contiene Hola.java.
Este archivo .class es el cdigo de bytes (bytecode) que puede ser ejecutado por
la mquina virtual
C) Una vez que tenga un archivo .class, lo puede ejecutar mediante el intrprete
de cdigo de bytes. Ejecute Hola.class escribiendo lo siguiente:
java Hola
Pgina 34 de 267
JAVA BSICO
La Figura 1-11. Muestra la salida apropiada de la aplicacin Hola junto con los
comandos MS-DOS que se utilizaron para llegar a ese punto.
Figura 1-11. Ejecucin del programa con el intrprete de Java JDK 6
Pgina 35 de 267
JAVA BSICO
1.7 Obtencin del IDE NetBeans 6.0

Para
obtener
el
NetBeans
6.9
visite
la
pgina
http://dlc.sun.com.edgesuite.net/netbeans/6.9/rc/ y descargue el NetBeans con las

caractersticas requeridas para este curso, en este caso, Java SE
Ver Figura 1-12.
Previamente ya instal el JDK 6, entonces, solo dele clic al archivo de instalacin
que descarg
Figura 1-12. Pgina de descarga del NetBeans IDE 6.9, para lo bsico se descarga Java SE
Pgina 36 de 267
JAVA BSICO
Para iniciar el proceso de instalacin. Aparecer una ventana de configuracin del

instalador, y luego una ventana de bienvenida del instalador, ver Figura 1-13.
Figura 1-13. Ventana de bienvenida del instalador del NetBeans 6.9
Luego aparecer una ventana con la licencia, la cual deber aceptar porque es un
software libre. Le da clic al botn siguiente y aparecer una ventana donde usted
determina donde est la carpeta o directorio donde se instal el JDK 6 y en donde
se instalar el NetBeans 6.9, ver Figura 1-14.
Figura 1-14. Donde se determina las carpetas o directorios de instalacin.

Pgina 37 de 267
JAVA BSICO
Le da clic al botn Next> y comienza la instalacin, ver Figura 1-15.
Figura 1-15.: Avance de instalacin, al cubrir el 100% se concluye la instalacin.
Al concluir, le pregunta si quiere contribuir con sus datos, y le da clic a Finish.En el

sistema ya hay accesos directos para abrir el NetBeans IDE 6.9, ver Figura 1-16. Si
tienes una versin previa al arrancarlo te preguntar si quieres exportar tus
proyectos existentes a la nueva versin.
Figura 1-16. Acceso directo al NetBeans 6.9
Pgina 38 de 267
JAVA BSICO
1.8 Desarrollo de una aplicacin Java con el IDE NetBeans 6.0
Se abre la nueva pantalla principal del NetBeans 6.9, ver Figura 1-17.
Figura 1-17. Pantalla principal y de bienvenida del NetBeans 6.9
Pgina 39 de 267
JAVA BSICO
Para crear programas con Java se requiere primero crear un proyecto. Para crear
un proyecto de clic al men File > New Project > y aparece el cuadro New
Project y escoger en Categories Java y tipo de proyecto Java Application y darle
clic al botn Next >, ver Figura 1-18.
Figura 1-18. Cuadro New Project.
Luego aparece la parte donde se le da nombre al proyecto, p. ej. PROY1DGSCA

y con el botn Browse...se puede crear una carpeta, p. ej., en la unidad
C:\CURSOJDK6. En la parte de crear una clase Main, y establecer como proyecto
principal, no ponga marcas de verificacin, porque no lo requerimos por el
momento y le da clic a Finish>. Ver Figura 1-19.
Pgina 40 de 267
JAVA BSICO
Figura 1-19. Parte donde se pone nombre al proyecto y el lugar donde se va a guardar.
Aparecer en el IDE en la ventana de proyecto un nuevo nodo con un icono de

una taza de caf con el nombre PROY1DGSCA, ver Figura 1-20.
Figura 1-20.Se ve la ventana de proyecto, con el paquete por default.
Pgina 41 de 267
JAVA BSICO
Ahora para crear una clase Java con el mtodo main para que sea una aplicacin
de consola, de clic al con el botn derecho sobre el nodo PROY1DGSCA y escoja
New > Java Class, ver Figura 1-21.
Figura 1-21. Men contextual para crear una nueva Java Class.
En el cuadro New Java Class escriba el nombre de la clase HolaMundo y le da

clic al botn Finish>. El IDE le va a crear un archivo HolaMundo.java en la ruta
C:\CURSOJDK6\PROY1DGSCA\src\HolaMundo.java ya que ah el NetBeans
pone los cdigos fuente que pertenecen al paquete por default.
Pgina 42 de 267
JAVA BSICO
Aparecer una nueva ventana de edicin donde usted podr capturar el cdigo
fuente de su programa, ver Figura 1-22.
Figura 1-22. Ventana de edicin del NetBeans 6.9
Pgina 43 de 267
JAVA BSICO
En la ventana HolaMundo.java escriba el siguiente cdigo fuente Java:

import javax.swing.JOptionPane;
/**
*
* @author CIC
*/
public class HolaMundo {
String nombre;
public HolaMundo(String nombre) {
this.nombre = nombre;
}// fin constructor
public static void main( String args[] ) {
HolaMundo hm = new HolaMundo("Oscar Alejandro");
System.out.println("Bienvenido a tu curso de Java " + hm.nombre + "!");
JOptionPane.showMessageDialog(null,
"Bienvenido a tu curso de Java " + hm.nombre + "!",
hm.nombre,
JOptionPane.INFORMATION_MESSAGE);
} // fin del metodo main
} // fin de la clase HolaMundo
Pgina 44 de 267
JAVA BSICO
Finalmente guarde el programa con el botn de Guardar. Para ejecutarlo

seleccione Run > Run File
Maysculas F6. El programa debera darle la
bienvenida en un cuadro de dilogo estndar, ver Figura 1-23.
Figura 1-23. Ejecucin del HolaMundo.java
Pgina 45 de 267
JAVA BSICO
1.9 Tipos de programas en Java

En Java se tienen varios tipos de programas que se caracterizan por la forma y
lugar en que se ejecutan. Hasta ahora se distinguen:
aplicaciones de consola.
applets.
servlets / JSP.
programas J2ME
JavaBeans
EJB. (Enterprise JavaBeans
Java Card
Java FX
Aplicaciones de consola: llevan en la clase un metodo que es esttico llamado

main (), en los sucesivos captulos de ste manual se muestran varios ejemplos.
Applets: son programas que se ejecutan dentro de un navegador de Internet
(como Netscape o Internet Explorer. La ejecucin de estos inicia en el mtodo
init(), luego en start() o paint()y termina con el mtodo destroy(). En caso de
faltar alguno de estos se pasa al siguiente.
Servlets son programas que se ejecutan en un servidor y entregan resultados a
un programa cliente (cliente/servidor se explica ms adelante en uno de los
captulos de este documento). Los mtodos que se ejecutan son init()primero y
luego doGet() o doPost() o action()dependiendo del que se encuentre
sobrescrito en ese momento.
Pgina 46 de 267
JAVA BSICO
Beans: se utilizan en los llamados JSP (Java Server Pages) para brindarles
funcionalidad con el uso de objetos. Estos no tienen un punto de inicio de
ejecucin como los anteriores sino que cualquier mtodo se puede llamar en
cualquier momento dentro de un JSP.
Los Java ME (Java Platform, Micro Edition) es una plataforma de aplicaciones
para dispositivos mviles o inalmbricos ubicados a lo ancho del Globo. Provee
un ambiente robusto y flexible para aplicaciones que se ejecuten sobre un amplio
rango de dispositivos, tales como telfonos mviles, PDAs, TV set-top boxes, e
impresoras. La plataforma Java ME incluye flexibles interfaces de usuario, y
modelos de seguridad robustos, para un amplio rango de protocolos de red, y un
soporte extensivo para redes y aplicaciones offline, que pueden ser descargadas
dinmicamente.
EJB: (Enterprise JavaBeans) son la base de la tecnologa J2EE (Java 2 Enterprise
Edition).Los EJB proveen una arquitectura escalable para ejecutar lgica de
negocios en ambientes computacionales distribuidos.
Java Card: nos permiten crear aplicaciones para tarjetas inteligentes de
identificacin y como llaves de acceso a lugares restringidos por ejemplo.
JavaFX: es un lenguaje script de Java que permite programacin de interfaces
grficas de usuario para estandarizar las GUIs para la mayora de dispositivos de
salida grfica.
Pgina 47 de 267
JAVA BSICO
1.10 Estructura de un programa de tipo aplicacin en Java
Todo programa en Java parte de la definicin de una clase donde se usa la

palabra reservada class seguida de su nombre y su cuerpo de sentencias
delimitado por llaves { }. La palabra reservada public es el delimitador de mbito
de acceso de la clase.
public class Galleta {

// aqu va la definicin
//de los atributos (campos)
y
// mtodos de la clase.
}
Cuando a una clase se le agrega el mtodo:

public static void main( String args[] )
La clase se convierte en una aplicacin de consola:

}
Todas las clases en Java heredan por default de manera implcita atributos y
mtodos de la clase raz Object.
Pgina 48 de 267
JAVA BSICO
Todas las clases en Java importan por default de manera implcita la librera o
paquete java.lang.
import java.lang.*;
public class Galleta extends Object {
}
}
Por lo tanto no es necesario escribir:
import java.lang.*; ni extends Object ya que se da
por hecho o de manera implcita.
}
}
Todas las clases pertenecen a un paquete.

Un paquete es un conjunto de clases agrupadas como una unidad y relacionadas
entre s por su funcionalidad.
Cuando se crea una clase, esta pertenece por omisin al paquete por
default.
Si se desea que una clase pertenezca a un paquete diferente al default , hay que
crear el paquete y usar la sentencia.
package nombrepaquete;
Pgina 49 de 267
JAVA BSICO
Y est sentencia debe ser la primera instruccin dentro del archivo fuente con
extensin .java
En la Figura 1-24. la clase Galleta pertenece al paquete unam.cafeteria.
Figura 1-24. La clase Galleta en el paquete unam.cafeteria.
Pgina 50 de 267
JAVA BSICO
Pero se recomienda la siguiente estructura, veamos un ejemplo:
package unam.cafeteria;
/** Variables campo */
/** nombre de la galleta */
public String nombre;
/** sabor de la galleta por default es fresa */
String sabor = "Fresa";
/**Constantes campo */
/** forma de la galleta es Estrella */
public static final String FORMA = "Estrella";
/** Numero de picos = 5 */
public static final int PICOS = 5;
/** constructores crean instancias u objetos de la clase Galleta */
/**constructor Galleta() crea una galleta cuyo nombre por default es "Estrellita" */
public Galleta() {
nombre = "Estrellita";
} // fin del constructor
public Galleta(String nombre) {
}
public Galleta(String nombre, String sabor) {
this.sabor = sabor;
}
public static void main (String args[]) {
int nogatos = 20;
for( int i = 0; i < args.length; i++)
System.out.println( "i= " + i + "\t" + args[i]);
String mensaje = new String("Programa Galleta.java");
System.out.println(mensaje);
JOptionPane.showMessageDialog(null, mensaje);
} // fin del metodo main
public String caracteristicasDeLaGalleta( ) {
String cadena = "Nombre : " + this.nombre + "\t" +
"Sabor : " + this.sabor + "\t" +
"Picos : " + this.PICOS + "\t" +
"Forma : " + this.FORMA ;
return cadena;
}
} // fin de la clase Galleta
Pgina 51 de 267
JAVA BSICO
El programador es libre de poner todos los miembros de la clase (atributos,

constructores, mtodos de interface pblica y de implementacin privada) donde
guste siempre y cuando estn dentro de la definicin de clase (dentro de los
parntesis de mbito de la clase), Java no le amarra las manos, pero conviene
tener un orden, y el ejemplo anterior se propone uno.
Pgina 52 de 267
JAVA BSICO
1.11 Como se crean aplicaciones Java con JDK

Primeramente necesita un editor (Block de notas, Edit, vi, Gel, TextEdit, Med, etc.)
para generar un archivo con extensin.java el cual tenga el cdigo fuente en
lenguaje Java. Despus puede generar la documentacin con javadoc.exe o
pasar a compilar el programa para generar el(los) archivo(s).class tambin
conocidos como unidades de compilacin (por cada definicin de clase se genera
una unidad de compilacin, esto es, se genera un archivo con extensin.class)
Luego puede incluir archivos de cabecera de C/C++ si as lo requiere su aplicacin
con javah.exe. Ahora ya puede ejecutar su aplicacin con el interprete java.exe
de Java y visualizar sus resultados por algn dispositivo de salida como la
pantalla. Finalmente puede depurar su programa con jdb.exe, si hay bugs en su
aplicacin y puede volver otra vez al editor de texto, y realizar de nuevo todos los
pasos mencionados.
Pgina 53 de 267
JAVA BSICO
En la siguiente Figura 1-25 se indica esquemticamente las etapas que un

programador tiene que realizar para crear aplicaciones Java con SDK.
Figura 1-25. Como se crean aplicaciones Java con JDK 6 (Java Development Kit )
Pgina 54 de 267
JAVA BSICO
1.12 Como se crean applets Java con SDK
Al igual que las aplicaciones, con los applets, primeramente necesita un editor
(Block
denotas,
Edit,
vi,
Gel,
TextEdit,
Med,
etc.)
para
generar
un
archivoconxtensin.java el cual tenga el cdigo fuente en lenguaje Java. Despus

puede generar la documentacin con javadoc.exe o pasar a compilar el programa
para generar el(los) archivo(s) .class tambin conocidos como unidades de
compilacin (por cada definicin de clase se genera una unidad de compilacin,
esto es, se genera un archivo con extensin .class) .
Luego puede incluir archivos de cabecera de C/C++ si as lo requiere su aplicacin
con javah.exe.
Ahora
para ejecutar su applet lo puede hacer con el interprete de
applets appletviewer.exe de Java el cual utiliza como argumento el archivo con

extensin .html o .html y visualizar sus resultados por la pantalla, tambin puede
utilizar algn navegador o browser como Internet Explorer o Netscape para
visualizar su applet en el rea de despliegue del navegador. Finalmente
puede depurar su programa con jdb.exe, si hay bugs en su aplicacin y puede
volver otra vez al editor de texto, y realizar de nuevo todos los pasos
mencionados.
Pgina 55 de 267
JAVA BSICO
En la siguiente Figura 1-26. Se indica esquemticamente las etapas que un

programador tiene que realizar para crear aplicaciones Java con SDK.
Figura 1-26. Cmo se crean applets Java con JDK (Java Development Kit)
Pgina 56 de 267
JAVA BSICO
2. ELEMENTOS BSICOS DEL LENGUAJE JAVA

2.1 Comentarios
Los comentarios son informacin que no tienen ningn efecto con la lgica de un
programa y cuyo propsito es la de documentar el cdigo del programador. Un
programador documenta sus clases, mtodos, variables, etc., porque no solo el
compilador es el nico en leer el cdigo, sino tambin otros programadores, o l
mismo despus de algn tiempo en el que podra olvidar para que o porque puso
tal o cual instruccin. En Java hay tres tipos de comentarios:
Los de una sola lnea al estilo del C++, que comienzan con doble diagonal // y
terminan al final de la lnea, ejemplo:
// Esto es un comentario que inicia con doble diagonal y termina aqu
Los de varias lneas al estilo del lenguaje C, los cuales estn entre diagonal y
asterisco /* y asterisco seguido de diagonal, */. Todo lo que este dentro es
considerado un comentario. Ejemplo:
/* Esto es un conjunto de
Datos que informa al programador
Para que puso tal o cual cosa */
En Java pueden anidarse estos comentarios /* */ pero el primer */ finalizar
ambos comentarios, lo que har que el resto del comentario que quede fuera sea
tratado como cdigo por el compilador.
Pgina 57 de 267
JAVA BSICO
2.1.1 Comentarios de tipo del C y C++

En esta parte veremos la sintaxis de los elementos bsicos del lenguaje Java y
que usados para describir los elementos que constituyen programas de Java
vlidos. Si el lector ya tiene experiencia con lenguajes como C, C++, C# se
percatar que la sintaxis es bastante similar en Java, y las diferencias se
percibirn de acuerdo al lenguaje del que se proceda. Para entender la sintaxis de
un lenguaje conviene empezar por lo bsico y avanzar desde ah, estos elementos
son: los comentarios, palabras reservadas, variables, tipos de datos, literales,
instrucciones, expresiones, operadores y modificadores.
Pgina 58 de 267
JAVA BSICO
2.1.2 Comentarios para el javadoc y sus etiquetas principales

El tercer tipo de comentarios es el que comienza con /** y termina con */ y son
conocidos como comentarios javadoc, llamados as por la herramienta SDK. Este
funciona como el comentario /* */ y se utiliza para documentar elementos como
clases, mtodos y variables. Este tipo de comentario tiene etiquetas conocidas
como @etiquetas las cuales se pueden colocar dentro del comentario, y que son
utilizadas por la herramienta javadoc al generar las pginas HTML. La siguiente
tabla muestra algunas de ellas.
Etiqueta
Descripcin
@autor nombre
Especifica el nombre del autor o creador del

elemento
@deprecated texto
Sirve para especificar un elemento que ya no

se usa, y el texto describe lo que se debe hacer
cuando sea posible.
@exception texto de la excepcin
Especifica que un mtodo arroja una excepcin.
@throws texto de la excepcin

{@link nombre de la etiqueta}
Sirve para insertar un vnculo a otra pgina

javadoc. Est diseado para estar relacionada
con otra descripcin.
@param nombre del texto
Es para describir un parmetro de un mtodo.
@return texto
Se usa para describir el valor devuelto por un

mtodo.
@see referencia
Sirve para crear una referencia cruzada con

otro paquete, clase, mtodo u otro documento.
@since texto
Es para especificar el momento en que se

aadi algo.
@serial texto
@serialField texto con nombre de tipo
Sirve
para
documentar
serializable de una clase.
la
naturaleza
@serialData texto
@version texto
Es para documentar la versin de un elemento.
Pgina 59 de 267
JAVA BSICO
Un ejemplo de comentarios javadoc

El siguiente programa muestra una clase particular llamada Dato con comentarios
javadoc creados en los lugares adecuados solo para ejemplificar esta herramienta
del SDK. Para generar la documentacin hay que ejecutar la herramienta javadoc
sobre el archivo fuente con el siguiente comando:
Javadoc Dato.java: Esto generar la documentacin HTML para la clase, como
se indica a continuacin:
Loading source file Dato.java...
Constructing Javadoc information...
Standard Doclet version 1.4.1
Generating constant-values.html...
Building tree for all the packages and classes...
Building index for all the packages and classes...
Generating overview-tree.html...
Generating index-all.html...
Generating deprecated-list.html...
Building index for all classes...
Generating allclasses-frame.html...
Generating allclasses-noframe.html...
Generating index.html...
Generating packages.html...
Generating Dato.html...
Se generar un archivo HTML para cada clase, junto con varios archivos de ndice
que, y son muy tiles cuando se generan mltiples clases juntas. Para ver el
resultado hay que abrir el archivo Dato.html y se obtendrn los comentarios estilo
javadoc de este archivo HTML.
Ver a continuacin el cdigo de Dato.java y la figura del ejemplo de
documentacin de clase generada con javadoc
Pgina 60 de 267
JAVA BSICO
/**
* El componente <code> Dato </code> es solo un ejemplo.
* Solo sirve para ensearte el javadoc.* 
* @version 2.0
* @author cic
*/
public class Dato {
/**
* Un tipo de Dato especfico
*/
public static final int TIPO_DATO = 0;
/**
* Otro tipo de dato especfico
*/
public static final int OTRO_TIPO_DATO = 1;
/**
* El tipo de dato actual
*/
private int tipo;
/**
* Crea un Dato
*/
public Dato() {
tipo = TIPO_DATO;
}
/**
* devuelve el tipo de dato actual
*
* @return tipo de dato actual
* @deprecated Como la versin 1.9, use {@link #getDato() getDato()} en
* su lugar
*/
public int data() {
return getDato();
}
/**
* Devuelve el tipo de dato actual
*
* @return tipo de dato actual
* @since V1.9
*/
public int getDato() {
return tipo;
}
/**
* Cambia el tipo de dato actual
*
* @param escribe el nuevo tipo de dato
* @throws IllegalArgumentException Cuando el tipo no es vlido
*/
public void setDato( int nuevoValor ) {
if ( ( nuevoValor != TIPO_DATO ) &&
( nuevoValor != OTRO_TIPO_DATO ) ) {
throw new IllegalArgumentException("Tipo malo");
}tipo = nuevoValor;
}/**
* Mtodo marcador de posicin para ver etiquetas
* @see Dato#TIPO_DATO
* @see Dato#getDato()
* @see #getDato()
* @see "Mi libro"
* @see <a href="http://www.cic.ipn.mx/ogonzalez">Web de Oscar</a>
*/public void myVoid() {}}
Pgina 61 de 267
JAVA BSICO
Salida del programa Dato.java al utilizar la herramienta javadoc
Figura 1-27. Ejemplo de documentacin de clase generada con la herramienta javadoc
Pgina 62 de 267
JAVA BSICO
2.2 Identificadores
Variables de Instancia.
Variables de una clase.
Variables locales a mtodos.
Variables parmetro de mtodos
La declaracin de variables en Java se hace de forma similar al C. En adelante, un
identificador ser el nombre de una variable. As declararemos.
Tipo identificador [identificador]; donde tipo va a ser uno de los 8 tipos de datos
(primitivos) de JAVA. Estos son:
Nombre tipo
Clase
Tamao
byte
entero
8-bit
short
entero
16-biy
int
entero
32-bit
long
entero
64-bit
float
real
32-bit
double
real
64-bit
char
carcter
16-bit (Cdigo Unicode)
boolean
booleano
1-bit
Java define adems otros tipos que no estn en la anterior clasificacin, estos
tipos son instancias de alguna clase en particular, ya sea de una clase que haya
creado el programador o una clase ya existente dentro de las bibliotecas API de
Java.
El mbito de los valores de las variables de instancia se limita como su nombre lo
indica a la instancia misma.
En las variables de clase sus valores son para todas las instancias de la clase
misma, esto es, su valor es compartido por todas las instancias de la clase y su
Pgina 63 de 267
JAVA BSICO
almacenamiento debe ser esttico y se especifica con la palabra reservada static,

si usted programador de C, son parecidas a las variables globales.
Por ltimo las variables locales a mtodos sus valores se circunscriben al mbito
del mtodo al que pertenecen. El siguiente ejemplo muestra la diferencia entre las
variables de clase, de instancia y locales mtodos:
/**
* Curso de Java Bsico
* @author CIC
* @version 1.0
* Archivo: Variables.java
* Clase Variables: su propsito es ensearte
* el uso de las variables en Java
*/
public class Variables {
static int clase;
int instancia;
int metodoVar ( ) {
int local = 6;
return local;
}
}
/**
* @author CIC
* @versin 1.0
* Archivo: UsaVariables.java
* Clase UsoVariables: su propsito es ensearte
* el uso de las variables en Java
*/
class UsaVariables {
Variables x = new Variables();
Variables y = new Variables();
public static void main ( String args[] )
Pgina 64 de 267
JAVA BSICO
{
UsaVariables u = new UsaVariables();
escribeVar( u.x ,"x" ); escribeVar( u.y , "y" );
u.y.clase = 123;
u.x.instancia = 321; u.y.instancia
= 567;
escribeVar( u.x ,"x" ); escribeVar( u.y , "y" );
System.out.println("Fin del programa");
}
static void escribeVar(Variables ejem
, String id) {
System.out.print("Valor de las variables\n" +
id + ".clase = " + ejem.clase + "\n" +
id + ".instancia = " + ejem.instancia + "\n" +
id + ".local = " +
ejem.metodoVar() + "\n" +
"=============================\n");
}
}
La salida del ejecutar el programa: java UsaVariables

Valor de las variables
x.clase = 0
x.instancia = 0
x.local = 6
=============================
y.clase = 0
y.instancia = 0
y.local = 6
=============================
x.clase = 123
x.instancia = 321
x.local = 6
=============================
y.clase = 123
y.instancia = 567
y.local = 6
=============================
Fin del programa
Pgina 65 de 267
JAVA BSICO
Finished executing
Podemos ver que en el listado del programa Variables.java tenemos definida en la
lnea 12 una variable de clase (observe el uso de la palabra reservada static), en
la lnea 13 una de instancia y una local al mtodo en la lnea 16.Todas son de tipo
int.
El siguiente listado del programa UsaVariables.java, esta compuesta de dos
variables de instancia x , y de la clase Variables. Para poderlas utilizar
necesitamos crear una variable u de instancia de la misma clase UsaVariables en
la lnea 16. Al mandar a imprimir sus valores en la lnea 17, mediante la invocacin
del mtodo escribeVar (Variables ejem, String id) el cual recibe la variable y su
identificador en sus parmetros el resultado es:
x.clase = 0
x.instancia = 0
x.local = 6
=============================
y.clase = 0
y.instancia = 0
y.local = 6
Debido a que el intrprete de Java inicializa las variables de tipo int con 0, excepto
para la local que se inicializa con un valor de 6 en la lnea 16.
Luego se le asigna en la lnea 18, un nuevo valor (123) a la variable de clase, esto
tiene como efecto la modificacin del valor para todas las instancias (en este caso
x, y) de la clase Variables.
18.
u.y.clase = 123;
En la lnea 19, se modifican los valores de las variables de instancia para x (321) y
para y (567), lo cual solo afecta respectivamente a esas variables de instancia.
19.
u.x.instancia = 321; u.y.instancia = 567;

Pgina 66 de 267
JAVA BSICO
Luego en la lnea 20, al volver a invocar al mtodo escribeVar() la salida

ejemplifica la afectacin de los valores de las variables tanto de clase, ambas con
valor
de
123
las
de
instancia
con
123
con
321.
=============================
x.clase = 123
x.instancia = 321
x.local = 6
=============================
y.clase = 123
y.instancia = 567
y.local = 6
=============================
Fin del programa
Pgina 67 de 267
JAVA BSICO
2.3 Palabras reservadas

Java al igual que cualquier otro lenguaje de programacin tiene su conjunto de
palabras reservadas. Las palabras reservadas no pueden ser empleadas como
identificadoras de clases, interfaces, variables, mtodos, constantes, etc., ya que
como su nombre lo dice, son palabras reservadas para el lenguaje de
programacin. La siguiente tabla es un resumen las palabras reservadas de Java.
abstract
double
Int
Static
boolean
else
Interface
Super
break
extends
Long
Switch
byte
final
Native
Synchronized
case
finally
New
This
catch
float
Null
Throw
char
for
Package
Throws
class
goto *
Private
trasient *
const *
if
Protected
Try
continue
implements
Public
Void
default
import
Return
Volatile
do
instanceof
Short
While
* indica que la palabra reservada no es actualmente utilizada.
Pgina 68 de 267
JAVA BSICO
2.4 Tipos de datos en Java
Los tipos primitivos tienen un tratamiento especial porque son usados

frecuentemente adems porque la razn es que crear un objeto con new
especialmente uno chico como una simple variable no es muy eficiente porque
new aloja objetos en el heap
Para estos tipos Java hace lo mismo que C y C++ en lugar de crear la variable
usando new una variable automtica es creada la cual no es una referencia. La
variable aloja el valor por si mismo y lo coloca en el stack que es mucho ms
eficiente.
Java determina el tamao de cada tipo primitivo. Estos tamaos no cambian de
una arquitectura de mquina a otra como en la mayora de los lenguajes. Esto es
la razn por la cual los programas en Java son muy portables. La siguiente tabla
muestra esos tamaos que no cambian:
Tipo
Tamao/Formato Descripcin
(Nmeros enteros)
byte
8-bit complemento a 2
Entero de un Byte
short
Entero corto
int
Entero
long
Entero largo
(Nmeros reales)
float
32-bit IEEE 754
Coma flotante de precisin simple
double
64-bit IEEE 754
Coma flotante de precisin doble
(otros tipos)
char
16-bit Caracter
Un slo carcter
boolean
true o false
Un valor booleano (verdadero o falso)
Pgina 69 de 267
JAVA BSICO
La mayora de los tipos primitivos tienen clases Wrapper. Significa que un objeto
no primitivo en el heap puede ser creado para representar uno primitivo en el
heap. Ejemplo:
char c = x;
Character C = new Character(c);
// O tambin puede ser:
Character C = new Character(x);
Pgina 70 de 267
JAVA BSICO
2.5 Literales
En Java hay una forma de especificar un valor determinado a una variable o
constante, mediante una literal, que es una expresin constante utilizada para
expresar un valor. Cada tipo de dato tiene su propio formato para especificar una
literal, como se describe en la siguiente tabla:
Notaciones literales
Tipo
Formato
int
Decimal dgitos 0-9 ejemplo: (1234)

Octal cero (0) seguido de los dgitos 0-7 ejemplo: (01234)
Hexadecimal 0x o 0X seguido de los dgitos 0-9, A-F ejemplo: (0x1234)
long
Aade l o L al final del trmino literal int ejemplo: 0Xdecadal
float
Aade f o F al final del trmino literal double y sustituye a d/D en caso de existir por
ejemplo: 3.14f , 3.14E+15F
double
Notacin cientfica como en 1.345e+10, donde el exponente puede expresarse con una
e o una E; puede encontrarse una d o D al final del elemento literal doubl
char
Un nico caracter o secuencia de escape entre comillas sencillas, por ejemplo: 'X', 'r'.
String
Varios caracteres o secuencias de escape entre comillas dobles. .
boolean
verdadero, falso
Null
Nulo
Notaciones literales
Notacin cientfica como en 1.345e+10, donde el exponente puede expresarse

con una e o una E; puede encontrarse una d o D al final del elemento literal
double
Char Un nico caracter o secuencia de escape entre comillas sencillas, por
ejemplo: 'X', 'r'.
String Varios caracteres o secuencias de escape entre comillas dobles. .
Boolean
Null
verdadero, falso
nulo
Pgina 71 de 267
JAVA BSICO
Ejemplo de literales
public class Literales {
public void representaLiterales() {
int xd= 1234; // literal entera decimal
int xo= 01234; // literal entera octal
int xh= 0x1234; // literal entera hexadecimal
// El operador (+) unin de cadenas convierte la variable entera
// A cadena String en formato numrico decimal
System.out.println ("xd= " + xd + "\txo= " + xo + "\txh= " + xh);
long xl = 0xDECADAL;
System.out.println ("xl= " + xl);
float f1 = 3.14E+15f;
System.out.printf("fl= %3.9f\n" , f1);
double d1 = 1.345e+10d;
System.out.printf("dl= %3.2f\n" , d1);
char c1 = 'a';
char c2 = '\t';
char c3 = '\u0040';
System.out.println("c1= " + c1 + "\tc2= " + c2 + "\tc3= " + c3);
String s1 = "Viva Villa Jijos del Maiz!";
System.out.println ("s1= " + s1 + "\n" +
"Mayusculas s1= " + s1.toUpperCase () + "\n" +
"Reversa s1= ".toUppercase() + new StringBuffer(s1).reverse() );
boolean si = true;
boolean no = !si;
boolean noperosi = !no;
System.out.println ("si= " + si + "\tno= " + no +
"\tnoperosi= " + noperosi );
} // fin del mtodo representaLiterales()
public static void main ( String args[] ) {
Literales lit = new Literales();
lit.representaLiterales();
} // fin del main
} // fin de la clase literales
Salida de Literales.java
run:
xd= 1234
xo= 668
xh= 4660
xl= 14600922
fl= 3140000124239872.000000000
dl= 13450000000.00
c1= a
c2=
c3= @
s1= Viva Villa Jijos del Maiz!
Mayusculas s1= VIVA VILLA JIJOS DEL MAIZ!
REVERSA S1= !ziaM led sojiJ alliV aviV
si= true
no= false
noperosi= true
BUILD SUCCESSFUL (total time: 0 seconds)
Pgina 72 de 267
JAVA BSICO
2.6 Secuencias de escape de carcter

Son caracteres que pueden utilizarse en los flujos o en los mtodos de
System.out.print (), o System.out.println () para control de la salida que el
programador desea, y siempre tienen como prefijo la diagonal invertida o back
slash. La siguiente tabla presenta un resumen de estos caracteres:
Escape Significado
\n
nueva lnea
\t
tabulador
\b
espacio en blanco
\r
retorno de carro
\f
formfeed
\\
back slash, para comentarios
\'
comilla simple
\"
comillas
\ddd
nmero en octal (ejemplo: \231 )
\xdd
nmero en hexadecimal (ejemplo: \x12 )
\udddd
caracter UNICODE (ejemplo: \u1914 )
Pgina 73 de 267
JAVA BSICO
2.7 Sentencias y expresiones

Las sentencias y expresiones en Java son delimitadas por punto y coma ( ; ) al
final de las lneas del cdigo ya que por lo general, las sentencias estn escritas
en una sola lnea como:
final String CIC = new String ("Centro de Investigacin en Computacin");
Pero el compilador de Java no se preocupa donde el programador coloca espacios

en blanco (tabuladores, espacios, retornos de carro) en su cdigo fuente, as que
la sentencia anterior es equivalente a lo siguiente:
final
String
CIC
=
new
String ("Centro de Investigacin en
Computacin");
Todo depende del estilo del programador y el compilador lo dejar pasar y tratar
la(s) lnea(s) como una sola sentencia.
Pgina 74 de 267
JAVA BSICO
Las sentencias (statements) o instrucciones, son lo que toscamente

podra decir la equivalencia de oraciones o sentencias en los
se
lenguajes
naturales.
Una sentencia forma una completa unidad para la ejecucin.
A continuacin tenemos los tipos de expresiones que pueden ser
sentencias
debido a que terminan con el punto y coma (;) que es el separador de sentencias
en el lenguaje Java.
Expresiones de asignacin (Assignment expressions)
Cualquier uso de ++ o -Invocaciones a mtodos
Expresiones de creacin de objetos.
Estas sentencias son denominadas sentencias de expresin (expression
statements)
Ver los siguientes ejemplos.
elValor = 5943.123; // expresin de asignacin

elValor++;
// sentencia de incremento
System.out.println("Hola Cuates!"); // sentencia de invocacin de mtodo

Auto tsuru = new Auto(Tsuru-GS1); //sentencia de creacin de objeto
Pgina 75 de 267
JAVA BSICO
Adems de las sentencias de expresin, hay otros dos tipos de sentencias. Las
sentencias de declaracin y las sentencias de control de flujo.
Sentencias de declaracin: Este tipo de sentencia sirve para
declarar una
variable. Hasta el momento ya ha visto ejemplos de sentencias de declaracin,

pero aqu tiene un ejemplo ms:
double otroValor = 2534.274;
// sentencia de declaracin
Los bloques: Un bloque es un grupo de cero o mas sentencias entre dos llaves
balanceadas, esto es, entre una llave que abre ( { ) y otra que cierra ( } ).
Un
bloque puede ser usado en cualquier lugar en donde una simple sentencia pueda
sea usada.
El programa BloquesEjemplo.java ilustra el uso de bloques:
public class BloquesEjemplo {

public static void main(String[] args) {
boolean condicin = true;
if (condicin) { // empieza bloque 1
System.out.println("La condicin es true.");
} // fin del bloque 1
else { // empieza bloque 2
System.out.println("La condicin es false.");
} // fin del bloque 2
} // fin del mtodo main
} // fin de la clase BloquesEjemplo
Pgina 76 de 267
JAVA BSICO
Los bloques de sentencias y el mbito (scope) de las variables.

En Java los bloques determinan la visibilidad y tiempo de vida de los nombres
definidos dentro de un mbito. Dicho mbito es determinado en Java, por la
colocacin de parejas de llaves {}. As por ejemplo
{
int q = 120;
// Solo q esta disponible
{
int w = -761;
// Ambas q y w estn disponibles
}
// Solamente q esta disponible
// w esta fiera del mbito
}
Una variable definida en un mbito esta disponible solamente hasta el final del
mismo.
Los bloques de sentencias y el mbito (scope) de las variables primitivas.
Hay que destacar que no es posible hacer lo siguiente en el lenguaje Java,
aunque en otros lenguajes como el C y C++ es permitido.
{
int w = 12;
{
int w = 96; // No esta permitido en Java
}
}
Si lo hace el compilador le recordar que la variable w ya ha sido definida. Los
diseadores del lenguaje Java determinaron que permitirlo podra conducir a
confusiones en los programas. Los bloques de sentencias y el mbito (scope) de
las variables primitivas.
Pgina 77 de 267
JAVA BSICO
El tiempo de vida de las variables esta inscrito dentro del bloque en que est
definido, por ejemplo:
{ // inicia bloque
int w = 96; //se define variable dentro del bloque
} // Finaliza bloque
System.out.println(w= + w ); // w no tiene alcance
ERROR
} // Fin del main
Si lo hace el compilador le recordar no encuentra el smbolo w y no lo dejar

compilar el programa.
Los bloques de sentencias y el mbito (scope) de las variables primitivas.
Si no redefine w y solo le asigna un nuevo valor ( w = 96 ) dentro del bloque
interno , ese valor permanece fuera del bloque, ya que en Java no esta permitida
la ocultacin de un valor dentro de un bloque.
public class BloquesEjemploDos {

{ // inicia bloque 1
int w = 12;
System.out.println("w= " + w);
{ // inicia bloque 2
w = 96; // se asigna otro valor a w
} // finaliza bloque 2
} // finaliza bloque 2
} // fin del main
} // fin de la clase BloquesEjemploDos
Salida:
w= 12
w= 96
w= 96
Pgina 78 de 267
JAVA BSICO
Los bloques de sentencias y el mbito (scope) de los objetos.

Los objetos en Java no tienen los mismos tiempos de vida que las variables
primitivas dentro de un mbito.
Cuando se crea un objeto usando el operador
new, este vive hasta que la ejecucin pase el final del mbito.
Por ejemplo.
{
String x = new String("esto es una cadena");
} // final del mbito o bloque
La referencia x se desvanece al final del bloque Sin embargo el objeto String el

cual esta siendo apuntado por x sigue todava ocupando memoria.
Dicho espacio de memoria es liberada por el Garbage Collector (Colector de
basura), que es un programa que libera los recursos ocupados por los objetos, y
es por eso que Java no tiene destructores.
Pgina 79 de 267
JAVA BSICO
2.7.1 De expresin de asignacin

La asignacin es una operacin que tiene como efecto dar valores a una variable:
V=E
Donde V denota una variable y E una expresin, y se lee V se hace E, o hacer V
igual a E o a V se le asigna E. Hay que recordar que esto no es una igualdad
relacional, ya que el operador de asignacin ( = ) no tiene nada que ver con el
operador ( == ). Es posible en Java al igual que en C y C++ las hacer las
"combinaciones taquigrficas" para realizar una operacin como por ejemplo la
suma y la asignacin con un solo operador (+=). La siguiente tabla muestra estas
combinaciones:
Operador
Uso
Descripcin
+=
op1 += op2
op1 = op1 + op2
-=
op1 -= op2
op1 = op1 op2
*=
op1 *= op2
op1 = op1 * op2
/=
op1 /= op2
op1 = op1 / op2
%=
op1 %= op2
op1 = op1 % op2
&=
op1 &= op2
op1 = op1 & op2
|=
op1 = op2
op1 = op1
^=
op1 ^= op2
op1 = op1 ^ op2
<<=
op1 <<= op2
op1 = op1 << op2
>>=
op1 >>= op2
op1 = op1 >> op2
>>>=
op1 >>>= op2
op1 = op1 >>> op2
op2
Tabla de operadores de asignacin de Java
Pgina 80 de 267
JAVA BSICO
2.7.2 De incremento o decremento

El resultado de utilizar stos operadores es generalmente un valor de tipo real o
entero y los operadores son:
Operador
Uso
Descripcin
Op1 + op2 Suma op1 y op2
Op1 op2
Resta op2 de op1
Op1 * op2
Multiplica op1 y op2
Op1 / op2
Divide op1 por op2
Op1
op2
+ op
Indica un valor positivo
- op
La negacin aritmtica de op
++
Op ++
Incrementa op en 1: evala el valor antes de incrementar
++
++op
Incrementa op en 1: evala el valor despus de

decrementar
--
Op--
Decrementa op en 1: evala el valor antes de

decrementar
--
--op
Decrementa op en 1: evala el valor despus de

decrementar
% El resto de dividir op1 por op2
Tabla de operadores aritmticos en Java
El siguiente ejemplo hace uso de los operadores aritmticos, y crea la clase

OpAritmeticos en el paquete operadores con package operadores. Luego para
utilizar la clase utilizamos la sentencia import operadores. OpAritmeticos
y por
supuesto tienes que configurar tu variable de ambiente classpath, o agregar la ruta

de clases en el entorno de desarrollo IDE que este utilizando, veamos:
Pgina 81 de 267
JAVA BSICO
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
/**
Programa de Java que te ensea a utilizar los operadores
aritmticos. Observa que la clase pertenece al paquete
operadores.
@autor CIC
@versin 1.0
Archivo: OpAritmeticos.java
*/
package operadores;
public class OpAritmeticos {
double x,y;
public OpAritmeticos (double x, double y) {
this.x = x;
this.y = y;
}
public String opera1() {
String s = " x + y =" + (x + y) + "\n";
s += " x - y =" + (x - y) + "\n";
s += " x * y =" + (x * y) + "\n";
s += " x / y =" + (x / y) + "\n";
s += " +x =" + (+x) + "\n";
s += " -x =" + (-x) + "\n";
return s;
} // fin de opera1()
25.
26.
27.
28.
29.
30.
31.
\n\n");
32.
33.
34.
35.
36.
public void opera2() {

double x1, x2;
x1 = x;
x2 = x;
System.out.println ("Valores inciales de x1 y x2 son:\n" +
"x1 = "+ x1 + " x2 = " + x2);
System.out.println("Operadores aritmticos de pre incremento y pos incremento
for ( int i=1; i <= 10; i++ )
System.out.println(" i = " + i
" ++x1 = " + (++x1) +
" x2++ = " + (x2++) );
}// fin de opera2()
Pgina 82 de 267
JAVA BSICO
37.
public void opera3() {
38.
double y1, y2;
39.
y1 = y;
40.
y2 = y;
41.
System.out.println("Valores inciales de y1 y y2 son:\n" +
42.
"y1 = "+ y1 + " y2 = " + y2);
43.
System.out.println("Operadores
aritmticos
de
predecremento
posdecremento \n\n");
44.
for ( int i=1; i <= 10; i++ )
45.
System.out.println(" i = " + i +
46.
" --y1 = " + (--y1) +
47.
" y2-- = " + (y2--) );
48.
} // fin de opera3()
49.
} // fin de la clase OpAritmeticos
________________________________________
50.
/**
51.
* Programa de Java que te ensea a utilizar los operadores
52.
* aritmticos. Observa que la clase pertenece al paquete
53.
* estndar, y hace uso de la clase OpAritmeticos que se
54.
* encuentra en la clase operadores.
55.
* @autor CIC
56.
* @versin 1.0
57.
* Archivo: UsaOperadoresAritmeticos.java
58.
*/
59.
import operadores. OpAritmeticos;
60.
class UsaOperadoresAritmeticos {
61.
OpAritmeticos op = new OpAritmeticos( 10 , 20);
62.
public static void main ( String[] args ) {
63.
UsaOperadores usa = new UsaOperadores();
64.
System.out.println(" Ejemplo de operadores \n" +
65.
" Operadores aritmticos \n" +
66.
usa.op.opera1() );
67.
usa.op.opera2();
68.
usa.op.opera3();
69.
System.out.println("\n\n Fin del programa ");
70.
} // fin del main()
71.
}// fin de la clase UsaOperadoresAritmeticos72.
Pgina 83 de 267
JAVA BSICO
La salida del programa

UsaOperadoresAritmeticos es:
Ejemplo de operadores
Operadores aritmticos
x + y =30.0
x - y =-10.0
x * y =200.0
x / y =0.5
+x =10.0
-x =-10.0
Valores inciales de x1 y x2 son:
x1 = 10.0 x2 = 10.0
al
ejecutarlo
con
el
comando
java
Operadores aritmticos de pre incremento y pos incremento

i = 1 ++x1 = 11.0 x2++ = 10.0
i = 2 ++x1 = 12.0 x2++ = 11.0
i = 3 ++x1 = 13.0 x2++ = 12.0
i = 4 ++x1 = 14.0 x2++ = 13.0
i = 5 ++x1 = 15.0 x2++ = 14.0
i = 6 ++x1 = 16.0 x2++ = 15.0
i = 7 ++x1 = 17.0 x2++ = 16.0
i = 8 ++x1 = 18.0 x2++ = 17.0
i = 9 ++x1 = 19.0 x2++ = 18.0
i = 10 ++x1 = 20.0 x2++ = 19.0
Valores inciales de y1 y y2 son:
y1 = 20.0 y2 = 20.0
Operadores aritmticos de pre decremento y pos decremento
i = 1 --y1 = 19.0 y2-- = 20.0
i = 2 --y1 = 18.0 y2-- = 19.0
i = 3 --y1 = 17.0 y2-- = 18.0
i = 4 --y1 = 16.0 y2-- = 17.0
i = 5 --y1 = 15.0 y2-- = 16.0
i = 6 --y1 = 14.0 y2-- = 15.0
i = 7 --y1 = 13.0 y2-- = 14.0
i = 8 --y1 = 12.0 y2-- = 13.0
i = 9 --y1 = 11.0 y2-- = 12.0
i = 10 --y1 = 10.0 y2-- = 11.0
Fin del programa
Pgina 84 de 267
JAVA BSICO
2.7.3 De invocacin a un mtodo

Un mtodo es: Un aparato de cdigo que tiene un nombre, recibe parmetros o
argumentos, contiene sentencias o instrucciones que cumplen con una funcin, de
acuerdo al mtodo elegido, y por lo regular devuelve un valor.
La sintaxis de un mtodo es:
Tipo_Valor_devuelto nombre_mtodo ( lista_argumentos ) {

bloque_de_codigo;
}
Por ejemplo:
int resta ( int num1, int num2 ){
int result = a - b;
return result;
Mi mtodo se llama resta,} recibe como parmetros num1 y num2 y devuelve como
resultado un valor entero.
Pgina 85 de 267
JAVA BSICO
2.7.4 De creacin de un objeto
La asignacin de objetos incluye el operador new, el cual es usado para invocar al

constructor de la clase del objeto que se quiere instanciar, ejemplo:
int num = 123;
Long unodostres = new Long (num);
2.7.5 De control de flujo.
Sentencias de control de flujo.
Estas sentencias regulan el orden en el cual las
sentencias deben ser ejecutadas. Este es tema posterior de este curso.
Pgina 86 de 267
JAVA BSICO
3. CLASES Y OBJETOS
3.1 Definicin de clase Estructura de una clase
Clase: Es una descripcin de atributos y comportamientos de un conjunto de
objetos similares. Los objetos de una clase o tipo determinado comparten los
mismos comportamientos y atributos. Las clases actan en forma muy parecida a
una plantilla o molde para galletas en el sentido de que una clase se utiliza para
crear o instanciar objetos.
Los atributos son caractersticas externas y visibles de una clase. El color

de los ojos y del cabello son ejemplos de atributos.
Un comportamiento es la accin que realiza un objeto cuando pasa un
mensaje o en respuesta a un cambio de estado: es algo que realiza un
objeto.
Un objeto puede ejercer el comportamiento de otro objeto ejecutando una
operacin sobre este ltimo. Los trminos llamada a mtodo, llamada a
funcin o paso de mensaje se utilizan en lugar de realizar una operacin,
cada una de estas acciones activa el comportamiento de un objeto
Pgina 87 de 267
JAVA BSICO
La sintaxis de una simple definicin o declaracin de clase es:

[ modificadores ] class nombreclase [extends claseSuperior ]
[implements interfaz1, interfaz2, ...interfaz ]
{
cuerpo
}
Donde:
Modificadores: es opcional y puede ser uno ms de las siguientes tres palabras
reservadas:
{ public, abstract, final, synchronizable }
Class: es una palabra reservada que se utiliza para definir o declarar una clase
nombre-clase: es cualquier identificador vlido
Extends: es una palabra reservada que indica si la clase tiene herencia o es
subclase o extensin de una claseSuperior o superclase
ClaseSuperior: es un identificador o nombre de la superclase de la que hereda
atributos y comportamientos
Implements: es una palabra reservada que indica si la clase implementa una o
varias interfaces
Cuerpo:
es una secuencia de declaraciones de variables, constantes,
constructores y mtodos dentro de llaves de mbito { } o bloque de sentencias.
Pgina 88 de 267
JAVA BSICO
3.1.1 Sentencia Packaged

Siempre que se desea crear un paquete de clases empleamos la palabra
reservada package con la siguiente sintaxis:
Siendo
esta
Package nombre_del_paquete,
definicin
la
primera lnea de cdigo no comentada dentro de un programa de Java, salvo

comentarios, dentro del archivo fuente.
Los paquetes pueden ser organizados, mediante importaciones, en una estructura
jerrquica anloga a la que se establece entre las clases al emplear los
mecanismos de herencia.
De hecho, las propias libreras del lenguaje estn
organizadas de este modo. El nombre del paquete refleja su origen y el lugar

que ocupa en la jerarqua.
La empresa Sun ha especificado un convenio de
nombres que consiste en comenzar el nombre de paquete con el nombre de

dominio usado en Internet por los creadores del paquete, pero con el orden
invertido. Adems el dominio de ms alto nivel (com, mil, org, mx, edu, etc. )
se escribe en maysculas.
A este nombre de dominio le sigue una serie de
nombres que especifican, en sentido descendente, la posicin del paquete en la

jerarqua.
Las distintas partes del nombre van separadas por puntos.
Todo se
ver ms claro con un ejemplo, el nombre:

MX.ipn.cic.ute.cursojava.utilerias
hace referencia a un paquete utileras, el cual depende en la jerarqua
de cursojava y esta desarrollado en el dominio
ute.cic.ipn.mx.Este convenio
hace posible evitar conflictos entre los nombres de los paquetes desarrollados en
diferentes lugares, al estar garantizada la no repeticin de los nombres de
dominio.
Una ventaja adicional es la facilidad para localizar las ltimas versiones
de un paquete y para contactar con sus desarrolladores.

Pgina 89 de 267
JAVA BSICO
3.1.2 Sentencia import
Esta sentencia nos sirve para no escribir toda la ruta del paquete en nuestra clase
java incluye esta sentencia para que se puedan ver ciertas clases o paquetes
enteros. La estructura de una sentencia import es la siguiente:
Import paquete1.[paquete2].(Nombre_clase I *)
El primer paquete en este caso va ser el nombre de un paquete de alto nivel el
paquete 2 es el nombre de un paquete opcional el cual va estar contenido en el
paquete exterior separndolo por un punto. Para indicar al compilador de java que
tiene que buscar el paquete completo se ingresa el nombre de la clase o un
asterisco al final de la sentencia.
Pgina 90 de 267
JAVA BSICO
3.2 Miembros de una clase.

3.2.1 Campos (fields)
Los atributos se convierten en variables miembro de la clase (tambin se les
conoce
en algunos ambientes como campos
o fields).
Los atributos
se
representan en UML, dentro del rectngulo de la clase abajo del nombre de la

clase.
Nombre de la clase
Atributo: Tipo= valor_inicial
La variable miembro de una clase es muy similar al concepto clsico de una

variable de programacin. Una variable miembro tiene la siguiente sintaxis.
[ mbito ] Tipo nombreVariable = [ valor_inicial]
Ejemplos:
public int x = 20;
private short sh = 100;
protected byte bt = 15;
long lo = 1000000;
float y = 10.3;
private double d = 3.141659;
public boolean b = x > y ;
char car = @;
Tambin un tipo puede ser una de una clase especfica de objetos, aqu la clase
se comporta como si fuera un tipo de dato abstracto, por ejemplo:
Date
Persona
String
Baln
Galleta
etc.
Pgina 91 de 267
JAVA BSICO
Ejemplos
private Date fechanac = new Date ( 01, 13, 1961 1900

);
public Persona oscar = new Persona( nombre , fechanac
);
String nombre = new String( Oscar Alejandro Gonzlez
Bustamante );
protected Balon pelota = new Balon( Football Socker );
protected Galleta marinela = new Galleta(Principe);
Pgina 92 de 267
JAVA BSICO
3.2.2 Mtodos (Methods)

Los comportamientos se convierten en mtodos miembro de la clase ( tambin se
les conoce en algunos ambientes como operaciones ). Su representacin en
UML, es dentro del rectngulo de la clase, debajo los atributos de la clase.
Nombre de la clase
Atributo: Tipo = valor_inicial
Metodo(lista_de_parametros: valor_de_retorno
El concepto de mtodo miembro de una clase es similar al concepto clsico de

una funcin de programacin.
Un mtodo es un conjunto de sentencias encargadas de implementar el

comportamiento del objeto
y todos
los mtodos deben tener las siguientes
caractersticas:
Los mtodos tienen un nombre (identificador).
Pueden tener o no una lista_de_parametros ( que son un conjunto de

parejas Tipo nombre separados por coma ).
Tienen un cuerpo (conjunto de sentencias) delimitado por llaves { }.
Pueden o no regresar un valor de algn tipo de dato primitivo o definido por

el usuario, por lo tanto tienen un Tipo_de_regreso.
Tienen un mbito de acceso y pueden ser;

default.
private, public, protected,
Pgina 93 de 267
JAVA BSICO
Ejemplo:
De un
mtodo que se llama convierteBinarioLong(long lnum) que devuelve o
regresa una cadena de tipo String de 0's y 1's al operar su parmetro entero
largo long lnum con corrimiento de bits << y con el operador &. Si el valor
resultante es diferente de cero se concatena un 1 a la cadena con el mtodo
append() y en caso contrario se concatena un 0.
Finalmente la cadena
modificable StringBuffer es convertida a una cadena no modificable con el mtodo

toString() y eso es lo que regresa el mtodo. Su mbito es privado y es un metodo
esttico.
Pgina 94 de 267
JAVA BSICO
3.2.3 Constructores ( Constructors )

Los mtodos son algo parecido a las funciones del lenguaje C /C++, pero en Java
no se permiten colocar mtodos fuera de la definicin de clase. Con los mtodos
implementamos el comportamiento de los objetos. Hay varios tipos de mtodos:
Mtodos de instancia. Son miembros de la clase y son mtodos que pueden ser
utilizados cuando se crea un objeto de la clase a la que pertenecen, esto es,
cuando se crea una instancia de la clase.
Mtodos de clase. Son miembros de la clase y son mtodos que pueden ser
invocados sin necesitar crear una instancia de la clase, y los identificamos
fcilmente porque tienen el modificador.
Mtodos constructores. Como veremos ms adelante, son mtodos con el
nombre de la clase y que son invocados al instanciar un objeto o crear un ejemplar
de la clase al que pertenecen con el operador new.
La sintaxis de una simple declaracin de un mtodo es:
[modificadores]
tipo-de-retorno nombre-mtodo
(lista-deparmetros) [ throws
claseExcepcion1,.., claseExcepcionN ]
{
cuerpo
}
Donde:
Modificadores: es opcional y puede ser uno ms de las siguientes ocho palabras
llave:
{static, abstract, final, native, synchronized, public, protected,
private }
Tipo-de-retorno: es cualquier nombre de clase o una de las siguientes nueve
palabras reservadas:
{void, boolean, byte, char, short, int, long, float, double }
Pgina 95 de 267
JAVA BSICO
nombre-mtodo: es cualquier identificador vlido

Lista-de-parmetros: es una secuencia de declaraciones de parmetros
[ throws claseExcepcion1,.., claseExcepcionN ] es una lista de posibles
excepciones que en un momento dado el cdigo del mtodo puede lanzar.
Cuerpo: es una secuencia de declaraciones de variables e instrucciones que son
ejecutadas por el mtodo cuando se le invoca.
Ejemplo:
public static void main(String args[]) throws IOException
{
/* aqu van las sentencias del cuerpo */
}
Vamos a aprovechar el ejemplo para definir un concepto importante conocido

como firma del mtodo.
Firma de un mtodo: Es la definicin del mtodo, excluyendo el cuerpo, es algo
parecido al concepto de funcin prototipo del lenguaje C. En el ejemplo anterior, la
firma del mtodo es:
public static void main(String args[]) throws IOException
El concepto es importante, porque la documentacin de las API's de Java vemos

listadas, cientos de miles de firmas de mtodos y las clases a los que pertenecen.
Pgina 96 de 267
JAVA BSICO
3.4 Proteccin de miembros.

Java hace uso de modificadores para la proteccin de cada uno de los miembros
que utiliza, entre los cuales podemos identificar las siguientes:
public: Es una variable pblica. Esta puede ser accesible en el paquete

donde fue declarada, o en cualquier otro paquete.
protected: Es una variable protegida. Es accesible solo por aquellos
mtodos que se encuentren en el mismo paquete o bien por las subclases
que hereden de la clase en donde se encuentra declarada.
prvate: Es una variable privada. Solo los mtodos de clase donde sta
definida pueden acceder a ella.
static: Es una variable esttica. Ser una variable permanente. Solamente
un valor del campo existe para todas las instancias de la clase (variable de
clase). Por lo tanto slo hay una variable con ese nombre para todas las
instancias del objeto.
La variable ser instanciada en tiempo de
compilacin.
transient: Es una variable declarada transitoria y no forma parte del estado
permanente o estado persistente de un objeto.
volatile: Es una variable que se modifica en forma asincrnica, o sea se
recarga y almacena en memoria cada vez que se recarga. Puede ser
modificado por hilos asincrnicos
final: Es una variable final. Por lo tanto solo podr tener un valor y ste no
lo podr cambiar o no podr modificarse. Este modificador se utiliza para
especificar una constante. Las constantes se especifican, por lo general,
como finales, estticas y pblicas.
friendly: Es el acceso por omisin o acceso de paquete.
private protected: Es una variable privada y protegida. Mezcla de las dos
cosas, por tanto, cuando declaramos una variable de este tipo dentro de
una clase slo podrn acceder a ella los mtodos de las subclases que la
deriven y no podrn acceder a ella otras clases del mismo paquete.
Pgina 97 de 267
JAVA BSICO
3.5 Constructores y creacin de objetos

Creacin de objetos
Objeto. Un objeto es una cosa, generalmente extrada del vocabulario del
espacio del problema o del espacio de la solucin.
Todo objeto tiene:
Identidad (puede nombrarse o distinguirse de alguna manera de otros
objetos)
Estado (generalmente hay algunos datos asociados a l)
Comportamiento (se pueden hacer cosas al objeto, y l puede a su vez
puede hacer cosas a otros objetos)
Objeto = atributos + comportamientos + identidad
Creacin de Objetos. Todo en Java se trata como un objeto. Se puede

manipular objetos a travs de handles (referencias, identificadores)
El handle o referencia no necesariamente est conectado a un objeto.
Ejemplo:
String s;
Solo es creada la referencia pero hay que inicializarlo:
String s = Curso de Java;
Pgina 98 de 267
JAVA BSICO
Para conectar un handle o referencia a un objeto se usa la palabra llave new que
es un operador de Java y significa ms o menos lo siguiente crame un nuevo
objeto de ste tipo o, " crame una nueva instancia o ejemplar de ste tipo"
Ejemplo:
String s = new String (Curso de Java);
Recuerde lector que cuando se crea un objeto a eso se le conoce como
instanciacin de una clase o ejemplificacin de una clase.
El caso de objetos de la clase String es especial, porque puede crearse o
instanciarse un objeto de esta clase sin el operador new, porque es una clase muy
utilizada.
El efecto de crear un objeto con el operador new se traduce en la asignacin de
memoria para ese objeto en el heap de la RAM y como veremos ms adelante, en
la invocacin o llamada al constructor de la clase a la que pertenece el objeto.
Pgina 99 de 267
JAVA BSICO
3.6 Niveles de acceso para una clase
Cada una de las clases que pueden proteger
cada uno de sus mtodos y
variables contra el acceso de otras variables. Este aspecto es muy importante

cuando se est trabajando con informacin muy delicada.
Tipos de acceso para una clase:

public: Este tipo de clase como su nombre lo indica son accesibles a cada
una de las variables y mtodos desde otras clases ya sea por herencia o
directamente. Este tipo de clases son accesibles desde el paquete que
fueron declaradas y para poder acceder de otros paquetes primero se
tienen que importar para hacer uso de ellas.
protected: En este tipo de clases solo las subclases de la clase pueden
acceder a las variables y mtodos de instancia protegidos.
prvate: Las variables y mtodos de este tipo solo pueden ser accesibles
desde dentro de la propia clase y no desde las subclases.
abstract: este tipo de clase no se instancia, se utiliza como una clase base
para la herencia.
final: No puede declarar subclases, esto es, ninguna otra clase puede
heredar de sta. En la jerarqua de clases stas se encontrarn en la parte
inferior de la jerarqua.
Synchronizable: Significa que todos los mtodos que acceden a esta clase
lo hacen de forma sincronizada, o sea, que slo podrn entrar de uno en
uno dejando en exclusin mutua uno de los mtodos para que operen con
la clase.
Pgina 100 de 267

JAVA BSICO
3.7 Niveles de acceso para un miembro

Las palabras reservadas para controlar el acceso definen quin tiene permitido ver
y acceder los mtodos y atributos. En general, estos niveles de acceso se ubican
en tres categoras:
private: nivel que slo permite el acceso a la clase.
protected: nivel que slo permite el acceso a la clase y a las hijas.
public: nivel que permite el acceso general.
Los mtodos y atributos protegidos son aquellos a los cuales se desea que
nicamente las subclases tengan acceso. Estos mtodos no deben hacerse
pblicos. Tan slo quienes tengan un conocimiento amplio de la clase deberan
utilizar los mtodos y atributos protegidos.
Cualquier atributo no constante y los mtodos dedicados exclusivamente a la
clase deben establecerse como privados. El acceso privado impide que cualquier
otro objeto, excepto el objeto mismo, llame al mismo. No establezca como
protegido solamente para aquellos mtodos que usted sabe que sern requeridos
por alguna subclase. De lo contrario, utilice acceso pblico o privado. Esta rgida
prctica significar que tal vez ms tarde tendr que regresar al cdigo por
cambiar el nivel de acceso al mtodo. No obstante, esto produce un diseo ms
seguro que aquel que deja abierto el acceso a una subclase.
Regresar a cambiar los niveles de acceso podra parecer una mala prctica. Sin
embargo, las jerarquas de herencia no deben ocurrir nunca por accidente. En vez
de ello, las jerarquas deben desarrollarse naturalmente conforme usted programe.
No hay por qu avergonzarse de reorganizar las jerarquas con el paso del tiempo.
La programacin orientada a objetos real es un proceso iterativo.
Sin embargo, recuerde que una regla de oro es hacer todo privado. Habr casos
en los cuales esto no ser funcional para usted. Todo depende de lo que tenga
que programar. Por ejemplo, si usted vende bibliotecas genricas, de clases sin
Pgina 101 de 267
JAVA BSICO
proporcionar el cdigo fuente, tal vez tenga que establecer todo como protegido de
manera predeterminada tonel propsito de que sus clientes puedan usar la
herencia para extender sus clases.
De hecho, habr ocasiones en que tendr que disear una subclase pensando en
la herencia. En tales casos es conveniente establecer un protocolo de herencia,
que es una estructura abstracta visible solamente a travs de los elementos
protegidos de la clase. La clase madre llamar a estos mtodos, y la clase hija
puede redefinirlos para modifica su comportamiento. En la siguiente leccin ver
un ejemplo.
Con estas definiciones y reglas, es sencillo comprender que los mtodos y
atributos protegidos y pblicos son los ms importantes para la herencia.
Pgina 102 de 267

JAVA BSICO
3.7.1 Acceso privado
Este acceso se utiliza solo para declarar miembros que van a ser utilizados por la
clase incluyendo cada uno de sus miembros. La estructura de una clase privada
es la siguiente.
class ejemplo {
prvate int varible_privada;
prvate void metodoprivado(){
System.out.println(Metodo privado);
}
3.7.2 Acceso protegido
Protected: Un miembro con el modificador protected se parece al acceso por

omisin, pero otorga cierto acceso privilegiado a las subclases de otros
paquetes. Frecuentemente los mtodos se crean para utilizarse dentro de la
propia clase (y no para su utilizacin general). Si se declaran como protected las
podremos utilizar dentro de la clase y todas sus subclases.
3.7.3 Acceso de paquete

Este acceso es el ltimo que se obtiene al no especificar ningn otro nivel de
acceso a los miembros. Este nivel de acceso permite que las clases del mismo
paquete que la clase accedan a sus miembros.
Pgina 103 de 267

JAVA BSICO
3.7.4 Acceso pblico

public: El modificador public no restringe el acceso. Cualquier parte del cdigo
puede acceder a clases, mtodos y variables de miembros.
Las subclases las heredarn, independientemente de que se encuentren en
el mismo paquete o no. Esto permite a una subclase acceder a esos
miembros solamente en instancias de la subclase.
Cualquier clase del mismo paquete podr acceder a ellas, pero en caso
contrario no sern accesibles.
Pgina 104 de 267

JAVA BSICO
3.8 Recursividad
Los mtodos y atributos recursivos se definen en la clase madre o en cualquier
otro antepasado, pero no en la clase hija. Al acceder al mtodo o al atributo, el
mensaje se enva hacia arriba en la jerarqua hasta que se encuentra una
definicin de mtodo. El mecanismo es el mismo que el que vimos en la seccin
sobre los mtodos y atributos redefinidos.
Los mtodos redefinidos tambin podran comportarse de manera recursiva.
Aunque un mtodo redefinido aparecer en la clase hija, la mayora de los
lenguajes orientados a objetos proporcionan un mecanismo que permite a un
mtodo redefinido llamado a la versin del mismo que se encuentra en la clase
madre (o en algn antepasado). Esta capacidad da la oportunidad de aprovechar
la versin de la superclase y definir nuevos comportamientos en la versin de la
subclase. En Java, la palabra reservada super permite tener acceso a la
implementacin de la clase madre. En la seccin siguiente tendr oportunidad de
utilizar super.
Pgina 105 de 267

JAVA BSICO
3.9 Mtodos sobrecargados

Cuando tenemos necesidad de que un mtodo en una clase tenga el mismo
comportamiento para distintos tipos de datos para sus argumentos, y no queremos
cambiar el nombre del mtodo, utilizamos la propiedad de sobrecarga de mtodos,
ver siguiente ejemplo: Sobrecarga de mtodos privados de una clase que obtienen
el cubo de un nmero de formas diferentes:
1. /** Programa de java que ejemplifica el uso

2. * de las clases con mtodos sobrecargados
3. * para as demostrar esta propiedad.
4. * @autor Oscar A. Gonzlez Bustamante
5. * @version 1.0
6. * Fecha : 02/07/2002
7. */
8.
9. class Sobrecarga {
10.
11. private double x;
12.
13.
14. private double cubo(double y )
15. {
16. return y * y * y ;
17. }
18.
19. private double cubo(Sobrecarga z )
20. {
21. return Math.pow(z.x , 3);
22. }
23.
24. private double cubo (double base , double potencia )
25. {
26. return Math.exp(potencia * Math.log(base));
27. }
28.
29. public static void main (String argumentos[] ) {
30.
31. Sobrecarga s = new Sobrecarga();
32. s.x = 10.0;
33.
34. System.out.println("\n\t 10 al cubo es: "+ s.cubo(10) +
35. "\n\t 10 al cubo es: "+ s.cubo(s) +
36. "\n\t 10 al cubo es: "+ s.cubo(10,3) +
37. "\n Fin del programa");
38. }
39.
}// fin de Sobrecarga
La salida del programa al ejecutar el comando java Sobrecarga es:
Sobrecarga java.lang.StringBuffer
10 al cubo es: 1000.0
10 al cubo es: 1000.0
10 al cubo es: 1000.0000000000007
Fin del programa
Pgina 106 de 267

JAVA BSICO
Anlisis del programa.

Vemos que la clase Sobrecarga tiene tres mtodos con el mismo nombre; cubo,
pero cada uno con tres firmas diferentes, esto es, se distinguen uno del otro del
tipo de parmetros que recibe cada uno:
private double cubo(double y )

private double cubo(Sobrecarga z )
private double cubo (double base,
double potencia )
En los tres casos todos son private double cubo pero cambian en cuanto a la
lista de parmetros, ya que uno recibe un double y, otro recibe una referencia a
Sobrecarga z, y los ltimos dos parmetros doble base, doble potencia. En las
lneas 34 a la 36 del cdigo se muestra como se invoca a cada uno de estos
mtodos sobrecargados, variando el tipo de argumentos que le son enviados, as
para el primero se invoca con s.cubo(10), el segundo con s.cubo( s) y el ltimo
con dos argumentos de tipo double s.cubo( 10, 3. Por ltimo en la salida de la
invocacin del tercer mtodo da "10 al cubo es: 1000.0000000000007", la razn
es el error de precisin que tienen los mtodos Math.exp() y Math.log(), que se
debe tomar en cuenta cuando hagamos programas de alta precisin. La siguiente
figura muestra el diagrama de UML con JBuilder 9 versin de prueba:
Pgina 107 de 267

JAVA BSICO
Pgina 108 de 267

JAVA BSICO
4. PAQUETES
4.1 Definicin y uso de paquetes.
Qu es un paquete?
Siempre que se desea crear un paquete de clases empleamos la palabra
reservada package con la siguiente sintaxis:
Package nombre_del_paquete;
Siendo esta definicin la primera lnea de cdigo no comentada dentro de un

programa de Java, salvo comentarios, dentro del archivo fuente.
Los paquetes pueden ser organizados, mediante importaciones, en una estructura
jerrquica anloga a la que se establece entre las clases al emplear los
mecanismos de herencia. De hecho, las propias libreras del lenguaje estn
organizadas de este modo. El nombre del paquete refleja su origen y el lugar que
ocupa en la jerarqua. La empresa Sun ha especificado un convenio de nombres
que consiste en comenzar el nombre de paquete con el nombre de dominio usado
en Internet por los creadores del paquete, pero con el orden invertido. Adems el
dominio de ms alto nivel (com, mil, org, mx, edu, etc.) se escribe en
maysculas.
A este nombre de dominio le sigue una serie de nombres que
especifican,
en
jerarqua.
sentido
descendente,
la
posicin
del
paquete
Las distintas partes del nombre van separadas por puntos.
en
la
Todo se
ver ms claro con un ejemplo, el nombre:

MX.ipn.cic.ute.cursojava.utilerias
Hace referencia a un paquete utileras, el cual depende en la jerarqua
de cursojava y est desarrollado en el dominio ute.cic.ipn.mx.
Pgina 109 de 267
JAVA BSICO
Este convenio hace posible evitar conflictos entre los nombres de los paquetes
desarrollados en diferentes lugares, al estar garantizada la no repeticin de los
nombres de dominio.
Una ventaja adicional es la facilidad para localizar las
ltimas versiones de un paquete y para contactar con sus desarrolladores.
Creacin y uso de paquetes ( package / import )

Como habamos dicho la seccin anterior, siempre que se desea crear un paquete
de clases empleamos la palabra reservada package y sta debe ser la primera
lnea de cdigo no comentada dentro de un programa de java.
Es posible hacer que parte de las clases y las interfaces contenidos en un paquete
sean utilizados desde fuera del paquete.
Para ello, es necesario que dichas
clases e interfaces hayan sido definidos como public.

Para acceder a una clase de otro paquete se emplea la palabra clave import del
siguiente modo:
Import
nombre_del_paquete.Nombre_de_la_clase:
As, si se quiere importar la clase Escri
del paquete
cuyo nombre dbamos
antes como ejemplo, habra que hacer:

import MX.ipn.cic.ute.cursojava.utilerias.Escri;
Una vez importada la clase, se puede usar su nombre sin el nombre del paquete,
a menos que exista una clase con el mismo nombre en el paquete que contiene el
import , o que exista un conflicto de nombres con otra clase importada desde otro
paquete.
Pgina 110 de 267

JAVA BSICO
Si se quieren importar varias clases de un mismo paquete, el hacerlo clase por

clase puede resultar muy engorroso.
Con el fin de evitar stas repeticiones se ha previsto la posibilidad de emplear un
comodn en la parte del nombre de clase en la sentencia import
import MX.ipn.cic.ute.cursojava.utilerias.*;
Esto hace que todas las clases e interfaces pblicas del paquete especificado
sean importados al paquete actual.
El siguiente ejemplo es ilustrativo:
Tenemos las dos clases pblicas A y P en la carpeta:
C:\cursojava\mascarones\alumnitos
Estas forman parte del paquete de clases package mascarones.alumnitos; se
compilan
D.class y
generan
las
unidades
de
compilacin
A.class,
C.class,
P.class.
Tenemos tambin una clase B en la carpeta:

C:\jdk1.3\ejemplos
(aunque puede ser cualquier carpeta)
que utiliza las clases publicas A y P
disponibles en el paquete mascarones.alumnitos gracias a la utilizacin de la

instruccin import mascarones.alumnitos.*; que debe ser tambin la primera
lnea no comentada del programa.
Ahora para que todo est bien, tenemos que modificar la variable de ambiente
CLASSPATH agregndole C:\cursojava que es la carpeta donde inicia la ruta de
clases, al final de la instruccin de esa variable de ambiente, as:
Pgina 111 de 267

JAVA BSICO
CLASSPATH=.;C:\jdk1.3\bin;C:\jdk1.3\lib\tools.jar;C:\jdk1.3\lib\dt.jar;C:\j
dk1.3\lib;C:\cursojava
As tanto el compilador javac.exe y el intrprete java.exe pueden localizar las
clases definidas por el usuario en el paquete mencionado. Al compilar todos los
programas y ejecutarlos produce
la salida que se muestra abajo. Ver los
siguientes cdigos y la figura.
/**
* Programa de Java que te ensea a construir
* mediante la palabra reservada package un paquete de clases.
* Solo las clases e interfaces pblicas sern miembros del
* paquete. En ste ejemplo solo la clase A es miembro del
* paquete mascarones.alumnitos. Las clases C y D no son miembros
* del paquete mascarones.alumnitos.
* @version 1.0
* Archivo: A.java
*/
package mascarones.alumnitos;
public class A {
public A() {
System.out.println("constructor mascarones.alumnitos.A() ");
C xc= new C();
D xd= new D();
}
}// fin de A
class C {
C() {
System.out.println("constructor mascarones.alumnitos.C() ");
}
}//fin de C
class D {
D() {
System.out.println("constructor mascarones.alumnitos.D() ");
}
}//fin de D
Pgina 112 de 267

JAVA BSICO
Para compilar el programa A.java usa el comando javac A.java, el cual te va a

producir los archivos A.class, C.class y D.class. Todos deben estar en la
carpeta:
C:\cursojava\mascarones\alumnitos.
/**
* Programa de Java que te ensea a construir
* mediante la palabra reservada package un paquete de clases.
* paquete. En ste ejemplo solo la clase P es miembro del
* paquete mascarones.alumnitos.
* @version 1.0
* Archivo: P.java
*/
package mascarones.alumnitos;
public class P {
public P() {
System.out.println("constructor mascarones.alumnitos.P() ");
}
public static void escribe(String s) {
System.out.println(s);
}
} // fin de la clase P
Pgina 113 de 267

JAVA BSICO
/**
* Programa de Java que te ensea a utilizar
* mediante la palabra reservada import un paquete de clases.
* paquete y son las que puedes utilizar en tu programa.
* En ste ejemplo solo la clase A y P son miembro del
* paquete mascarones.alumnitos, y las importamos con el
* caracter comodn asterisco. El archivo B.class puede
* ubicarse en cualquier directorio o carpeta de tu computadora.
* @version 1.0
* Archivo: B.java
*/
import mascarones.alumnitos.*;
public class B extends A {
B() {
System.out.println("Hola soy constructor B() ");
}
static void main(String args[]) {
B x = new B();
P y = new P();
y.escribe("saludo 1: Hola ");
P.escribe("saludo 2: Amigos.");
}
}// fin de la clase B
La salida del programa al ejecutar el comando java B es la siguiente:
constructor mascarones.alumnitos.A()
constructor mascarones.alumnitos.C()
constructor mascarones.alumnitos.D()
Hola soy constructor B()
constructor mascarones.alumnitos.P()
saludo 1: Hola
saludo 2: Amigos.
Fin del programa
Pgina 114 de 267

JAVA BSICO
4.2 Uso del API de programacin.
Un API es una interfaz de programacin de aplicaciones, que fue implementada

por los desarrolladores de java, brindando al programador los medios para
desarrollar sus aplicaciones, provee un grupo de clases, las cuales son tiles para
realizar cualquier tipo de tarea que sea necesaria dentro de un programa.
Una API est organizada en:
Clases
API
Paquetes
lgicos
Clases
Paquetes lgicos que a su vez cada paquete contiene clases, relacionadas entre
s. Existen muchas APIs, pero a continuacin mencionar las ms conocidas:
JAXP
Servlets
Hibernate
Para procesar XML's.
Para facilitar la implementacin de soluciones web.
Para facilitar la implementacin de persistencia.
En conclusin podemos decir que:

Interfaz de comunicacin
API
Componentes del software
Pgina 115 de 267

JAVA BSICO
4.3 Paquete java.lang
Las clases del paquete java.lang estn tan profundamente integradas en el

desarrollo de Java que ni siquiera debe indicarle al compilador que las importe.
Desde luego, ya se ha encontrado con varias de las clases que forman esta
biblioteca String, Thread y Exception, por nombrar algunos. En este paquete
encontrar varias categoras de clases.
Clases envolventes: Son clase que le permiten tratar tipos primitivos como
objetos reales, por ejemplo, los objetos int y float; reciben el nombre de Integer y
Float. Puede utilizar las clases envolventes para realizar conversiones entre
cadenas o tipos de datos especficos y las otras utilidades de conversin
numrica.
Compatibilidad de cadenas: Las clases String y StringBuffer le permiten
trabajar con texto Unicode. La clase String se usa cuando necesita texto
permanente de slo lectura; y la clase StringBuffer se usa cuando necesita texto
que pueda ser modificado.
Compatibilidad con multitarea: Las clases de apoyo se encuentran en
java.lang: Thread,
Runnable,
InheritableThreadLocal.
ThreadGRoup,
ThreadLocal
Con estas clases puede crear varios thread de
ejecucin en sus programas de Java.

Bibliotecas Math: Las clases Math y StrictMath proporcionan una coleccin de
funciones
matemticas
trigonomtricas
(seno,
para
coseno,
generar
nmeros
tangente,
etc.),
aleatorios,
funciones
funciones
logartmicas
exponenciales y clculos como encontrar el valor mximo y el mnimo. La clase

Math est optimizada para la velocidad.
Se garantiza que la clase StrictMath
producir los mismos resultados en todas las plataformas, como ciertos algoritmos
publicados.
Pgina 116 de 267

JAVA BSICO
Acceso al sistema: Algunas clases de este grupo (System, Runtime y Process)

proporcionan acceso a informacin y capacidades especficas de sistema. Otras
ayudan a la carga de programas de Java y a un alto nivel de seguridad:
ClassLoader, SecurityManager, Class y Package. La clase System es la que
encontr con anterioridad con System.out, para escribir mensajes.
Tambin
puede encontrar informacin como la memoria disponible y la posicin del entorno

de ejecucin a lo largo de estas clases. Las clases de acceso al sistema tambin
se usan para iniciar programas especficos de ciertas plataformas.
Errores y excepciones: Las clases base para el control de excepciones se
encuentran en el paquete java.lang: Throwable, Exception, Error y muchas de
sus subclases. Muchas de las subclases de excepcin se encuentran en paquetes
ms apropiados, como IOException en java.io.
Otros dos subpaquetes de Java usados con menos frecuencia que java.lang son
java.lang.ref y java.lang.reflect. El paquete java.lang.ref ofrece compatibilidad
con objetos de referencia, un modo de supervisar el uso de objetos para ayudar al
recolector de elementos no utilizados.
El paquete java.lang.reflect se usa para
la reflexin (la capacidad de preguntar a una clase sobre si misma).
Pgina 117 de 267

JAVA BSICO
4.3.1 Clase String
Una cadena o string es una secuencia de caracteres. Las palabras, sentencias y

nombres son cadenas. El mensaje "Hola, Mundo" es un string. Tambin un objeto
de la clase String es una cadena o string y es uno de los tipos ms simples y
utilizados en Java. Estos objetos no pueden cambiarse, esto es, una cadena de la
clase String es inmutable. El siguiente ejemplo muestra cmo puede manejarse
una cadena con un arreglo de caracteres y tambin con un objeto de la clase
String.
/**
* Ejemplo: programa de Arreglos y Strings (cadenas)
* Que muestra el uso de la clase
* String y de un arreglo de caracteres
* Archivo: ArreglodeCaracteres.java
*/
class ArreglosdeCaracteres{
// Prueba de el mtodo String.toCharArray() y de acceso a un arreglo de caracteres
public static void main(String args[])
{
String s = new String("ABCDEFG");
char[] a = s.toCharArray();
System.out.println("s = \"" + s + "\"\t\ta = \"" + a + "\"");
System.out.println("s.length() = " + s.length() +
"\t\ta.length = " + a.length);
for (int i=0; i<s.length(); i++)
System.out.println("s.charAt(" + i + ") = " +
s.charAt(i) + "\t\ta[" + i + "] = " + a[i]);
}
} // fin de la clase ArreglosdeCaracteres
La salida del programa al ejecutarlo con el comando java ArreglodeCaracteres es:
s = "ABCDEFG"
a = "[C@bd0108"
s.length() = 7
a.length = 7
s.charAt(0) = A
a[0] = A
s.charAt(1) = B
a[1] = B
s.charAt(2) = C
s.charAt(3) = D
s.charAt(4) = E
s.charAt(5) = F
s.charAt(6) = G
a[2] = C
a[3] = D
a[4] = E
a[5] = F
a[6] = G
Pgina 118 de 267

JAVA BSICO
Ejemplo 1
Haga el programa en Java tal, que dada una cadena con las letras del alfabeto
romano, "ABCDEFGHIJKLMNOPQRSTUVWXYZ, diga cuantas letras tiene la
cadena, que carcter se encuentra en la posicin 4, de el ndice de la letra Z , e
informe el cdigo hash de dicha cadena.
// Curso de Java Bsico

// Ejemplo 1 de cadenas o strings
public class Alfabeto

{
public static void main(String[] args)
{
String alfabeto = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
System.out.println(alfabeto);
System.out.println("Esta cadena contiene "+alfabeto.length()+" caracteres.");
System.out.println("El caracter en el indice 4 es "+ alfabeto.charAt(4));
System.out.println("El indice de el caracter Z es "+ alfabeto.indexOf('Z'));
System.out.println("El cdigo hash para esta cadena es " +
alfabeto.hashCode());
}// fin del main
}// fin de Alfabeto
La salida de ste programita es:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
Esta cadena contiene 27 caracteres.
El caracter en el indice 4 es E
El indice de el caracter Z es 26
El cdigo hash para esta cadena es -287815408
Pgina 119 de 267

JAVA BSICO
4.3.2 Clase StringBuffer
Una cadena o string puede tambin manejarse con la clase StringBuffer. Estos
objetos a diferencia de los de la clase String, si pueden cambiarse, esto es, una
cadena de la clase StringBuffer es susceptible a ser modificada, esto es, es
mutable. En los siguientes programas el participante manejar las cadenas con
algunos de los mtodos de la clase StringBuffer.
En los siguientes ejercicios el participante manejar las cadenas con los mtodos
de la clase StringBuffer.
Ejemplo 2. Haga el programa en Java que demuestre los mtodos length() y
capacity() de la clase StringBuffer.
//solucin al Ejemplo 8 de modificacin de cadenas con la clase StringBuffer

public class PruebaStringBuf
{ public static void main(String[] args)
{ StringBuffer buf = new StringBuffer(10);
System.out.println("buf = " + buf);
System.out.println("buf.length() = " + buf.length());
System.out.println("buf.capacity() = " + buf.capacity());
} // fin del main
} // fin de la clase PruebaStringBuf
Salida:
buf =
buf.length() = 0
buf.capacity() = 10
Pgina 120 de 267

JAVA BSICO
Ejemplo 3
Haga el programa en Java que demuestre los mtodos append() de la clase
StringBuffer.
//solucin al Ejemplo 9.0 de modificacin de cadenas con la clase StringBuffer
// Fecha: 22 agosto 2001
public class Pruebadeappend

{ public static void main(String[] args)
buf.append("El java");
buf.append(" es el mejor");
buf.append(" de los lenguajes");
} // fin del main
} // fin de la clase Pruebadeappend
La salida es:
buf = El java
buf.length() = 7
buf.capacity() = 10
buf = El java es el mejor
buf.length() = 19
buf.capacity() = 22
buf = El java es el mejor de los lenguajes
buf.length() = 36
buf.capacity() = 46
Finished executing
Pgina 121 de 267

JAVA BSICO
Ejemplo 4
Haga el programa en Java que ilustre como se pueden modificar los contenidos de
una variable de la clase StringBuffer con los mtodos append(), setCharAt(), e
insert().
// Fecha: 22 agosto 2001
public class Remplazandobuf
{
buf.append("El C fue el mejor de los lenguajes.");
buf.setCharAt(12, 'P');
buf.setCharAt(14, 'o');
buf.insert(15, "r");
buf.setCharAt(16,' ');
buf.setCharAt(17,' ');
} // fin del main
} // fin de la clase Remplazandobuf
La salida es:
buf = El C fue el mejor de los lenguajes.
buf.length() = 35
buf.capacity() = 50
buf = El C fue el Pejor de los lenguajes.
buf = El C fue el Peoor de los lenguajes.
buf = El C fue el Peoror de los lenguajes.
buf = El C fue el Peor r de los lenguajes.
buf = El C fue el Peor de los lenguajes.
Pgina 122 de 267

JAVA BSICO
Ejemplo 5 Haga el programa en Java que ilustre como se pueden convertir un

objeto de la clase StringBuffer a otro de la clase String
Public class PruebatoString
{
{
StringBuffer buf = new StringBuffer("era una poca de promesas,");
String str = buf.toString();
System.out.println("str = " + str);
System.out.println("str.length() = " + str.length());
buf.append(" " + str.substring(0, 17) + "tontos ingenuos,");
System.out.println("str = " + str);
} // fin del main
} // fin de la clase PruebatoString
La salida es:
buf = era una poca de promesas,
buf.length() = 26
buf.capacity() = 42
str = era una poca de promesas,
str.length() = 26
buf = era una poca de promesas, era una poca de tontos ingenuos,
buf.length() = 60
buf.capacity() = 86
str = era una poca de promesas
Pgina 123 de 267

JAVA BSICO
4.3.3 Clase Math

La clase math agrupa a todas las funciones de clculo matemtico, se ha creado
la clase math solo con el propsito de que aqu se agrupen todas las funciones
para el clculo, es una clase pblica, para que se pueda utilizar desde cualquier
parte del programa, y static, para no tener que inicializarla, permite hacer clculos
precisos.
Funciones Matemticas:
Math.abs( x ) Para int, long, float y double
Math.tan( double )
Math.sin( double )
Math.asin( double )
Math.cos( 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.max( a,b )
para int, long, float y double
Math.pow( a,b )
Math.round( x )
para double y float
Math.rint( double )
Math.random()
Math.min( a,b )
para int, long,
Math.E
devuelve un double
para la base exponencial
float y double
Math.PI
para PI
Pgina 124 de 267

JAVA BSICO
.abs
.tan
.sin
.cos
.atan
.exp
.sqrt
.floor
.pow
.rint
.min
.PI
.tan
.asin
.acos
.atan2
.log
.ceil
.max
.round
.random
Muestra el valor absoluto de la variable.

Sirve para calcular la tangente.
Calcula el seno de un ngulo.
Devuelve el coseno de un ngulo.
Calcula el arco tangente de la variable.
Calcula la potencia de una variable.

Calcula la raz de una variable, la cual debe ser positiva
Calcula el entero ms grande > o = a la variable.
Calcula la variable elevada a la potencia.
Cumple la funcin de redondear al entero mayor o igual al
estn en su argumento.
numero double que
Calcula el mnimo de la variable.

Permite hacer clculos con la variable PI de manera ms precisa.
Calcula la tangente de un ngulo.
Calcula el arco seno de la variable.
Calcula el arco coseno de la variable.
Devuelve el ngulo en radianes

Calcula el valor del logaritmo natural de la variable.
Calcula el entero ms pequeo o > a la variable
Calcula el mximo de la variable.
Redondea un double a un long.
Genera nmeros aleatorios.
Pgina 125 de 267

JAVA BSICO
4.4 Paquete java.util
Los paquetes java.util y java.math contienen clases con utilidades generales, las
cuales aparecen descritas en la documentacin de Sun. En el paquete java.util,
encontrar ayudas para la compatibilidad con tipos de datos abstractos (ADT)
llamada Collection Framework, para fechas y calendarios y algunas clases para
ayudar a la internacionalizacin de sus programas. Con el paquete java.math, hay
ayudas para las operaciones aritmticas con precisin arbitraria.
Adems hay varios subpaquetes de java.util, como:
java.util.jar
java.util.zip
Que ofrecen compatibilidad con archivos JAR (Java Archive), GZIP y ZIP.
java.util.logging la utilidad de registro bsica.
java.util.regex la biblioteca de expresiones regulares para comparar patrones.
java.util.pref que proporciona almacenamiento de las preferencias del usuario y la
aplicacin. En plataformas basadas en Microsoft Windows,
el
paquete
java.util.pref. Proporciona acceso al registro de Windows.

4.4.1 Arrays
Un arreglo es una estructura de datos homognea o conjunto de elementos del
mismo tipo. En Java se pueden manejar arreglos de elementos de tipo primitivo (8
tipos primitivos hay en Java) o arreglos de objetos. Los arreglos son variables con
ndice, y pueden ser unidimensionales, bidimensionales o n - dimensionales.
Pgina 126 de 267

JAVA BSICO
4.4.2 Creacin y uso de arrays
Creacin de arrays
Cuando creamos arrays en Java, necesitamos utilizar el operador new , para
reservar espacio en memoria para almacenar todos los elementos. As , de esta
manera se indica el nmero de elementos que tendr en cada dimensin. Se
crean los arrays de la siguiente forma:
Identificador = new tipo [ tamao ];
Identificador = new tipo [ tamao] ... [ tamao ];
Es necesario sealar que el primer elemento de un array tiene un ndice cero,
y el ltimo tiene un ndice (tamao - 1).
Tamao de un array.
System.out.println(El array a1 tiene + a1.length + elementos.);
Para conocer el tamao o nmero de elementos de un array se utiliza el atributo

length, de la siguiente forma:
Inicializacin esttica.
Es posible inicializar los elementos del array a la vez que se crean de la siguiente
forma:
// Declaracin e inicializacin esttica
String[] perrosFamosos = { Snoopy, Super Can, Fido, Patan,
Tribiln,
Scoobe Doo,Pluto, Rintintn, Lasie };
Pgina 127 de 267

JAVA BSICO
Abra sido equivalente que hiciramos:
String[] perrosFamosos = new String[8]; // declaracin

perrosFamosos[0] = Snoopy; // inicializacin
perrosFamosos[1] = Super Can;
perrosFamosos[2] = Fido;
perrosFamosos[3] = Patan;
perrosFamosos[4] = Tribilin;
perrosFamosos[5] = Scoobe Doo;
perrosFamosos[6] = Rintintn;
perrosFamosos[7] = Lasie;
Para un arreglo de tipo enteros

int[] a1 = { 1, 2, 3, 4, 5 }; // declaracin e inicializacin esttica
Abra sido equivalente que hiciramos:
int[] a1 = new int[5]; // declaracin

a1[0]= 1; // inicializacin
a1[1]= 2;
a1[2]= 3;
a1[3]= 4;
a1[4]= 5;
Pgina 128 de 267

JAVA BSICO
Tenemos el siguiente modelo de memoria cuando declaramos el arreglo a1 ver

siguiente Figura 4-1:
Zona de memoria Stack
a1
null
Zona de memoria Heap
Length
length
a1[0]
a1[1]
..
a1[4]
12
0
0
0
Figura 4-1: Tras declarar el array a1 se reserva espacio en la memoria stack para la referencia del
array.
Despus de usar el operador new para colocar espacio, se reserva memora heap
para el contenido del array. Los valores son inicializados automticamente a 0, si
no es que los inicializamos de forma explcita. Ver la Figura 4-2: del modelo de
memoria cuando tras colocar el espacio int[] a1 = new int[5].
a1
length
a1[0]
a1[1]
..
a1[4]
5
0
0
0
Figura 4-2: Modelo de memoria tras colocar espacio para el arreglo a1.
Pgina 129 de 267

JAVA BSICO
Por otra parte, para un array de objetos el espacio colocado es para contener una
referencia al objeto, no el objeto en s. Por ejemplo, veamos que al definir una
clase Calendario que contenga el nombre del mes y un nmero de das.
public class Calendario {
String mes;
int nodias;
Calendario (String mes, int nodias)
{
this.mes = mes;
this.nodias = nodias;
} // fin del costructor
}// fin de la clase calendario
Despus de definir la clase, se puede crear un array de esos elementos:

new Calendario[12]. El modelo de memoria tendr el aspecto de la Figura 4-3: al
asignar espacio Calendario c[] = new Calendario[12].

c

length
12
c[0]
Null
c[1]
null
..
c[11]
null
Figura 4-3: Estado de la memoria al asignar espacio al arreglo c.
Pgina 130 de 267

JAVA BSICO
Se observar que an no hay espacio reservado para objetos Calendario. Todo lo

que hay en el array es una referencia null. Esto no sucede hasta que se reserva
espacio mediante new Calendario(..) y se agregue el objeto a la matriz mediante
c[ x ] = ... el modelo de memoria no ser afectado.
c[ 0 ] = new Calendario("Enero", 31 );
c[ 1 ] = new Calendario("Febrero" , 28);
Acceso a los valores
Cuando se desea acceder a los valores de un array de tamao N, el primer
elemento se encuentra en la posicin 0 y el ltimo se encuentra en la posicin N
1. Cualquier intento de hacer referencia a un elemento que no est entre 0 y N -1
genera la excepcin ArrayIndexOutOfBoundsException.
Por ejemplo:
System.out.println( La mascota de Carlitos es su perro + perrosFamosos[ 0 ]
);
System.out.println( Este ao es bisiesto entonces el mes + c[ 1 ].mes +
tiene + c[ 1 ].nodias );
Pgina 131 de 267

JAVA BSICO
4.4.3 Arrays multidimensionales
Para la declaracin y creacin de un array de dos o ms dimensiones se requiere

el operador [] por cada dimensin que este tenga, as por ejemplo, una tabla de
dos dimensiones:
int [][] tabla; // declaracin de un array bidimensional
Para crear un array de dos dimensiones hay que indicar los tamaos de las dos
dimensiones. Por ejemplo, para declarar una tabla de 4 por 7 elementos se
utilizar la sentencia de Java:
int [][] tabla = new int[4][7]; // declaracin y creacin del
//array bidimensional de 4 por 7
Los arrays pueden tener ms de dos dimensiones. Por ejemplo para declarar un
array de tres dimensiones se hara:
int [][][] libro = new int[4][7][6];
Tamao de arrays multidimensionales.
El atributo length permite conocer el tamao de un array. Si un array tiene ms de
una dimensin cada dimensin tiene su propio tamao y se puede utilizar este
atributo length de la siguiente forma:
int [][][] libro = new int[4][7][6];
tamao = libro.length; // tamao de la primera dimensin, osea 4
tamao2 = libro[0].length; // tamao de la primera fila, es decir 7
tamao3 = libro[0][0].length; // tamao de la primera fila, primera
columna, osea 6
Pgina 132 de 267

JAVA BSICO
Acceso
Para acceder a cualquier variable del array de dos dimensiones hay que indicar en
qu posicin de cada una de las dimensiones se encuentra la variable a la que se
desea acceder, p. ej.:
tabla[1][3] = 46;
Ejemplo de arreglos bidimensionales y unidimensionales con inicializacin esttica
de un algoritmo que suma el total de los votos electorales, para cada uno de los de
cuatro partidos diferentes en cuatro estados diferentes, en base a la siguiente
tabla.
VOTOS
PARTIDO
VERACRUZ PUEBLA
DISTRITO
FEDERAL
ESTADO DE
MXICO
RIP
789
425
576
355
BOLILLO
734
765
733
543
SOLECITO
567
354
234
435
PAJARITO
454
546
345
523
Pgina 133 de 267

JAVA BSICO
Ahora veamos el cdigo fuente en lenguaje de programacin Java.

package ejemplos;
// Programa que suma el total de los votos electorales para cada uno de
// cuatro partidos diferentes en cuatro estados diferentes.
// Declaracin y asignacin esttica de valores al array bidimensional
public class Votos {
int votos[][] = {
{789, 425, 576, 355 },
{734, 765, 733, 543 },
{567, 354, 234, 435 },
{454, 546, 345, 523 }
};
// Declaracin y asignacin de valores a un arreglo unidimensional
// de cadenas
String nombrePartido[] = {"RIP", "BOLILLO", "SOLECITO", "PAJARITO"};
int sumaPartido[] = new int[4]; // variable para acumular la suma
// de votos por partido
int i, j; //variables ndices, i para filas-partidos,
// j para columnas - estados
public Votos() {
i = 0; // inicializamos contador de filas partidos
j = 0; // inicializamos contador de columnas estados
while(i <= 3) {
sumaPartido[i] = 0; // inicializamos con 0 las sumas de votos // de cada partido
while (j <= 3) {
// acumula la suma de votos por partido
sumaPartido[i] = sumaPartido[ i ] + votos[i][j]; // incrementamos contador de columnas - estados
j = j + 1;
} // fin del while o del ciclo interno con j como contador
i = i + 1; // incrementamos contador de filas - partidos
j = 0; // reiniciamos a cero la variable contador
// del ciclo interno
} //fin del while o del ciclo externo con i como contador
// escribimos los resultados de la suma de votos electorales
// por partido
i = 0; // volvemos a inicializar el contador para filas
while (i <= 3) {
System.out.print("La suma de votos electorales del partido "
+ nombrePartido[i] + " es igual a : " + sumaPartido[i]);
i = i + 1; // incrementamos contador de filas - partidos
} // fin del while del ciclo i como contador
public
static void
main(String[] args) {
4.4.4
Clase
Arrays.
new Votos(); //arranca el programa creando un objeto e
al constructor
En//invocando
tenemos
la clase Arrays, la cual
} //java.util
fin del mtodo
main
} // fin de la clase Votos
contiene un conjunto de mtodos
estticos que permiten manipular arrays. Hay cuatro mtodos bsicos:
Pgina 134 de 267

JAVA BSICO
Todos estos mtodos estn sobrecargados para los distintos tipos de datos
primitivos
para
objetos.
Adicionalmente
se
tiene
un
mtodo
simple asList() que hace que un array se convierta en un contenedor List, que
es una clase para manejar colecciones de objetos como un contenedor, lo cual es
tema para un curso avanzado de Java.
El siguiente ejemplo (ver figura abajo) hace uso de algunos de estos mtodos y
consta de las siguientes clases que manejan un arreglo de objetos, los ordena y
obtiene promedio, varianza, etc., contiene:
-
equals()
Para comparar la igualdad de dos arrays.
fill()
Para rellenar un array con un valor determinado.
sort()
Para ordenar el array
binarySearch()
Para bsqueda de un dato en un array
Persona.java para asignar valores de Nombre, apellido y edad

-Estudiante.java extiende Persona, asigna valores de calificacin y pasa los
dems valores a la clase Persona
-Mascarones.java ordena el arreglo por nombre y por calificacin, calcula los
valores de promedio, varianza, mnima y mxima calificacin
-usaEstudiante.java inicializa y asigna el arreglo, manda llamar las dems clases
e imprime el contenido del arreglo original, ordenado y los clculos de promedio,
varianza, etc.
Pgina 135 de 267

JAVA BSICO
Pgina 136 de 267

JAVA BSICO
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
import java.util.*;
import java.util.Collections;
/**
* Archivo: usaEstudiante.java 
* Descripcin: Te ensea a usar el ordenamiento de arreglos
* mediante el uso de colecciones de la clase List
* Copyright: Totalmente libre
* Empresa: El patito Feo Inc.
* @author Gerardo Gonzlez ( alumno del curso de Java )
* amplio y reviso: Oscar Alejandro Gonzlez Bustamante.
* @version 1.0
*/
public class usaEstudiante {
public static Estudiante[] est = new Estudiante[10];
//Inicializa y asigna el Arreglo
est[0]= new Estudiante("Gerardo","Gonzalez ",27,10.0);
est[1]= new Estudiante("Ramon ","Fernandez",30,9.99);
est[2]= new Estudiante("Rocio ","Espejo ",29,8.5);
est[3]= new Estudiante("Octavio","Garces ",29,10.0);
est[4]= new Estudiante("Mariana","Rosas ",33,6.9);
est[5]= new Estudiante("Ricardo","Lopez ",33,9.50);
est[6]= new Estudiante("Ernesto","Ramirez ",26,8.0);
est[7]= new Estudiante("Maribel","Juarez ",26,6.8);
est[8]= new Estudiante("Pedro ","Sandoval ",31,5.5);
est[9]= new Estudiante("Ricardo","Cedillo ",30,10.0);
//Crea una lista con el arreglo existente y asigna valores
List list = new ArrayList(Arrays.asList(est));
System.out.println("\n\t\tARREGLO ORIGINAL\n"); //Imprime arreglo original
System.out.print(" NOMBRE APELLIDO EDAD CALIFICACION\n\n");
for(int i=0; i<10; i++)
System.out.println(list.get(i));
//Manda llamar a clase Mascarones para ordenar
Mascarones nc = new Mascarones();
Collections.sort(list, nc);
//Ordenacion por nombre
//Imprime los elementos de la lista
System.out.println("\n\n\t\tARREGLO ORDENADO POR: NOMBRE\n");
for(int i=0; i<10; i++)
System.out.println(list.get(i));
Mascarones2 cc = new Mascarones2(est); //Nueva clase Mascarones2
cc.insertionSort();
//Llama a metodo insercion
System.out.println("\n\n\t\tARREGLO ORDENADO POR: CALIFICACION\n");
cc.display();
//Muestra el arreglo en clase Mascarones2
double promedio=0.0;
//Sobrecarga constructor para calculo de promedio, varianza, MaxCalif, MinCalif
cc.Mascarones2(promedio);
cc.displayFinal();
//Muestra los valores del calculo
} //Fin main()
} //Fin clase usaEstudiante
Pgina 137 de 267

JAVA BSICO
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
import java.util.*;
/**
* Archivo: Mascarones.java 
* Descripcin: Te ensea a usar el ordenamiento de arreglos
* mediante el uso de la interface Comparator que implementa el
* mtodo compare(). La clase Mascarones2 que esta dentro de este
* archivo, realiza el cculo de los estadsticos y el ordenamiento 
* Copyright: Totalmente libre
* Empresa: El patito Feo Inc.
* @author Gerardo Gonzlez ( alumno del curso de Java )
* amplio y reviso: Oscar Alejandro Gonzlez Bustamante.
* @version 1.0
*/
/*Ordena por NOMBRE */
class Mascarones implements Comparator {
public int compare(Object o1, Object o2) {
Estudiante u1 = (Estudiante) o1;
Estudiante u2 = (Estudiante) o2;
return u1.getNombre().compareTo(u2.getNombre());
}
public boolean equals(Object o) {
return this == o;
}
} //Fin clase Mascarones
/*Ordena por CALIFICACION */
class Mascarones2 {
private Estudiante[] a;
Mascarones2(Estudiante[] arreglo) { //1er constructor
a = arreglo;
}
// Fin constructor Mascarones2
public void display() {
// Muestra el arreglo
for(int j=0; j<a.length; j++)
System.out.println(""+a[j].toString());
}
public void insertionSort()
{
//Ordenacion por insercion
int in, out;
for(out=1; out<a.length; out++) {
Estudiante temp = a[out];
in = out;
while(in>0 && a[in-1].getCalif() -(temp.getCalif())>0) {
Pgina 138 de 267

JAVA BSICO
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
a[in] = a[in-1];
--in;
}
a[in] = temp;
}
} // Fin ordenacion
//Declaracion de variables
public double promedioGral, varianza, MinValor, MaxValor;
public double Mascarones2(double prom){
//2o constructor
/*Calculo del promedio: Suma de todos los valores entre
*el No. de elementos */
for(int i=0; i<a.length; i++)
promedioGral+=a[i].getCalif();
promedioGral/=a.length;
/*Calculo de la varianza: Suma de todos los elementos al
*cuadrado entre el promedio al cuadrado */
for(int j=0; j<a.length;j++) {
varianza+=Math.pow( (a[j].getCalif()),2);
}
//El total de la suma manos el promedio al cuadrado
varianza=(varianza/10)-(Math.pow(promedioGral,2));
/*Calculo de valores minimos y maximos, usando el arreglo ya
ordenado */
MinValor= a[0].getCalif();
MaxValor= a[(a.length-1)].getCalif();
return varianza;
} //Fin constructor Mascarones2
/*Muestra valores promedio, varianza, Valor minimo y maximo*/
public void displayFinal() {
System.out.println("\n\t Promedio: "+promedioGral+
"\n\t Varianza: "+varianza+
"\n\t Calificacion Minima: "+MinValor+
"\n\t
Calificacion
Maxima:
"+MaxValor);
75.
}
} //Fin clase Mascarones2import java.util.*;
Pgina 139 de 267

JAVA BSICO
1. public class Persona {

2.
3.
protected String nombre;
4.
protected String ap;
5.
protected int edad;
6.
7.
//Asigna valores del arreglo a cada elemento
8.
Persona(String nombre, String ap, int edad) {
9.
this(nombre);
10.
this.ap= ap;
11.
this.edad = edad;
12.
}
13.
14.
Persona(String nombre) {
15.
16.
}
17.
18.
Persona() {
19.
this.nombre=null;
20.
this.ap=null;
21.
this.edad=-1;
22.
}
23.
24. } //Fin clase Persona
Pgina 140 de 267

JAVA BSICO
1. public class Estudiante extends Persona{

2.
3.
public double calif;
4.
5.
//Asigna valores de calificacion del arreglo y pasa a clase Persona lo
dems
6.
7.
8.
9.
10.
11.
Estudiante(String nombre, String ap, int edad, double calif) {

super(nombre, ap, edad);
this.calif= calif;
}
public String toString() {

//Muestra cada elemento del arreglo en
posicin i
12.
return " "+nombre+" "+ap+
13.
" "+edad+" "+calif;
14.
}
15.
16.
17.
18.
19.
20.
21.
22.
public String getNombre() { //Regresa el valor del nombre

return nombre;
}
public double getCalif() {

return calif;
}
} //Fin clase Estudiante
//Regresa el valor de la calificacion
Pgina 141 de 267

JAVA BSICO
4.5 Paquete java.io
Los servidores de E/S de archivos y flujos se encuentran en los paquetes java.io y

java.nio. Aqu, la n de nio significa nuevo.
La E/S y los nuevos servicios
de E/S aparecen descritos ms estn descritos mas adelantes.

Bsicamente, estas clases proporcionan la posibilidad de leer y escribir a nivel de
byte, de carcter, de primitivo y de objeto, incluyendo el acceso directo a la
memoria intermedia de E/S nativa. Los filtros de E/S proporcionan nuevas
posibilidades a las operaciones de lectura y escritura bsicas. Por ejemplo, los
flujos de E/S bsicos no se almacenan temporalmente, pero si no desea realizar
una operacin de lectura y escritura ms optimizada, puede agregar un filtro de
memoria intermedia.
Pgina 142 de 267

JAVA BSICO
4.5.1 Introduccin a los flujos
Qu es un Flujo?
Un flujo es un sistema de comunicacin implementado en el paquete java.io cuyo
fin es guardar y recuperar la informacin en cada uno de los diversos dispositivos
de almacenamiento.
Podemos imaginar un flujo como un tubo donde podemos leer o escribir
bytes. No nos importa lo que pueda haber en el otro extremo del tubo: Puede ser
un teclado, un monitor, un archivo, un proceso, una conexin TCP/IP o un objeto
de Java.
Todos los flujos que aparecen en Java englobados en el paquete java.io,
pertenecen a dos clases abstractas comunes: java.io.InputStream para los flujos
de Entrada (aquellos de los que podemos leer) y java.io.OutputStream para os
flujos de salida (aquellos en los que podemos escribir).
Estos flujos, pueden tener orgenes diversos (un archivo, un socket TCP, etc.),
pero una vez que tenemos una referencia a ellos, podemos trabajar siempre de la
misma forma: leyendo datos mediante los mtodos de la familia read() o
escribiendo datos con los mtodos write().
Hay flujos de:
Flujos de bytes
Flujos de caracteres
Hay flujos de entrada y salida:
Un flujo de entrada enva datos de una fuente a un programa
Un flujo de salida enva datos de un programa hacia un destino
Pgina 143 de 267

JAVA BSICO
4.5.2 Flujos Estndar
Java al igual que cualquier otro lenguaje de programacin tiene su conjunto

mtodos que le permiten captar la informacin de flujos de entrada y enviar flujos
de salida por dispositivos estndar.
Los flujos estndar son:
Flujo de datos de entrada: Se realiza mediante la clase System.in y suele recibir
los datos del teclado. Utiliza el mtodo read() para conseguir leer los caracteres
del teclado.
Flujo de datos de salida: Se realiza mediante la clase System.out y suele enviar
los datos por pantalla. Utiliza el mtodo print() y println() para la salida por
pantalla
Flujo de datos de error: Se realiza mediante la clase System.err
Nos aseguramos que la salida va redirigida al monitor para enviar mensajes de
error al usuario. El flujo de entrada ms utilizado est asociado al teclado, veamos
el siguiente ejemplo que es bastante ilustrativo.
/**
* Ejemplo: programa de flujos (streams)
* que lee tu nombre de la lnea de comandos
* y te lo muestra por la consola de salida.
* @version 1.0
* Archivo: HolaOscar.java
*/
import java.io.*;
public class HolaOscar {
public static void main(String[] args) throws IOException
{
InputStreamReader lector = new InputStreamReader(System.in);
BufferedReader entrada = new BufferedReader(lector);
System.out.print("Cual es tu nombre? ");
String nombre = entrada.readLine();
System.out.println("Hola " + nombre + "!");
}
}// fin de la clase HolaOscar
Pgina 144 de 267
JAVA BSICO
La salida del programa al ejecutarlo con el comando java HolaOscar es:

Da tu nombre: Oscarin
Hola, Oscarin!
En la siguiente figura vemos el proceso de tomar los datos del flujo estndar de
entrada System.in asociado al teclado con la creacin del objeto lector de la
clase InputStreamReader.
Luego con el objeto lector lo utilizamos como
argumento del constructor de un objeto entrada de la clase BufferReader, el

cual tiene mtodos como readLine(), para leer el conjunto de bytes del buffer
hasta el final de la lnea.
Finalmente utilizamos el mtodo println() de
System.out que est asociado al flujo estndar de salida para presentar los datos
por la consola o monitor.
Pgina 145 de 267

JAVA BSICO
Algunos ejemplos de flujo estndar

En
los
ejemplos
siguientes,
usamos
el
flujo
estndar
de
entrada
System.in asociado al teclado. Todo lo que se lea de algn flujo de entrada

esta dado en bytes, los cuales son transformados a cadenas de caracteres.
Entonces como hacemos la lectura de algn nmero real o entero por teclado?
Afortunadamente existen mtodos de conversin de cadenas en las clases
envoltorio ( wrappers ) como doubleValue() que convierte una cadena en formato
de nmero real a una variable primitiva de tipo double. As es como podemos
entonces manejar los flujos de datos de bytes o caracteres a formatos binarios
especficos. Tambin observe que el mtodo main() se est manejando la
excepcin IOException , para prever algn tipo de error en el flujo de entrada o
salida, ver el ejemplo:
/**
* Ejemplo: programa de flujos (streams)
* que lee el valor del radio desde el teclado y calcula
* el rea del circulo. La cadena del nmero see lee
* con un flujo de entrada que luego es convertido a
* formato de nmero de tipo double con doubleValue()
* de la clase wrapper Double . El programa calcula el
* rea del circulo en base al radio dado y presenta el
* resultado por pantalla.
* @author Oscar A. Gonzlez Bustamante
* @version 1.0
* Archivo: AreaCirculo.java
*/
import java.io.*;
public class AreaCirculo{
public static void main(String[] args) throws IOException
{
InputStreamReader lector = new InputStreamReader(System.in);
BufferedReader entrada = new BufferedReader(lector);
System.out.print("Introduce valor del radio: ");
String texto = entrada.readLine();
Double x = new Double(texto);
double r = x.doubleValue();
System.out.println("El area de un circulo de radio "+ r );
double area = r*r*Math.PI;
System.out.println(" es " + area);
}
}// fin de la clase AreaCirculo
Pgina 146 de 267

JAVA BSICO
Para correr el programa hay que ejecutar la sentencia java AreaCirculo y

presenta los siguientes resultados si se le da como radio el valor de 10.
Introduce valor del radio: 10

El rea de un circulo de radio: 10.0
Es: 314.1592653589793
Pgina 147 de 267

JAVA BSICO
5. HERENCIA Y POLIFORMISMO
5.1 Herencia
En esta seccin veremos como la relacin entre clases llamada herencia, o
relacin is-a (es-un), es una estrategia de la POO para la reutilizacin de cdigo y
para la especializacin y extensin de cdigo existente en algo nuevo y mejor.
De hecho todas las clases en Java heredan de la clase Object todos sus mtodos
y atributos de manera implcita, pero el programador puede crear sus clases e
implementar la herencia de manera explcita con la palabra reservada extends y
as construir un sub - rbol dentro de la jerarqua de clases que tiene Java.
Herencia: es un mecanismo que permite crear una clase nueva en base a la
definicin de una clase existente. Con la herencia la clase nueva hereda de la
clase base, todos los mtodos y atributos que se encuentran en la interfaz de la
clase existente y aparecern automticamente en la interfaz de la clase nueva.
Jerarqua de clases, o alcance de las clases
En los lenguajes de POO una jerarqua de clases o alcance de las clases esta
conformada por un conjunto de clases que forman un rbol de nodos (rbol
invertido).
Estos nodos son clases y este rbol tiene en su parte superior una clase
denominada clase raz.
Este rbol termina en una(s) clase(s) denominadas hoja.
Pgina 148 de 267

JAVA BSICO
Superclase y subclasesLa herencia define la nueva clase, la hija, en funcin de

una clase anterior ya existente denominada, la madre. Esta relacin madre-hija
es la ms sencilla de la herencia. De hecho, todas las jerarquas de herencia
empiezan con una madre y una hija. La clase hija es la que recibe la herencia,
tambin se conoce como subclase o clase derivada. La clase madre es de la cual
hereda directamente la hija, tambin se conoce como superclase o clase base.
La relacin entre la superclase y la subclase en diagramas de UML es representada mediante una

fecha que va de la subclase a la superclase y con la punta del lado de la superclase.
Pgina 149 de 267

JAVA BSICO
Mecnica de la herencia:
Cuando una clase hereda de otra su implementacin, comportamientos y

atributos, esto significa que todos los mtodos y atributos disponibles en la
interfaz publica de la madre aparecern en la interfaz de la hija.
Una clase elaborada a travs de la herencia puede tener tres tipos

importantes de mtodos y atributos.
Redefinidos: la nueva clase hereda el mtodo o el atributo de la

superclase, pero proporciona una nueva definicin. (El concepto redefinido
tambin se le conoce como sobre escrito o sobrepuesto).
Nuevos: la nueva clase derivada agrega un mtodo o un atributo

completamente nuevo.
Recursivos: la nueva clase simplemente hereda de la superclase
un
mtodo o un atributo.
Modificadores de acceso protegidos

Miembros protegidos.
Un miembro con el modificador de acceso protected es algo parecido al acceso
por omisin o acceso por default, pero otorga cierto acceso privilegiado a las
subclases de otros paquetes.
Si se declaran como protected las podremos utilizar dentro de la clase y todas sus
subclases.
Miembros protegidos.
O dicho de otro modo, si tuvieras una superclase con mtodos o variables con
acceso protected, y luego haces una extensin de esta superclase, sea haces
una o varias subclases, y estas estn ubicadas en paquetes diferentes donde no
Pgina 150 de 267

JAVA BSICO
est la superclase, estos miembros estn protegidos y las subclases podrn

utilizarlos y accesarlos.
ConstructoresPara crear objetos de una subclase sigue un procedimiento
ordenado.
Al crear un objeto de una subclase, primero se crea la parte
correspondiente a la superclase y, despus, se construye la parte de la subclase.

Si la superclase es, a su vez, subclase de otra, se aplica el mismo procedimiento,
hasta llegar al constructor de Object.
El proceso se complica cuando se aaden constructores a las clases. Cuando
una clase contiene un constructor, primero se construye la superclase, luego la
subclase y entonces se ejecuta el cdigo del constructor.
La superclase se
construye con el constructor por default si existe. Si en la construccin de la

subclase se desea utilizar uno determinado de la superclase, se indica con la
sentencia super (parmetros).
Por ejemplo hagamos una superclase
Planta con su constructor por default.
Luego la subclase rbol con constructor por default, finalmente la clase Pino con
su constructor por default.
Luego una clase Bosque que tenga un arreglo pinitos de objetos de la clase Pino
con por lo menos un objeto como se ve en el diagrama.
Pgina 151 de 267

JAVA BSICO
Ejemplo Planta.java
Pgina 152 de 267

JAVA BSICO
Ejemplo clase Arbol.java

Clase Arbol.java subclase de Planta.java
Pgina 153 de 267

JAVA BSICO
Clase Bosque.java
Clase Bosque.java la cual tiene un arreglo de objetos pinitos de la clase Pino.java
Pgina 154 de 267

JAVA BSICO
Ejemplo clase Bosque.java

La salida de la clase Bosque.java. El constructor de Bosque.java crea un objeto
de la clase Pino. Pero un Pino es una subclase de rbol, as que se crea primero
un objeto rbol invocando automticamente a su constructor por default, pero
para crear un objeto Arbola se tiene que crear un objeto de la clase Planta, as que
entonces se invoca automticamente al constructor por default de Planta y es por
eso que la salida de la ejecucin sale as:
5.2 Uso de la palabra reservada Extends
Extends: es una palabra reservada que indica si la clase tiene herencia o es

subclase o extensin de una claseSuperior o superclase
Pgina 155 de 267

JAVA BSICO
5.3 Uso de la palabra reservada This
Las variables de instancia pueden ser referenciadas con la palabra this, donde this
significa de esta clase , as por ejemplo supongamos que tiene una clase
Persona con un campo public String nombre, entonces para hacer referencia a
ella se hace as;
class Persona {
public void setNombre(String nombre ) {
}
}
Pero si se crea un objeto p de Persona entonces en lugar de usar this usamos p

as;
Persona p = new Persona();
p.nombre = Paco;
Pgina 156 de 267

JAVA BSICO
5.4 Uso de la palabra reservada Super

La palabra reservada super es utilizada en la herencia (en lenguajes POO como
Java) cuando queremos invocar desde la subclase a un mtodo constructor de la
superclase o a un mtodo cualquiera de la superclase o a una variable de la
superclase.
super( [lista_de_argumentos ] )
super.metodo( [ lista_de_argumentos ] )
super.variable
Ejemplo:
// invoca al constructor de la superclase
super( diametrotronco, altura, anillos, nombre);
super.imprime(); // invoca al mtodo imprime de la superclase
super.velocidad= 60; // invoca al la variable velocidad la superclase
Pgina 157 de 267

JAVA BSICO
Ejemplo con super - Planta.java
1. public class Planta {

2. private String nombre; // atributos privados no se heredan
3. private int aos;
4. public Planta() { System.out.println("Soy una Planta"); }
5. public Planta (String nombre ) {
6.
7.
}
8.
public Planta( String nombre, int aos) {
9.
this(nombre);
10.
this.aos = aos;
11. }
12. public String getNombre() { return nombre; }
13. public void setNombre(String val) { this.nombre = val; }
14. public int getAos() { return aos; }
15. public void setAos(int val) { this.aos = val; }
16.
17. public String toString() {
18.
StringBuffer buf
19.
= new StringBuffer("Planta nombre: " +
20.
this.getNombre() );
21.
return buf.toString();
22. }
23. } // fin de la clase Planta
Pgina 158 de 267

JAVA BSICO
Ejemplo con super - Planta.java

Ahora en la clase Planta tenemos dos variables privadas:
private String nombre; // atributos privados no se heredan
private int aos;
Las cuales no se heredan porque son privadas, y son de uso exclusivo de la clase
que las contiene, as que ponemos mtodos pblicos getter y setter para su
acceso desde cualquier clase en cualquier paquete.
Luego tenemos tres constructores, el default que no tiene argumentos, mas otros
dos que inicializan las variables privadas.
Finalmente tenemos el mtodo sobre escrito o sobrepuesto toString() el cual
viene incluido en el paquete java.lang.String y es miembro de la clase raz Object.
Este mtodo toString() devuelve una cadena con los valores de los atributos de la
clase (estado del objeto ) y que nos permitir armar una representacin cadena de
tipo String para objetos de la clase Planta y para eso lo redefinimos su
comportamiento.
Pgina 159 de 267

JAVA BSICO
5.5 Creacin y destruccin de objetos en una jerarqua de herencia

En java los objetos se crean nicamente de forma dinmica, es decir, en el heap.
Para ello se utiliza el operador new, de manera similar a C++. Los objetos en java
se utilizan siempre a travs de referencias. Las referencias son similares a los
punteros de C/C++, aunque su uso es mucho mas sencillo. Por lo tanto los pasos
a seguir en la creacin son:
Declarar una referencia a la clase

Crear un objeto mediante el operador new invocando al constructor
adecuado
Conectar el objeto con la referencia
La destruccin de los
objetos se realiza de manera automtica cuando el
recolector de basura detecta que el objeto no esta siendo usado, es decir no esta
conectado a ninguna referencia.
Pgina 160 de 267

JAVA BSICO
5.6 Redefinicin de miembros

En una subclase se puede volver a escribir uno de los mtodos que ya tuviese
la superclase de la que hereda.
A esto se le denomina sobre escritura,
redefinicin o sobre posicin. Tambin se pueden sobre escribir tambin la

variable miembro de la clase.
Una subclase o clase derivada puede definir:
Una variable miembro con el mismo nombre que uno de la superclase.
Un mtodo con la misma firma (nombre y parmetros de la invocacin)

que uno de la superclase.
Las variables y mtodos de clase (estticos) se pueden sobrescribir, pero se

accede de acuerdo a la declaracin del objeto con el que se invocan, sin que
exista un vnculo dinmico con estos, ya que no se requieren instancias u
objetos para poder usarlos.
La sobre escritura puede ampliar el nivel de acceso, hacindose ms pblico,
pero no restringindose hacindose ms privado. La siguiente tabla muestra los
posibles cambios de acceso:
Acceso en la Superclase
Acceso posible en la Superclase

Privado
Privado
Protegido
Default o de paquete
Publico
Protegido
Publico
Protegido
Publico
Protegido
Publico
Publico
Pgina 161 de 267

JAVA BSICO
5.7 Clases finales

Clase raz, clase hoja: La clase raz es la clase base de todas las clases en una
jerarqua de clases. As por ejemplo en el lenguaje de programacin Java todas
las clases heredan por omisin de la clase Object (conocida como la clase raz)
todos sus mtodos y atributos de manera implcita, pero el programador puede
crear sus clases e implementar la herencia de manera explcita con la palabra
reservada extends y as construir un sub-rbol dentro de la jerarqua de clases que
tiene Java.
Una clase hoja es aquella que ya no tiene descendencia y en la jerarqua de
clases esta en el nivel ms especializado o concreto posibles.
En el lenguaje Java, a estas clases se les conoce como clases finales
(final clases )
5.8 Clases abstractas
Si una clase contiene al menos un mtodo abstracto, entonces es una clase

abstracta.
Una clase abstracta es una clase de la que no se pueden crear objetos,

pero puede ser utilizada como clase padre para otras clases.
Declaracin:
abstract class NombreClase
{
..............
}
Pgina 162 de 267

JAVA BSICO
Ejemplo de clase abstracta
persona
-nombre
-edad
+toString() : String
+cambiarEdad()
alumno
-curso
-nivelAcademico
+cambiarCurso()
+pagoMensual() : double
+mostrarAsignaturas()
profesor
-asignatura
libre
presencial
-listaAsignaturas
-precioPorHora
-noHorasDiarias
-pedirAsignaturas()
-matriculaCurso
-noConvocatoria
-plusPorConvocatoria
Pgina 163 de 267

JAVA BSICO
abstract class Alumno extends Persona {

protected int curso;
private String nivelAcademico;
public Alumno (String n, int e, int c, String nivel) {
super(n, e);
curso = c; nivelAcademico = nivel;
}
return super.toString() + curso + nivelAcademico;
}
abstract double pagoMensual();
abstract String getAsignaturas();
}
class Libre extends Alumno {
private String []listaDeAsignaturas;
private static float precioPorHora=10;
private int noHorasDiarias;
private void pedirAsignaturas() {}// se inicializa listaDeAsignaturas
public double pagoMensual() {
return precioPorHora*noHorasDiarias*30; }
public String getAsignaturas() {
String asignaturas="";
for (int i=0; i<listaDeAsignaturas.length; i++)
asignaturas += listaDeAsignaturas[i] + ' ';
return asignaturas;
}
public Libre(String n, int e, int c, String nivel, int horas)
{super(n,e,c,nivel); noHorasDiarias = horas; pedirAsignaturas(); }
}
class Presencial extends Alumno {
private double matriculaCurso;
private double plusPorConvocatoria;
private int noConvocatoria;
public double pagoMensual()
{ return (matriculaCurso+plusPorConvocatoria*noConvocatoria)/12; }
public String getAsignaturas(){
return todas las del curso + curso;
}
public Presencial(String n, int e, int c, String nivel,
double mc, double pc, int nc) {
super(n,e,c,nivel);
matriculaCurso=mc;
plusPorConvocatoria=pc;
noConvocatoria=nc;
}
}
// FUNCIONES GLOBALES
void mostrarAsignaturas(Alumno v[]) {
for (int i=0; i<v.length; i++)
System.out.println(v[i].getAsignaturas());
// enlace dinmico
}
double totalPagos(Alumno v[]) {
double t=0;
for (int i=0; i<v.length; i++)
t += v[i].pagoMensual(); // enlace dinmico
return t;
}
Pgina 164 de 267

JAVA BSICO
5.9 Polimorfismo
El polimorfismo (poli = muchas, morfismo = formas) es una de las propiedades
importantes de la Programacin Orientada a Objetos. Para entender el
polimorfismo debemos entender primeramente la herencia porque ste concepto
esta muy relacionado con el polimorfismo.
El polimorfismo es una de las tcnicas ms importantes que permiten al
programador "Separar las cosas que cambian de las cosas que deben permanecer
igual", as se puede reutilizar cdigo existente para las cosas que quedan sin
cambios y crear cdigo nuevo para las cosas que cambian.
Pgina 165 de 267

JAVA BSICO
5.10 Interfaces
La palabra reservada interface toma el concepto de abstract un paso mas
adelante. Usted puede pensar que una interface como un clase abstracta
"pura". Una interface solo provee la forma, pero no la implementacin.
Las interfaces nacen ah donde la jerarqua de clases hasta ahora tratada se
queda corta para el diseo de complejos programas. Entonces entra una nueva
jerarqua que es la jerarqua de interfaces. La idea es algo parecida a la herencia
mltiple pero no es tal.
Pgina 166 de 267

JAVA BSICO
5.11 Clases internas

Dentro de una clase es posible declarar otra clase y incluso tener delimitadores de
acceso como private.
Cuando se compila se generarn tantos archivos .class
como clases internas haya, incluso con las clases internas annimas que se
generan cuando se le dan eventos a las GUIS. p. ejemplo la clase Direccin
es
interna a la clase Persona . Cuando se compila la clase Persona.java se generan

dos unidades de compilacin, Persona.class y Persona$Direccion.class , ver es
siguiente ejemplo:
Tenemos la clase Persona con varios constructores. Esta clase tiene las variables
privadas direccin de la clase Direccin, estatura de tipo double, fnac de la clase
estndar de Java Date, y nombre de la clase String.
Los constructores de la clase Persona inicializan esta variable miembro privadas.
El mtodo toString() dentro de Persona , arma una cadena de los valores de las
variables miembro y la regresa.
La clase Persona tiene dentro una clase interna esttica llamada Direccin, y nos
sirve para crear un objeto para manejar la direccin.
Para usar esta clase Persona, hacemos un programa de Java, Este programa se
llama UsaLaPersona y es una clase que contiene mtodo main().
Este mtodo
main es donde empiezan a ejecutarse las aplicaciones de Java cuando se corren

con el intrprete.
Pgina 167 de 267

JAVA BSICO
Este programa UsaLaPersona construye un objeto de la clase Persona llamado

p1 y luego presenta los datos de las variables miembro de p1 en un ScroollPane
( Panel de desplazamiento ) dentro de un cuadro de Dialogo para visualizar esos
datos, vea la Figura 1-29.
Figura 1-29. Diagrama de UML de las clases Persona y UsaLaPersona, donde se aprecia la
relacin de asociacin entre las clases, representada con una flecha que las conecta.
Pgina 168 de 267

JAVA BSICO
5.12 Clases annimas

Las clases annimas son muy similares a las clases internas locales, pero sin
nombre. En las clases internas locales primero se define la clase y luego se crean
uno o ms objetos. En las clases annimas se unen estos dos pasos: Como la
clase no tiene nombre slo se puede crear un nico objeto, ya que las clases
annimas no pueden definir constructores. Estas clases se utilizan con mucha
frecuencia para definir clases y objetos que gestionen los eventos de los distintos
componentes de la interface de usuario como veremos en el siguiente artculo.
Existen 3 maneras de definir una clase annima:
Requieren una extensin de la palabra clave new.

Se definen en una expresin de Java, incluida en una asignacin o en la
llamada a un mtodo.
Se incluye la palabra new seguida de la definicin de la clase annima,
entre llaves {...}.
Otra forma de definirlas es mediante la palabra new seguida del nombre de
la clase de la que hereda (sin extends) y la definicin de la clase annima
entre llaves {...}.
El nombre de la super-clase puede ir seguido de argumentos para su
constructor (entre parntesis, que con mucha frecuencia estarn vacos
pues se utilizar un constructor por defecto).
Una tercera forma de definirlas es con la palabra new seguida del nombre
de la interface que implementa (sin implements) y la definicin de la clase
annima entre llaves {...}.
En este caso la clase annima deriva de Object.
El nombre de la interface va seguido por parntesis vacos, pues el
constructor de Object no tiene argumentos.
Pgina 169 de 267

JAVA BSICO
Para las clases annimas compiladas el compilador produce ficheros con un

nombre del tipo ClaseContenedora$1.class, asignando un nmero correlativo a
cada una de las clases annimas. En este tipo de clase se debe respetar los
aspectos tipogrficos, pues al no tener nombre dichas clases, suelen resultar
difciles de leer e interpretar.
Cuando las uses escribe la palabra new en la misma lnea que el resto de la
expresin. Las llaves se abren en la misma lnea que new, despus del cierre del
parntesis de los argumentos del constructor. El cuerpo de la clase annima se
debe sangrar respecto a las lneas anteriores de cdigo para que resulte
claramente distinguible.
El cierre de las llaves va seguido por el resto de la expresin en la que se ha
definido la clase annima.
//Ejemplo de definicin de clase annima

objeto.addActionListener (new ActionListener() {
public void actionPerformed (ActionEvent ae) {
...
}
});
Pgina 170 de 267

JAVA BSICO
5.13 Clases interfaces

La interface en Java es la clase ms abstracta posible. Esta constituida solamente
de mtodos pblicos abstractos (nombres de mtodos, lista de argumentos y tipos
de retorno, pero no cuerpos de mtodos, y son implcitamente abstract) y
atributos pblicos y finales (que son implcitamente static y final).
Cuando se dice que una clase implementa una interfaz es porque sta define
todos los mtodos abstractos de la interfaz. Una clase que implementa una
interfaz se comporta como si hubiese extendido una clase abstracta especificada
por la interfaz.
La diferencia fundamental entre una clase abstracta y una interfaz es que, aunque
ambas especifican cmo deben comportarse las subclases, la interfaz no puede
dar ningn detalle acerca de la implementacin de los mtodos ni de los atributos.
La consecuencia de estas restricciones es que la existencia de varias interfaces
no presenta los mismos problemas potenciales que la herencia mltiple. De este
modo, mientras que en Java una clase puede extender slo a otra clase base, si
que puede implementar a varias interfaces (implementacin de herencia mltiple).
Creacin de una interfaz

Para crear una interface, hay que utilizar la palabra reservada interface en lugar
de la palabra reservada class. Puede agregar la palabra reservada public antes
de la palabra interface - pero solamente si la interface es definida en un archivo
de el mismo nombre - o dejarla con el acceso de paquete, as solo ser utilizable
dentro del mismo paquete.
Pgina 171 de 267

JAVA BSICO
5.14 Implementacin interfaces

Para crear una clase que utilice o implemente una particular interface - o grupo de
interfaces -, aplique la palabra reservada implements, la cual indica, "La interface
te dice cual es su forma o aspecto, pero ahora voy a decirte como trabaja", en
pocas palabras, una interfaz es un contrato que debe cumplir una clase
implementadora. Si una clase implementa una interfaz en particular tiene que
implementar todos los mtodos designados por esa interfaz, en resumen una
clase implementa una interfaz si cumple los siguientes requisitos:
Declara que implementa la interfaz
Define implementaciones para todos los mtodos de la interfaz, y es
obligatorio implementar exactamente cada mtodo indicado en la interfaz.
Pgina 172 de 267

JAVA BSICO
6. MANEJO DE EXCEPCIONES
6.1 Modelo del manejo de excepciones
Las excepciones son situaciones excepcionales que producen errores en los
programas en tiempo de ejecucin. Una condicin excepcional es un problema
que evita la continuacin de un mtodo o mbito, esto es, se sale del contexto
actual para relegar ese problema un un contexto mayor, como en una lnea de
comando de ordenes. Esto es lo que sucede cuando usted lanza una excepcin:
Cuando se lanza una excepcin ocurren varias cosas:
Primero: un objeto es creado o instanciado con new como cualquier otro
objeto.
Segundo: la ruta actual de ejecucin es interrumpida y la referencia de el
objeto de excepcin es abortada del contexto actual.
Tercero: un mecanismo de manejo de excepcin se hace cargo y comienza
a buscar un lugar apropiado para continuar ejecutando el programa. Este
lugar apropiado es el manejador de excepcin cuyo trabajo es manejar el
error para que el programa pueda continuar.
Lanzando excepciones try / catch.
Cuando queremos que nuestro programa pueda capturar una excepcin utilizamos: el
bloque try - catch
try {
// cdigo que puede
generar excepciones o
// regin salvaguardada
donde se puede producir
una excepcin
}
Pgina 173 de 267

JAVA BSICO
Manejadores de Excepcin.
En nuestro cdigo cuando dentro del bloque try se lanza una excepcin, hay que
capturarla con catch y manejarla segn su tipo con el manejador de excepcin
adecuado, ya que podemos poner varios catch para los diferentes tipos de errores
que sucedan:
try {
// Codigo que puede genera excepciones
} catch(Tipo1 id1) {
// Manejo de excepciones del Tipo1
}
// etc...
Ejemplos try/catch
Primeramente veamos que sucede cuando no hay un bloque try - catch para
proteger nuestro cdigo y capturar una posible excepcin, el ejemplo de divisin
por cero es intencional para
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
/**
* Programa de Java que te ensea que pasa cuando
* no manejas una excepcin.
* @autor Oscar A. Gonzlez Bustamante
* @version 1.0
* Archivo: EjemploExcepcion.java
*/
public class EjemploExcepcion
{
{
int divisor = 0;
int cociente = 1234/divisor;
}
}
Pgina 174 de 267

JAVA BSICO
La salida de ste programa al ejecutarlo con el comando java EjemploExcepcion

es:
java.lang.ArithmeticException: / by zero
at
EjemploExcepcion.main(EjemploExcepcion.java:14)
Exception in thread "main" Finished executing
Como vemos el proceso que maneja las excepciones en Java y que es un thread
que corre en paralelo junto con el intrprete de Java detecta el error en la lnea 14
y reporta el error como una excepcin, adems imprime el mensaje "/ by zero"
para indicarnos el problema luego el programa termina abruptamente ya que no
puede continuar porque no puede manejar esa divisin por cero.
Ahora veamos que pasa si decidimos poner el cdigo que produce la divisin por
cero dentro de un mtodo:
/**
* Programa de Java que te ensea que pasa cuando
* no manejas una excepcin dentro de un mtodo.
* @version 1.0
* Archivo: EjemploExcepcion2.java
*/
public class EjemploExcepcion2
{
static void excepcional()
{
int divisor = 0;
}
{
EjemploExcepcion2.excepcional();
}
}
Pgina 175 de 267
JAVA BSICO
La salida de ste programa al ejecutarlo con el comando java EjemploExcepcion2

es:
java.lang.ArithmeticException: / by zero
at EjemploExcepcion2.excepcional(EjemploExcepcion2.java:13)
at EjemploExcepcion2.main(EjemploExcepcion2.java:17)
Exception in thread "main" Finished executing
Como podemos observar el programa manejador de excepciones de Java reporte
el origen de los errores simulando una pila de llamadas, como lo hara un
depurador, as el error se origina en la lnea 17 dentro del mtodo main(), y luego
siguiendo la traza nos lleva a la lnea 13 dentro del mtodo excepcional().
Ahora vamos a tratar la excepcin para que el programa sepa que hacer cuando
se arroje el error de divisin por cero. El siguiente ejemplo de programa muestra
como podemos usar el try - catch para ello:
/**
Programa de Java que te ensea que pasa cuando
manejas una excepcin con el try - catch.
@autor Oscar A. Gonzlez Bustamante
@version 1.0
Archivo: EjemploExcepcionCapturada.java
*/
public class EjemploExcepcionCapturada
{
{
try
{
int divisor = 0;
}
catch (ArithmeticException excepcion)
{
System.out.println("Excepcion de division por cero.");
System.out.println("El mensaje del tipo de error es:"
+ excepcion.getMessage() );
System.out.println("La descripcin de este error es:"
+ excepcion.toString() );
}
}
}
Pgina 176 de 267
JAVA BSICO
La
salida
de
ste
programa
al
ejecutarlo
con
el
comando
java
EjemploExcepcionCapturada es: Excepcion de division por cero.

El mensaje del tipo de error es:/ by zero
La descripcin de este error es:java.lang.ArithmeticException: /
by zero
Finished executing
Vemos el efecto de utilizar el mtodo getMessage() de la clase Throwable que es
la de obtener una cadena del tipo de error "/ by zero" y la descripcin de este error
lo obtenemos con el mtodo toString() de la clase Object el cual nos da
"java.lang.ArithmeticException: / by zero" que es una informacin til para saber
de que tipo de error o excepcin estamos tratando.
El siguiente ejemplo muestra el uso de varias excepciones encadenadas, donde
se piden dos nmeros dentro del bloque try y si hay problemas de conversin se
manda la excepcin NumberFormatException , si hay errores de divisin por cero
se lanza la excepcin ArithmeticException, si hay error en el flujo de entrada se
lanza la excepcin IOException y si no es ninguna de las tres se lanza la
excepcin de tipo Exception.
Pgina 177 de 267

JAVA BSICO
import java.io.*;
public class VariasExcepciones{
public static void main(String args[]){
BufferedReader teclado = new BufferedReader(
new InputStreamReader(System.in));
boolean error=false;
do{
try{
error=false;
System.out.print("\nTeclea un numero: ");
String texto= teclado.readLine();
int i = Integer.parseInt(texto);
System.out.print("Teclea otro numero: ");
texto= teclado.readLine();
int j = Integer.parseInt(texto);
System.out.printf("La divisin %d/%d = %d\n",i,j,i/j);
}catch (NumberFormatException e){
System.out.println("Error: en la conversin");
error=true;
}catch (IOException e) {
System.out.println("Error en la lectura");
error=true;
}catch (ArithmeticException e){
System.out.println("\nDivisin por cero");
error=true;
}catch (Exception e){
System.out.println("Excepcin desconocida");
error=true;
}
}while(error);
}// fin del main
} // fin de la clase variasExcepciones
Pgina 178 de 267

JAVA BSICO
6.2 Clausula Finally

Esta clusula se utiliza cuando tengamos que hacer determinada accin
necesariamente, para asegurarnos que se va a realizar conviene crear una
excepcin, pero es conveniente usar una clusula dentro de la sentencia try que
esta diseada con ese propsito, es la clusula finally.
try {
//aqui va cdigo que puede lanzar una excepcin
}
catch (Tipo1 e) {
// aqu va el cdigo para tratar la excepcin del Tipo 1
}
finally {
// Aqu en el bloque finally es donde se ejecutan
// las sentencias que se quieran siempre ejecutar
// haya o no excepcin
}
Pgina 179 de 267

JAVA BSICO
6.3 Encadenamiento de excepciones

Java permite al manejador de excepciones relanzar la excepcin si el manejador
no puede procesar la excepcin o simplemente si el manejador quiere que a su
llamador sea noficada la excepcin. La sintaxis de esto es como sigue:
try{
sentencias;
}
catch( LaExcepcin ex ) {
// ejecutando operaciones antes de salir
throw ex;
}
La sentencia throw ex relanza la excepcin de tal manera que otros manejadores

tengan oportunidad de procesar la excepcin ex.
Las excepciones encadenadas
Previamente vimos que el bloque catch relanza la excepcin original.
Algunas
veces, usted necesite lanzar una nueva excepcin ( con informacin adicional ) a
travs de la excepcin original. A esto ltimo se le conoce como excepciones
encadenadas.
El siguiente programa ExcepcinEncadenadaEjemplo.java
demuestra como
crear y lanzar excepciones encadenada.
Pgina 180 de 267

JAVA BSICO
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
package excepciones;
/**
* Programa ExcepcionesEncadenadasEjemplo.java
* Demuestra como crear excepciones encadenadas.
* @author Oscar Alejandro Gnzlez Bustamante
* @version 1.0
*/
public class ExcepcionesEncadenadasEjemplo {
try {
m1();
}
catch (Exception ex) {
ex.printStackTrace();
}
}// fin del mtodo main()
public static void m1 () throws Exception {

try {
m2();
}
22.
catch (Exception ex) {
23.
throw new Exception("Nueva informacin proveniente de
m1() ", ex);
24.
}
25.
}// fin del mtodo m1()
26.
27.
public static void m2() throws Exception {
28.
throw new Exception("Nueva informacin proveniente de
m2() ");
29.
}// fin del mtodo m2()
30.
31.
} // fin de la clase ExcepcionesEncadenadasEjemplo
Pgina 181 de 267

JAVA BSICO
El mtodo main() invoca al mtodo m1(), y este invoca al mtodo m2() que lanza
con throw una excepcin.
Esta excepcin es capturada en el bloque catch
dentro del m1() y es envuelto en una nueva excepcin . La nueva excepcin es

lanzada y capturada en el bloque catch dentro del mtodo main().
La salida
muestra el volcado de pila del mtodo printStackTrace(). La nueva excepcion es

lanzada desde el mtodo m1() y es desplegada primero, seguida de la excepcin
original lanzada desde el metodo m2() .
java.lang.Exception: Nueva informacin proveniente de m1()
atexcepciones.ExcepcionesEncadenadasEjemplo.m1(ExcepcionesEncadenadasEj
emplo.java:23)
atexcepciones.ExcepcionesEncadenadasEjemplo.main(ExcepcionesEncadenadas
Ejemplo.java:11)
Caused by: java.lang.Exception: Nueva informacin proveniente de m2()
emplo.java:28)
emplo.java:20)
... 1 moreBUILD SUCCESSFUL (total time: 0 seconds)
run-single:
Pgina 182 de 267

JAVA BSICO
6.4 Generacin de excepciones propias

Es posible crear excepciones definidas por el usuario por medio de la herencia
extendiendo de la clase Exception. La clase Exception posee todo lo que una
clase comn y corriente tiene. El siguiente ejemplo es una clase de manejo de
excepciones definida por el usuario, conteniendo tres constructores, aunque
tambin puedes pone, algunas variables, y mtodos.
1.
/**
2.
* Programa que te ensea a crear tus propias
3.
* clases para manejar excepciones, o excepciones
4.
* personalizadas o de usuario. Ademas te
5.
* te ejemplifica el uso de el lanzamiento de
6.
* excepciones con costructores diferentes y
7.
* utilizando throw ( en singular )
8.
* y throws ( en plural ).
9.
10.
* @version 1.0
11.
* Archivo: ExcepcionesConstruidas
12.
*/
class MiExcepcion extends Exception {
public MiExcepcion() {}
public MiExcepcion(String msg) {
super(" \"" + msg + "\"" );
public MiExcepcion( String msg, int noError ) {
super(" Error garrafal No: " + noError +
" \"" + msg + "\"" );
} //fin del constructor
} // fin de MiExcepcion
13.
public class ExcepcionesConstruidas {
public static void f() throws MiExcepcion {
System.out.println( " Lanzando MiExcepcion de f() ");
throw new MiExcepcion(); // invocando al contructor por default
}
Pgina 183 de 267

JAVA BSICO
public static void g() throws MiExcepcion {

System.out.println("Lanzando MiExcepcion de g()");
throw new MiExcepcion(" Originada en g() ");
}
public static void h() throws MiExcepcion {
System.out.println("Lanzando MiExcepcion de h()");
throw new MiExcepcion(" Originada en h() " , 123 );
}
try {
f();
} catch(MiExcepcion e) {
System.out.println("Capturando excepcin de tipo " + e.toString() +
" "+
"Mensaje: " + e.getMessage() );
}
try {
g();
System.out.println("Capturando excepcin de tipo " + e.toString() +
" "+
}
try {
h();
System.out.println("Capturando excepcin de Tipo: " + e.toString() +
" "+
}
} // fin del main()
} //fin de ExcepcionesConstruidas
Pgina 184 de 267

JAVA BSICO
En el anterior cdigo fuente de la lnea 13 a la 22 tenemos la clase personalizada

para manejo de excepciones MiExcepcin que es una extensin de Excepction
y tiene tres constructores. Luego para que un mtodo pueda utilizar esa clase de
excepciones solo se escribe en la definicin del mtodo throws MiExcepcion, as
por ejemplo el mtodo g() en la lnea 29 tiene declarado public static void g()
throws MiExcepcion.
Ahora para lanzar una excepcin de manera explicita usamos la palabra reservada
throw (en singular) seguido del operador new y el nombre del constructor, as por
ejemplo en la lnea 35 usamos throw new MiExcepcion(" Originada en h() ",
123) para invocar al constructor con dos argumentos, uno de la clase String y el
otro de tipo int.
Podemos proteger nuestro cdigo de una excepcin del tipo que acabamos de
crear dentro de un bloque try - catch, as por ejemplo, de la lnea 52 a la 58
estamos invocando al mtodo h() el cual nos puede lanzar una excepcin del tipo
MiExcepcion que es el nombre de la clase que creamos para manejar nuestras
excepciones.
La
salida
del
programa
al
ejecutarlo
con
el
comando
java
ExcepcionesConstruidas es el siguiente:
Lanzando MiExcepcion de f()
Capturando excepcin de tipo MiExcepcion Mensaje: null
Lanzando MiExcepcion de g()
Capturando excepcin de tipo MiExcepcion: " Originada en g() " Mensaje: "
Originada en g() "
Lanzando MiExcepcion de h()
Capturando excepcin de Tipo: MiExcepcion: Error garrafal No: 123 " Originada en
h() " Mensaje: Error garrafal No: 123 " Originada en h() "
Pgina 185 de 267

JAVA BSICO
Presentaciones
Pgina 186 de 267

JAVA BSICO
Pgina 187 de 267

JAVA BSICO
Pgina 188 de 267

JAVA BSICO
Pgina 189 de 267

JAVA BSICO
Pgina 190 de 267

JAVA BSICO
Pgina 191 de 267

JAVA BSICO
Pgina 192 de 267

JAVA BSICO
Pgina 193 de 267

JAVA BSICO
Pgina 194 de 267

JAVA BSICO
Pgina 195 de 267

JAVA BSICO
Pgina 196 de 267

JAVA BSICO
Pgina 197 de 267

JAVA BSICO
Pgina 198 de 267

JAVA BSICO
Pgina 199 de 267

JAVA BSICO
Pgina 200 de 267

JAVA BSICO
Pgina 201 de 267

JAVA BSICO
Pgina 202 de 267

JAVA BSICO
Pgina 203 de 267

JAVA BSICO
Pgina 204 de 267

JAVA BSICO
Pgina 205 de 267

JAVA BSICO
Pgina 206 de 267

JAVA BSICO
Pgina 207 de 267

JAVA BSICO
Pgina 208 de 267

JAVA BSICO
PRACTICAS
PRACTICA 1
Nombre: ________________________________________________________Fecha:________
Apellido Paterno
Apellido Materno
Nombre(s)
Objetivo: El participante utilizara el IDE NetBeans 6.9 para crear una aplicacin
de Java.
Instrucciones: Lea con atencin y realice lo que se le pide en cada punto

Desarrollo:
1. Haga doble clic en el acceso directo al archivo jnetbeans.exe que est en el
escritorio para abrir el IDE.
2. Dentro del proyecto PROYECTOUNO. Abra el archivo HolaMundo.java
que creo previamente, se abrir la ventana de edicin de dicho archivo, vea
Figura 1.
Figura 1. Ventana de edicin del programa HolaMundo.java
Pgina 209 de 267

JAVA BSICO
3. Modificaremos el programa HolaMundo.java de la Figura 1 para que al

ejecutarlo mande un cuadrito de mensaje con nuestro nombre como se ve
en la Figura 2.
Figura 2. Cuadro de mensaje que presenta su nombre.
4. Abajo de la lnea de la sentencia:
package unam;
Agregue la lnea de cdigo: import javax.swing.JOptionPane ;
Abajo de la sentencia: System.out.println("Bienvenidos a su curso de Java
Bsico en Lnea") ;
Agregue las lneas de cdigo: JOptionPane.showMessageDialog(null,
"Oscar Alejandro",
"Mi nombre es",
JOptionPane.INFORMATION_MESSAGE);
Donde dice Oscar Alejandro escriba su nombre por favor y borre el mo (su
nombre debe estar entre comillas).
5. Guarde las modificaciones con el comando File | Save
Pgina 210 de 267

JAVA BSICO
6. Su cdigo debe verse en la ventana de edicin como el de la Figura 4.
Figura 4. Cdigo del programa HolaMundo.java con las modificaciones.
Compile el programa con el comando Build | Comile HolaMundo.java (vea

figura 5)
7. Si hay errores, deprelo y corrija los errores con el editor.
8. Ejectelo con el comando Run | Run File | Run HolaMundo.java
Evaluacin. Capture la pantalla de salida y mustrela a su profesor.
No olvide incluir su nombre en la portada.
Pgina 211 de 267

JAVA BSICO
PRACTICA 2
Nombre:________________________________________________________Fecha:_______
Apellido Paterno
Apellido Materno
Nombre(s)
Objetivo: Utilizara el IDE NetBeans 6.0 creara un pequeo programa que

contenga todos los elementos componentes de la estructura bsica de un
programa en Java

Desarrollo:
1. Haga doble clic en el acceso directo al archivo jnetbeans.exe
en el escritorio para abrir el IDE.
que esta
2. Dentro del proyecto

PROYECTODOS y
cree el nuevo paquete
unam.oagb con el comando File | New | Java Package
3. Aparece el cuadro New Java Package, en el campo Package Name
escribir unam.oagb y luego de clic al botn Finish> , vea Figura 1
Figura 1 del cuadro New Java Package.
4. Una vez creado el paquete unam.oagb crearemos una clase de Java.(

Java Class ) con el nombre Galleta. Utilice el comando File | New | Java
Class
5. Dentro del cuadro New Java Class escriba en el campo Class Name el
nombre Galleta
Pgina 212 de 267

JAVA BSICO
6. Aparece una nueva ventana de edicin con el nombre Galleta.java en la

cejilla, vea Figura 2 Observe que la clase Galleta pertenece al paquete
unam.oagb, ya que en la lnea 10 esta escrita la sentencia package
unam.oagb;
Figura 2. La clase Galleta pertenece al paquete unam.oagb.
7. En la ventana de edicin Galleta.java substituya el cdigo de la Figura 3por

el que se lista a continuacin( por favor no escriba los nmeros de lnea que
estn al principio de cada lnea, ya que solo son una gua o ayuda para
ubicar cada instruccin o sentencia):
Pgina 213 de 267

JAVA BSICO
/*
* Galleta.java
*
* Created on 30 de enero de 2007, 05:53 PM
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/
package unam.oagb;
/**
*
* @author Oscar
*/
/** variables */
String sabor = "Fresa";
/** constantes */
/** Crea una nueva instancia de Galleta */
public Galleta() {
}
/** Crea una nueva instancia de Galleta( String nombre ) */
}
/** Crea una nueva instancia de Galleta( String nombre, String sabor ) */
this( nombre );
this.sabor = sabor;
}
/**
* metodo caracteristicasDeLaGalleta()
* @return String
*/
public String caracteristicasDeLaGalleta() {
String cadena = "Galleta: " + this.nombre +
"\tSabor : " + this.sabor +
"\tForma : " + this.FORMA +
"\tPicos : " + this.PICOS ;
return cadena; // regresa cadena
Pgina 214 de 267

JAVA BSICO
} // fin del metodo caracteristicasDeLaGalleta()

Galleta estrella1 = new Galleta();
Galleta estrella2 = new Galleta("Estrella de Mar");
Galleta estrella3 = new Galleta("Estrella del cielo, Vainilla");
System.out.println( estrella1.caracteristicasDeLaGalleta() );
} // fin del mtodo main()
8. Guarde las modificaciones con el comando File | Save ..

9. Compile el programa con el comando Build | Compile Galleta.java
11. Ejectelo con el comando Run | Run File | Run Galleta.java
Evaluacin: Capture la pantalla de salida y envesela por correo a su profesor.

Fin del ejercicio.
Pgina 215 de 267

JAVA BSICO
PRACTICA 3
Nombre:________________________________________________________Fecha:_______
Apellido Paterno
Apellido Materno
Nombre(s)
Objetivo: El participante utilizara el IDE NetBeans 6.9 para crear un applet que
ejemplifique el ciclo de vida de los mismos y luego escribir un applet que reciba
parmetros y que convierta esos parmetros en valores reales para realizar un
calculo aritmtico y desplegar una sencilla figura geomtrica.
Desarrollo:
2. Dentro del proyecto PROYECTOUNO. Cree un paquete con el nombre de
uno y dentro del paquete uno cree el archivo de tipo Java | Applet
CicloVida.java , se abrir la ventana de edicin de dicho archivo, y teclee
el siguiente cdigo:
package uno;
import java.applet.Applet;
/**
* Programa que muestra las etapas de la vida de un applet.
* Ejemplifica los mtodos mas comunes de un applet.
* @version 1.0
* Archivo: CicloVida.java
*/
import java.awt.Graphics;
public class CicloVida extends Applet
{
private String pais, instituto, caddiametro;
/**
* Mtodo constructor del applet. Tiene el mismo nombre de la clase
*/
Pgina 216 de 267

JAVA BSICO
public CicloVida()
{
System.out.println("El constructor se esta ejecutando....");
} // fin constructor por default
/**
* Mtodo init del applet. Inicializa el applet.
*/
public void init()
{
System.out.println("Este es el mtodo init().\n");
this.pais = "Mxico";
this.instituto = "Universidad Nacional Autnoma de Mxico";
this.caddiametro = "100";
} // fin mtodo init
/**
* Mtodo start. Arranca o comienza el applet.
*/
public void start()
{
System.out.println("Este es el mtodo start(). \n");
} // fin mtodo start
/**
* Mtodo paint. Dibuja o pinta el applet.
*/
public void paint(Graphics g)
{
double dmt = Double.parseDouble(this.caddiametro); // conversin de cadena a double
g.drawString("Hola , a todos mis pupilos!", 10,40); // dibuja cadenas
g.drawString( pais, 10, 150);
g.drawString(instituto, 10, 170);
g.drawRect(5, 20, 300, 170); // dibuja rectangulo
g.drawOval(100, 50,(int) dmt,(int) dmt); // circulo de la cara
g.drawOval(110, 70, (int) (dmt/4), (int)( dmt/4)); // ojo izq
g.drawOval(150, 70, (int) (dmt/4), (int)( dmt/4)); // ojo der
g.drawArc(130, 100, 10, 15, 0, 180); // nariz
g.drawArc(120, 120, 30, 15, -180, 180); // boca
System.out.println("El applet acaba de ser dibujado con paint() \n");
} // fin del mtodo paint
Pgina 217 de 267

JAVA BSICO
/**
* Mtodo stop. Para el applet.
*/
public void stop()
{
System.out.println("Este es el mtodo stop(), para el applet. \n");
} // fin del mtodo stop
/**
* Mtodo destroy. Destructor del applet.
*/
public void destroy()
{
System.out.println("Este es el mtodo destroy(), destruye el applet.\n");
} // fin del mtodo destroy
}// fin de la clase CicloVida

4. Compile el programa con Compile File F9
5. Si hay errores, deprelos y corrija los errores con el editor.
6. Ejectelo con el comando Run | Run File | Run CicloVida.java .
Observe la salida en la ventana que genera el netbeans con el
appletviewer. Observe la salida del applet en la consola de Output y pruebe
las opciones del men Applet de la ventana del appletviewer y vea lo que
pasa en la ventana de salida.
7. Dentro del proyecto PROYECTOUNO dentro del paquete uno cree el
archivo de tipo Java | Applet SwingParametros.java , se abrir la ventana
de edicin de dicho archivo, y teclee el siguiente cdigo:
Pgina 218 de 267

JAVA BSICO
package uno;
import java.awt.Color;
/**
* Programa de Java que te ensea a hacer applets
* con la librera java.swing.* que reciban parametros
* y utiliza para ello el mtodo getParameter()
* Dependiendo del valor del parametro dibujar un
* circulo o un cuadrado.
* @version 1.0
* Archivo: AppletParametros.java
*/
public class AppletParametros extends Applet
{
public void paint( Graphics g )
{
String figura;
float radio;
float lado;
double areacirculo, areacuadrado;
// LEE LOS PARAMETROS DE HTML name Y value
figura = getParameter("figura");
if ( figura.equals("circulo") ) {
radio = new Float( getParameter("radio") ).floatValue();
areacirculo = Math.PI * radio * radio;
g.drawString("El area de un "+ figura +
" de radio " + radio + " = " + areacirculo,
15, 20 );
g.setColor( Color.RED );
g.drawOval( 100, 30, (int)radio, (int)radio );
g.setColor( Color.CYAN );
g.fillOval(100, 30, (int)radio - 1, (int)radio - 1 );
}
else if ( figura.equals("cuadrado") ) {
lado = new Float( getParameter("lado") ).floatValue();
areacuadrado = lado * lado;
Pgina 219 de 267

JAVA BSICO

" de lado " + lado + " = " + areacuadrado,
15, 20 );
g.drawRect(100, 30, (int)lado, (int)lado );
g.setColor(new Color(00,21,00));/* establece color verde muy obscuro */
g.fillRect(100+1,30+1,(int)lado-1,(int)lado-1); /* dibuja borde */
}
else {
g.drawString("Lo siento no hay ninguna figura",15, 20 );
}
} // fin del paint()
} // fin de la clase AppletParametros
8. Guarde las modificaciones con el comando File | Save .

10. Si hay errores, deprelos y corrija los errores con el editor.
archivo de tipo Other | HTML file verappletparametros.html , se abrir la
ventana de edicin de dicho archivo, y teclee el siguiente cdigo:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<HEAD>
<TITLE>Applet con parmetros</TITLE>
</HEAD>
<BODY>
Applet que desplega un el area de una figura y la dibuja
Ahora voy a dibujar una figura=circulo
<hr>
<APPLET
CODEBASE ="/root/NetBeansProjects/PROYECTOUNO/build/classes/"
CODE = "uno.AppletParametros.class" WIDTH=400 HEIGHT=100 >
<PARAM NAME="figura" VALUE= "circulo" >
<PARAM NAME="radio" VALUE= "50.0" >
</APPLET>
<hr>
<APPLET
CODE = "uno.AppletParametros.class" WIDTH=400 HEIGHT=100>
<PARAM NAME="figura" VALUE= "cuadrado" >
<PARAM NAME="lado" VALUE= "50.0" >
</APPLET>
</BODY>
</HTML>
Pgina 220 de 267

JAVA BSICO
12. Para ejecutar el applet abra el archivo verappletparametros.html desde

algn navegador habilitado con Java JRE o desde el netbeans en la
ventana de cdigo de clic con el botn derecho y escoja del men
contextual la opcin View.
Evaluacin: Presente la pantalla de salida de ambos programas y mustrelas a
su profesor.
Pgina 221 de 267

JAVA BSICO
PRACTICA 4
Nombre: ________________________________________________________Fecha:_______
Apellido Paterno
Apellido Materno
Nombre(s)
Objetivo: El participante utilizar el IDE NetBeans 6.9 para crear un applet que
ejemplifique el ciclo de vida de los mismos y luego escribir un applet que reciba
parmetros y que convierta esos parmetros en valores reales para realizar un
calculo aritmtico y desplegar una sencilla figura geomtrica.
Desarrollo:
uno y dentro del paquete uno cree el archivo de tipo Java | Applet
CicloVida.java , se abrir la ventana de edicin de dicho archivo, y teclee
el siguiente cdigo:
package uno;
/**
* Programa que muestra las etapas de la vida de un applet.
* Ejemplifica los mtodos mas comunes de un applet.
* @version 1.0
* Archivo: CicloVida.java
*/
public class CicloVida extends Applet
{
private String pais, instituto, caddiametro;
/**
* Mtodo constructor del applet. Tiene el mismo nombre de la clase
*/
public CicloVida()
{
Pgina 222 de 267

JAVA BSICO
System.out.println("El constructor se esta ejecutando....");

} // fin constructor por default
/**
* Mtodo init del applet. Inicializa el applet.
*/
public void init()
{
System.out.println("Este es el mtodo init().\n");
this.pais = "Mxico";
this.instituto = "Universidad Nacional Autnoma de Mxico";
this.caddiametro = "100";
} // fin mtodo init
/**
* Mtodo start. Arranca o comienza el applet.
*/
public void start()
{
System.out.println("Este es el mtodo start(). \n");
} // fin mtodo start
/**
* Mtodo paint. Dibuja o pinta el applet.
*/
public void paint(Graphics g)
{
double dmt = Double.parseDouble(this.caddiametro); // conversin de cadena a double
g.drawString("Hola , a todos mis pupilos!", 10,40); // dibuja cadenas
g.drawString( pais, 10, 150);
g.drawString(instituto, 10, 170);
g.drawRect(5, 20, 300, 170); // dibuja rectangulo
g.drawOval(100, 50,(int) dmt,(int) dmt); // circulo de la cara
g.drawOval(110, 70, (int) (dmt/4), (int)( dmt/4)); // ojo izq
g.drawOval(150, 70, (int) (dmt/4), (int)( dmt/4)); // ojo der
g.drawArc(130, 100, 10, 15, 0, 180); // nariz
g.drawArc(120, 120, 30, 15, -180, 180); // boca
System.out.println("El applet acaba de ser dibujado con paint() \n");
} // fin del mtodo paint
/**
* Mtodo stop. Para el applet.
*/
public void stop()
{
System.out.println("Este es el mtodo stop(), para el applet. \n");
} // fin del mtodo stop
/**
* Mtodo destroy. Destructor del applet.
*/
public void destroy()
{
System.out.println("Este es el mtodo destroy(), destruye el applet.\n");
} // fin del mtodo destroy
}// fin de la clase CicloVida
Pgina 223 de 267

JAVA BSICO

5. Si hay errores, depurelos y corrija los errores con el editor.
6. Ejectelo con el comando Run | Run File | Run CicloVida.java .
Observe la salida en la ventana que genera el netbeans con el
appletviewer. Observe la salida del applet en la consola de Output y pruebe
las opciones del men Applet de la ventana del appletviewer y vea lo que
pasa en la ventana de salida.
archivo de tipo Java | Applet SwingParametros.java , se abrir la ventana
de edicin de dicho archivo, y teclee el siguiente cdigo:
package uno;
import java.awt.Color;
/**
* Programa de Java que te ensea a hacer applets
* con la librera java.swing.* que reciban parametros
* y utiliza para ello el mtodo getParameter()
* Dependiendo del valor del parametro dibujar un
* circulo o un cuadrado.
* @version 1.0
* Archivo: AppletParametros.java
*/
public class AppletParametros extends Applet
{
public void paint( Graphics g )
{
Pgina 224 de 267

JAVA BSICO
String figura;
float radio;
float lado;
double areacirculo, areacuadrado;
// LEE LOS PARAMETROS DE HTML name Y value
figura = getParameter("figura");
if ( figura.equals("circulo") ) {
radio = new Float( getParameter("radio") ).floatValue();
areacirculo = Math.PI * radio * radio;
" de radio " + radio + " = " + areacirculo,
15, 20 );
g.drawOval( 100, 30, (int)radio, (int)radio );
g.setColor( Color.CYAN );
g.fillOval(100, 30, (int)radio - 1, (int)radio - 1 );
}
else if ( figura.equals("cuadrado") ) {
lado = new Float( getParameter("lado") ).floatValue();
areacuadrado = lado * lado;
" de lado " + lado + " = " + areacuadrado,
15, 20 );
g.drawRect(100, 30, (int)lado, (int)lado );
g.setColor(new Color(00,21,00));/* establece color verde muy obscuro */
g.fillRect(100+1,30+1,(int)lado-1,(int)lado-1); /* dibuja borde */
}
else {
g.drawString("Lo siento no hay ninguna figura",15, 20 );
}
} // fin del paint()
} // fin de la clase AppletParametros

10. Si hay errores, depurelos y corrija los errores con el editor.
archivo de tipo Other | HTML file verappletparametros.html , se abrir la
ventana de edicin de dicho archivo, y teclee el siguiente cdigo:
Pgina 225 de 267

JAVA BSICO
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<HEAD>
<TITLE>Applet con parmetros</TITLE>
</HEAD>
<BODY>
Applet que desplega un el area de una figura y la dibuja
<hr>
<APPLET
CODE = "uno.AppletParametros.class" WIDTH=400 HEIGHT=100 >
<PARAM NAME="figura" VALUE= "circulo" >
<PARAM NAME="radio" VALUE= "50.0" >
</APPLET>
<hr>
<APPLET
CODE = "uno.AppletParametros.class" WIDTH=400 HEIGHT=100>
<PARAM NAME="figura" VALUE= "cuadrado" >
<PARAM NAME="lado" VALUE= "50.0" >
</APPLET>
</BODY>
</HTML>
12. Para ejecutar el applet abra el archivo verappletparametros.html desde

algn navegador habilitado con Java JRE o desde el netbeans en la
ventana de cdigo de clic con el botn derecho y escoja del menu
contextual la opcin View.
Evaluacin: Presente la pantalla de salida de ambos programas y mustrelas a
su profesor.
Pgina 226 de 267

JAVA BSICO
PRACTICA 5
Nombre: ________________________________________________________Fecha:_______
Apellido Paterno
Apellido Materno
Nombre(s)
Objetivo: El participante utilizar el IDE NetBeans 6.9 para crear un programa

que ejemplifique el uso de la sentencia switch case en un ciclo iterativo
empleando alguna sentencia de bucle.

Desarrollo:
1. Haga doble clic en el acceso directo para abrir el IDE NetBeans.

2. Vamos a trabajar dentro de la carpeta C:\CURSOJAVA y cree el proyecto
PROYECTODOS.
3. Escribiremos un programa que resuelva el siguiente EJEMPLO, en base al
diagrama de flujo y pseudocdigo, vea la figura 1-a y figura 1-b.
Ejemplo: Haga el algoritmo en diagrama de flujo y pseudocdigo de un
programa que simule una calculadora simple y que pueda efectuar las
operaciones aritmticas de suma, resta, divisin, multiplicacin, residuo y
potencia.
El programa deber presentar un men interactivo para que el usuario
seleccione la operacin a realizar, introduciendo por teclado el smbolo de la
operacin a efectuar:
+
Suma
Resta
Multiplicacin
Divisin
Residuo
Potencia
El programa pedir por teclado dos nmeros reales para efectuar con ellos la
operacin aritmtica seleccionada y calcular el resultado:
Pgina 227 de 267

JAVA BSICO
De el primer nmero:
De el segundo nmero:
El programa solicitar al usuario continuar calculando una nueva operacin o
salir para terminar el proceso:
4. Cree una nueva clase dentro del proyecto PROYECTODOS con el nombre
de Calculadora con mbito pblico, dentro del paquete

con mtodo main.
ejemplos, y
Figura 1-a. Diagrama de flujo del Ejemplo
Pgina 228 de 267

JAVA BSICO
Figura 1-b. Diagrama de flujo del Ejemplo
5. Capture con el editor el cdigo para resolver el Ejemplo 6. Este problema
se resolver con las estructuras de control de decisin mtiple Case EndCase y utilizar alguno de los ciclos while, do while o for.
package ejemplos;
public class Calculadora {
public double p,q,r; // variables reales
String cad; // cadena
char n; // variable para el selector
String menu;
public Calculadora() {
menu = "Operacion a realizar:\n " +
"+ : suma \n" +
"- : resta \n" +
"* : multiplicacion \n" +
"/ : divicion \n" +
Pgina 229 de 267
JAVA BSICO
"% : modulo \n" +

"^ : potencia \n\n ";
Calculadora c = new Calculadora();
String mayuscula = "";
do {
// se leen los dos cadenas para convertirlas a nmeros de tipo doble
c.p = Double.parseDouble (JOptionPane.showInputDialog(null, "De el 1er nmero:") );
c.q = Double.parseDouble (JOptionPane.showInputDialog(null, "De el 2do nmero:") );
String cad = JOptionPane.showInputDialog (null, c.menu); // despliego menu y obtengo
cadena
c.n = cad.charAt (0); // obtengo el 1er. carcter de la cadena
switch (c.n) {
case '+' : c.r = c.p + c.q;
JOptionPane.showMessageDialog(null, "La suma es:" + c.r);
break;
case '-' : c.r = c.p - c.q;
JOptionPane.showMessageDialog(null, "La resta es:" + c.r);
break;
case '*' : c.r = c.p * c.q;
JOptionPane.showMessageDialog(null, "La multiplicacion es:" + c.r);
break;
case '/' : c.r = c.p / c.q;
JOptionPane.showMessageDialog(null, "La divicion es:" + c.r);
break;
case '%' : c.r = c.p % c.q;
JOptionPane.showMessageDialog(null, "El mdulo es:" + c.r);
break;
case '^' : c.r = Math.pow (c.p , c.q);
JOptionPane.showMessageDialog(null, "La Potencia es:" + c.r);
break;
default: JOptionPane.showMessageDialog(null, "Opcion no valida");
break;
} //fin del switch
c.cad = JOptionPane.showInputDialog(null,"Deseas otro claculo? (s/n):");
mayuscula = c.cad.toUpperCase();
} while ( mayuscula.equals( "S" ) || mayuscula.equals( "SI" ) );
System.out.println("Adios, hasta luego");
System.exit (0);
}//fin de main()
}//fin de la clase Calculadora
Pgina 230 de 267

JAVA BSICO
6. Complelo: Si hay errores, depure y corrija los errores con el editor.

8. Ejectelo
9. Coloque un punto de ruptura y vea los valores de las variables en la
ventana de Watch.
Evaluacin: Ejecute de nuevo el programa y de los siguientes valores para el
nmero 1 y para el nmero dos y calcule la suma, resta, divisin,
multiplicacin, mdulo y potencia as:
De el primer numero: 8
De el segundo nmero: 3
Mustrele a su profesor la ejecucin del programa y hgale preguntas si tiene
dudas.
Pgina 231 de 267

JAVA BSICO
PRACTICA 6
Nombre: ________________________________________________________Fecha:_______
Apellido Paterno
Apellido Materno
Nombre(s)
Objetivo: El participante utilizar el IDE NetBeans 6.9 para crear un programa

que ejemplifique el uso de literales para inicializar variables.
Desarrollo:
dos y dentro del paquete uno cree el archivo de tipo Java | Java Class
Literales.java , se abrir la ventana de edicin de dicho archivo, y teclee el
siguiente cdigo:
package dos;
ipublic class Literales {
//public String cadena="";
public void representaLiterales() {
int xd= 1234; // literal entera decimal
int xo= 01234; // literal entera octal
int xh= 0x1234; // literal entera hexadecimal
// el operador (+) union de cadenas convierte la variable entera
// a cadena String en formato numrico decimal
System.out.println("xd= " + xd + "\txo= " + xo + "\txh= " + xh);
long xl = 0xDECADAL;
System.out.println("xl= " + xl);
float f1 = 3.14E+15f;
System.out.printf("fl= %3.9f\n" , f1);
double d1 = 1.345e+10d;
System.out.printf("dl= %3.2f\n" , d1);
char c1 = 'a';
char c2 = '\t';
char c3 = '\u0040';
System.out.println("c1= " + c1 + "\tc2= " + c2 + "\tc3= " + c3);
String s1 = "Viva Villa Jijos del Maiz!";
System.out.println("s1= " + s1 + "\n" +
"Mayusculas s1= " + s1.toUpperCase() + "\n" +
"Reversa s1= ".toUpperCase() + new StringBuffer(s1).reverse() );
Pgina 232 de 267

JAVA BSICO
boolean si = true;
boolean no = !si;
boolean noperosi = !no;
System.out.println("si= " + si + "\tno= " + no +
"\tnoperosi= " + noperosi );
/*
cadena+="\n\nMuestra una serie de diversos tipos de variables:\n";
cadena+="decimal\toctal\thexadecimal\n";
cadena+="xd= " + xd + "\txo= " + xo + "\txh= " + xh+"\n";
cadena+="long\n";
cadena+="xl= " + xl+"\n";
cadena+="float\n";
cadena+="f1="+f1 +"\n";
cadena+="double\n";
cadena+="d="+f1+ "\n";
cadena+="char\n";
cadena+="c1= " + c1 + "\tc2= " + c2 + "\tc3= " + c3+"\n";
cadena+="String\n";
cadena+="s1="+s1+ "\n";
cadena+="String to uppercase\n";
cadena+="Mayusculas s1="+s1.toUpperCase()+ "\n";
cadena+="String to reverse\n";
cadena+="Reversa s1="+new StringBuffer(s1).reverse()+ "\n";
cadena+="Booleanos\n";
cadena+="si= " + si + "\tno= " + !si + "\tnoperosi= " + !no+"\n";
*/
} // fin del main
} // fin de la clase literales
3.
4.
5.
6.
Guarde las modificaciones con el comando File | Save .

Compile el programa con Compile File F9
Si hay errores, deprelos y corrija los errores con el editor.
Ejectelo con el comando Run | Run File | Run Literales.java . Observe
la salida del programa en la consola de Output y pruebe con nuevos valores
literales para las variables y vea lo que pasa en la ventana de salida.
7. Evaluacin: Presente las pantalla de salida del programa y mustrelas a su
profesor.
Pgina 233 de 267

JAVA BSICO
PRACTICA 7
Nombre: ________________________________________________________Fecha:_______
Apellido Paterno
Apellido Materno
Nombre(s)
Objetivo: El participante reconocer y extrapolar los smbolos grficos de un

diagrama de flujo y del pseudocdigo.

Desarrollo:
1. Haga doble clic en el acceso directo al archivo jdevw.exe que est en el
escritorio para abrir el IDE NetBeans 5.5.
2. Se trabajar dentro de la carpeta C:\PracticasJava y cree el proyecto
ESTRUCTURAS.
3. Escriba un programa que resuelva el siguiente Ejemplo, con base en el
diagrama de flujo y pseudocdigo, vea la figura 1.
Ejemplo: Construya un algoritmo con diagrama de flujo y en pseudocdigo tal
que, dada la calificacin de un alumno en un curso de computacin que consiste
en el promedio de tres exmenes de la siguiente forma: CAL= (EX1 + EX2 + EX3)
/ 3.0; escriba aprobado si su calificacin es mayor que 7.5 y reprobado en caso
contrario. Las calificaciones deben ser ledas para calcular la variable CAL
4. Cree una nueva clase dentro del proyecto ESTRUCTURAS con el nombre
de Calificacion, con mbito pblico, dentro del paquete ejemplos, y con
mtodo main.
5. Capture con el editor el cdigo fuente siguiente en lenguaje Java para
resolver el Ejemplo 3.
Pgina 234 de 267

JAVA BSICO
package ejemplos;
public class Calificacion {
double ex1,ex2,ex3,cal;
public Calificacion() {
String cadena1 = JOptionPane.showInputDialog(null,"De 1er.examen:");
String cadena2 = JOptionPane.showInputDialog(null,"De 2do.examen:");
String cadena3 = JOptionPane.showInputDialog(null,"De 3er.examen:");
/* Conversion de String a double*/
ex1= new Double(cadena1).doubleValue();
Calificacin c = new Calificacion();
c.cal = (c.ex1 + c.ex2 + c.ex3)/3.0;
if(c.cal >=7.5)
JOptionPane.showMessageDialog(null,"Aprobado con : " + c.cal);
else
JOptionPane.showMessageDialog(null,"Reprobado con:" + c.cal);
System.exit(0);
}//fin del main()
}//fin de la clase Calificacion
Pgina 235 de 267

JAVA BSICO
Figura 1. Diagrama de flujo y pseudocdigo del Ejemplo 3.
6. Complelo. Si hay errores, deprelo y corrija los errores con el editor.

7. Ejectelo
8. Evaluacin: Ejecute de nuevo el programa y de valores diferentes para los
exmenes as:
1er Examen = 9.8 , 2do. Examen = 10.0 , 3er. Examen = 9.2
Capture la pantalla de salida y mustresela a su instructor.
Pgina 236 de 267

JAVA BSICO
PRACTICA 8
Nombre: ________________________________________________________Fecha:_______
Apellido Paterno
Apellido Materno
Nombre(s)
OBJETIVO: Reconocer los smbolos grficos de un diagrama de flujo y del

pseudocdigo y extrapolarlos. El participante aplicar las estructuras de la
programacin estructurada para disear, editar, compilar, ejecutar y depurar si
fuera necesario, un sencillo programa a un lenguaje de programacin como el
Java, en especial los smbolos de la sentencia selectiva mltiple o if anidados.
DESARROLLO:
1. Haga doble clic en el acceso directo al archivo jdevw.exe que esta en el
escritorio para abrir el IDE netbeans 5.5.
2. Vamos a trabajar dentro de la carpeta C:\PracticasJava y cree el proyecto
ESTRUCTURAS.
3. Escribiremos un programa que resuelva el siguiente Ejemplo 4, en base al
diagrama de flujo y pseudocdigo, vea la figura 1.
Ejemplo 4. Elabore un algoritmo con diagrama de flujo y pseudocdigo tal que,
dado como dato una temperatura en grados Centgrados, calcule los grados
Fahrenheit y determine el deporte que es apropiado practicar a esa temperatura,
teniendo en cuenta lo siguiente tabla 1
DEPORTE
Temperatura en grados Fahrenheit
Natacin
>85
Tenis
70 <TEMP<= 85
Golf
32 <TEMP<= 70
Esqu
10 <TEMP<= 32
Marcha
<=10
Tabla 1. Que deporte practicar segn la temperatura.
Pgina 237 de 267

JAVA BSICO
4. Cree una nueva clase dentro del proyecto ESTRUCTURAS con el nombre de
Deporte con mbito pblico, dentro del paquete ejemplos , y con mtodo
main.
5. Capture con el editor el cdigo fuente siguiente en lenguaje Java para resolver
el Ejemplo 4.
package ejemplos;
public class Deporte {
double c, f; // declaracin de variables
public Deporte() {
String cadena =JOptionPane.showInputDialog(null, "De temperatura en Centgrados:");
//Conversin de String a double
c = Double.parseDouble(cadena);
f = c * (9.0/5.0) + 32; // Conversin de grados centgrados a Fahrenheit
} //fin del instructor
Deporte d = new Deporte();
String cad= "El deporte a practicar con: + d.f + " F es : ";
if( d.f > 85 )
cad += " Natacin";
else if ( d.f > 70 )
cad += " Tenis";
cad += " Golf";
cad += " Esqui";
else
cad += " Marcha";
JOptionPane.showMessageDialog(null,cad);
System.exit(0);
}//fin del main()
}//fin de la clase Deporte
Pgina 238 de 267

JAVA BSICO
Figura 1. Diagrama de flujo y pseudocdigo del Ejemplo 4.
6. Complelo.
8. Ejectelo
9. Coloque un punto de ruptura y vea los valores de las variables en la
ventana de Watch.
10. Evaluacin: Ejecute de nuevo el programa y de un valor diferente para los
grados centgrados as:
De temperatura en Centgrados = 25.5
Capture la pantalla de salida y envesela por correo a su profesor.
Pgina 239 de 267

JAVA BSICO
PRACTICA 9
Nombre: ________________________________________________________Fecha:_______
Apellido Paterno
Apellido Materno
Nombre(s)
Objetivo: Reconocer los smbolos grficos de un diagrama de flujo y del

pseudocdigo y extrapolarlos. El participante aplicara las estructuras de la
programacin estructurada para disear, editar, compilar, ejecutar y depurar si
fuera necesario, un sencillo programa a un lenguaje de programacin como el
java, en especial los smbolos de las sentencias del ciclo while(mientras), dowhile (repetir- asta) y for (para).
Desarrollo
Haga doble clic en el acceso directo al archivo jdevw.exe
el escritorio para abrir el IDE netbeans 5.5.
Vamos a trabajar dentro de la carpeta C:\PracticasJava
proyecto ESTRUCTURAS.
que esta en
y cree el
Escribiremos un programa que resuelva el siguiente Ejemplo 5, en base al

diagrama de flujo y pseudocdigo, vea las figuras 1-a, 1-b y 1-c.
Ejemplo 5. Haga el algoritmo en diagrama de flujo y en pseudocdigo que
calcule e imprima la suma de los primeros N nmeros enteros positivos.
Cree una nueva clase dentro del proyecto ESTRUCTURAS con el nombre
de Sumatorias, con mbito pblico, dentro del paquete ejemplos , y con
mtodo main.
Capture con el editor el cdigo fuente siguiente en lenguaje Java para
resolver el Ejemplo 5.
Pgina 240 de 267

JAVA BSICO
package ejemplos;
public class Sumatorias {
int i,n;
double s;
public Sumatorias() {
String cadena = JOptionPane.showInputDialog(null,"Dar N=");
n= Integer.parseInt(cadena); // convertimos la cadena a un valor de tipo int
Sumatorias x = new Sumatorias(); //creamos un objeto x de la clase Sumatorias
x.i = 1; // inciamos i con 1
while ( x.i <= x.n ) {
x.s = x.s + x.i; // acumulamos la suma en s
x.i =x.i + 1; // incrementamos el contador i
} //fin de while
System.out.println ("La suma de los primeros" + x.n );
System.out.println ("nmeros enteros positivos es =" + x.s );
//Ahora con ciclo do - while
//Hay que reiniciar de nuevo las variables, para esto creamos otro objeto
Sumatorias y = new Sumatorias (); // creamos objeto y de la clase Sumatorias
y.i = 1; // iniciamos i con 1
do {
y.s = y.s + y.i; // acumulamos la suma en s
y.i = y.i + 1; // incrementamos el contador i
}while ( y.i <= y.n );
System.out.println ("La suma de los primeros" + y.n );
System.out.println ("nmeros enteros positivos es=" + y.s );
//ahora con el ciclo for hay que crear otro objeto para inicializar
Sumatorias z = new Sumatorias(); // creamos el objeto z de la clase Sumatorias
for ( z.i=1; z.i <= z.n; z.i++ ) // la variable i se incrementa en el for
z.s= z.s + z.i; // acumulamos la suma en s
System.out.println ("La suma de los primeros" + z.n );
System.out.println ("nmeros enteros positivos es =" + z.s );
System.exit (0);
}//fin del main()
}//fin de la clase sumatorias
Pgina 241 de 267

JAVA BSICO
Figura 1-a. Diagrama de flujo del ejemplo 5, con ciclo while (mientras).
Figura 1-b. Diagrama de flujo del ejemplo 5, con ciclo do-while (repetir-hasta).
Pgina 242 de 267
JAVA BSICO
Figura 1-c. Diagrama de flujo del ejemplo 5, con for (para).
Complelo.
Si hay errores, deprelo y corrija los errores con el editor.
Ejectelo
Coloque un punto de ruptura y vea los valores de las variables en la
ventana de Watch.
Evaluacin: Ejecute de nuevo el programa y de un valor diferente para N:
Dar N= 250
Capture la pantalla de salida y envesela por correo a su profesor.
Pgina 243 de 267

JAVA BSICO
PRACTICA 10
Nombre: ________________________________________________________Fecha:_______
Apellido Paterno
Apellido Materno
Nombre(s)
Objetivo: Distinguira la definicin, declaracin y creacin de arrays de objetos en

Java. Escribira un programa en el lenguaje Java con sentencias que impliquen
mtodos de la clase Arraiy para rdenar arreglos en Java y hacer bsquedas
dentro de ellos. En particular mtodos como equals() , fill(), sort(), binarySearch(),
asList().
Instrucciones:
1. Abra el IDE NetBeans 5.5.
2. Cree un proyecto de Java y pngale el nombre Arreglos a su nuevo
proyecto.
3. Escribiremos un programa que resuelva el siguiente Ejemplo 40.
Ejemplo 40: Crear una Java Class de nombre Galleta.java a la cual le
gregaremos un atributo precio de tipo double. Luego crearemos un arreglo
arrGalletas de objetos de la clase Galleta.java y con un comparador
ComparadorPrecioGalleta ordenaremos los objetos por el precio y con el
comparador ComparadorNombrePrecioGalleta ordenaremos por precio y
nombre. Finalmente rellenar la primera mitad del arreglo arrGalletas con un
objeto de la clase Galleta.java.
4. Cree una nueva clase dentro del proyecto Arreglos
con el nombre de
Galleta, con mbito pblico, dentro del paquete apimanejoarrays , y

capture el cdigo siguiente:
Pgina 244 de 267

JAVA BSICO
/package apimanejoarrays;
/**
*@author Oscar Alejandro Gonzlez B.
@version 1.0
*/
/** variables */
String nombre;
public String sabor = "Fresa";
public double precio = 0.0d;
/** constantes */
/** Creates a new instance of Galleta */
public Galleta() {
}// fin del constructor
/** Crea una nueva instancia de Galleta( String nombre ) */
/** Crea una nueva instancia de Galleta( String nombre, String sabor ) */
this( nombre );
this.sabor = sabor;
/** Crea una nueva instancia de Galleta( String nombre,
* String sabor,double precio ) */
public Galleta(String nombre, String sabor, double precio) {
this( nombre, sabor );
this.precio = precio;
/**
* metodo toString() sirve para convertir los valores de
* las variables miembro de la clase Galleta a cadenas y
* esto es convertir el objeto a un String para ver su estado
* @return String
*/
return "[ " + this.nombre +
",\t" + this.sabor +
",\t" + this.precio +
",\t" + this.FORMA +
",\t: " + this.PICOS +
"]";
} // fin del metodo caracteristicasDeLaGalleta
Pgina 245 de 267

JAVA BSICO
5. Complelo. Si hay errores, depure y corrija los errores con el editor.

6. Cree una nueva clase dentro del proyecto Arreglos con el nombre de
ComparadorPrecioGalleta
con mbito pblico, dentro del paquete
apimanejoarrays, y capture el cdigo siguiente:
package apimanejoarrays;
/*
* ComparadorPrecioGalleta.java
* Created on 14 de junio de 2007, 07:40 PM
* @author Oscar A. Gonzlez B.
* Clase para obtener comparacin de dos objetos Galleta en
* en base a su atributo precio
*/
import apimanejoarrays.Galleta;
import java.util.Comparator;
public class ComparadorPrecioGalleta implements Comparator<Galleta> {
/** Creates a new instance of ComparadorCadLongitud */
public ComparadorPrecioGalleta() {
/** metodo redefinido para implementar comparacin
* de dos objetos Galleta en base a su precio. Se
* multiplican por 100 para evitar los decimales ya
* que las galletas valen centavos
*/
public int compare( Galleta a, Galleta b) {
return (int)( b.precio*100 - a.precio*100 );
}// fin del mtodo compare
}// fin de la clase ComparadorPrecioGalleta
7. Complelo.
Si hay errores, depure y corrija los errores con el editor.
ComparadorNombrePrecioGalleta
con mbito
pblico, dentro del
paquete apimanejoarrays, y capture el cdigo siguiente:
Pgina 246 de 267

JAVA BSICO
/*
* ComparadorNombrePrecioGalleta.java
*
* Created on 14 de junio de 2007, 07:40 PM
* @author Oscar A. Gonzlez B.
* Clase para obtener comparacin de dos objetos Galleta en
* en base a su atributo precio
*/
import java.util.Comparator;
public class ComparadorNombrePrecioGalleta implements Comparator<Galleta> {
/** Creates a new instance of ComparadorCadLongitud */
public ComparadorNombrePrecioGalleta() {
/** metodo redefinido para implementar comparacin
* de dos objetos Galleta en base a su precio. Se
* multiplican por 100 para evitar los decimales ya
* que las galletas valen centavos
*/
public int compare( Galleta a, Galleta b) {
// si las dos galletas tienen el mismo precio
if ( (int)( b.precio*100 ) - (int) ( a.precio*100 ) == 0 )
// compara lexicograficamente los nombres de las galletas
return a.nombre.compareTo( b.nombre );
else
return (int)( b.precio*100 - a.precio*100 );
}// fin del mtodo compare
}// fin de la clase ComparadorNombrePrecioGalleta
9. Complelo. Si hay errores, depure y corrija los errores con el editor.

ManejoArraysTres,
con mbito
pblico, dentro del paquete
apimanejoarrays, y capture el cdigo siguiente:
Pgina 247 de 267

JAVA BSICO
import apimanejoarrays.ComparadorPrecioGalleta;
import apimanejoarrays.ComparadorNombrePrecioGalleta;
import java.util.Arrays;
/**
* @author Oscar A. Gonzlez Bustamante.
*Muestra arrays de objetos Galleta y su ordenacin
*sort(), su relleno con fill() y busqueda binaria
*con binarySearch() utilizando comparadores
*con su atributo precio.
*/
public class ManejoArraysTres {
/** Creates a new instance of ManejoArraysTres */
public ManejoArraysTres() {
public static void main(String args[] ) {
Galleta[] arrGalletas = { // definicin y declaracin esttica
new Galleta("Estrella de chocolate ", "Chocolate", 50),
new Galleta("Estrella de coco
", "Coco ", 56),
new Galleta("Estrellita del rio ", "Vainilla ", 76),
new Galleta("Estrellita del norte ", "Miel ", 76),
new Galleta("Estrellita del mar ", "Moca ", 76),
new Galleta("Estrellita del oceano ", "Fresa ", 76),
new Galleta("Estrellita del cielo ", "Nuez ", 76),
new Galleta("Estrella fugaz meteoro", "Vainilla ", 90),
new Galleta("Estrella fugaz cometa ", "Coco ", 90)
};
// Orden natural de las galletas
System.out.println("\nArreglo de Galletas orden natural");
imprimeArray( arrGalletas );
// ordena con el comparador precio de las Galletas
Arrays.sort( arrGalletas, new ComparadorPrecioGalleta());
System.out.println("\nArreglo de Galletas orden por precio");
// ordena con el comparador de nombre y precio de las Galletas
Arrays.sort( arrGalletas, new ComparadorNombrePrecioGalleta());
System.out.println("\nArreglo de Galletas orden por nombre de la +
" galleta y su precio");
// orden natural con el comparador como requisito
// previo para la busqueda binaria
System.out.println("\nBusqueda de un dato dentro del arreglo " +
" de Galletas con bynarySearch");
int indice = Arrays.binarySearch( // regresa indice del elemento buscado
arrGalletas, //array donde buscar
new Galleta("Estrellita del cielo ", "Nuez ", 76), //elemento a buscar
new ComparadorNombrePrecioGalleta() // comparador
);
System.out.println("\narrGalletas[ " + indice + " ]= " + arrGalletas[ indice ] );
Pgina 248 de 267

JAVA BSICO
System.out.println("\nRelleno del arreglo de Galletas de 0 a la mitad");

// creamos un objeto de tipo Galleta para rellenar la mitad del array
Galleta relleno = new Galleta("La estrellita del sur", "Melocotn", 37);
Arrays.fill(arrGalletas, 0, (int)( arrGalletas.length / 2), relleno );
System.out.println("\nFin del programa");
}// fin del mtodo main
/**
* imprimeArray es un mtodo que recibe un array de Object de una dimensin
* y como todas las clases son subclases de Object , luego por Upcasting
* puede recibir el arreglo de Galletas e invocar a sus mtodo
* toString() para imprimir los objetos Galleta
**/
public static void imprimeArray( Object[] obj ) {
for ( int k= 0; k < obj.length; k++ )
System.out.println( obj[k].toString() );
}// fin del mtodo Array
}// fin de la clase ManejoArraysTres
Complelo. Si hay errores, depure y corrija los errores con el editor.

Ejectelo. Al ejecutar el programa ManejoArraysTres.java
Evaluacin:
Cree una nueva clase ComparadorSaborPrecioGalletas.java donde
el primer criterio de comparacin sea el precio y el segundo sea el
sabor de la galleta.
Ordene el arreglo arrGalletas con el mtodo sort() enmpleando el
ComparadorSaborPrecioGalletas
Imprima el arreglo arrGalletas con el mtodo imprimeArray(Object[]
obj ) .
Ejecute de nuevo el programa del ejemplo 40, agregando una nueva
galleta al arreglo arrGalletas, por ejemplo: new Galleta("Estrellita del
universo ", "Pia
", 78), codifique en el mtodo main su busqueda
binaria con el mtodo binarySearch()
utilizando la clase
ComparadorSaboPrecioGalletas como criterio de la busqueda y
que imprima el resultado de la bsqueda.
Pgina 249 de 267

JAVA BSICO
Convierta el arreglo arrGalletas en una coleccin de tipo List con el

mtodo Arrays.asList( arrGalletas ) as List<Galleta> listaGalletas
= Arrays.asList( arrGalletas );
Escriba el programa ConvierteArrayaLista.java y ejecutelo. Cheque
su salida, en especial vea el uso de los mtodos Arrays.asList(),
add(), size(), listIterator(), hasNext() y next().
}
import java.util.Arrays;
import java.util.List;
import java.util.LinkedList;
import java.util.ListIterator;
/**
*
* @author Oscar
*/
public class ConvierteArrayaLista {
/** Creates a new instance of ConvierteArrayaLista */
public ConvierteArrayaLista() {
}
public static void main( String[] args ) {
Galleta[] arrGalletas = { // definicin y declaracin esttica
new Galleta("Estrella de chocolate ", "Chocolate", 50),
new Galleta("Estrella de coco
", "Coco ", 56),
new Galleta("Estrellita del rio ", "Vainilla ", 76),
new Galleta("Estrellita del norte ", "Miel ", 76),
new Galleta("Estrellita del mar ", "Moca ", 76),
new Galleta("Estrellita del oceano ", "Fresa ", 76),
new Galleta("Estrellita del cielo ", "Nuez ", 76),
new Galleta("Estrella fugaz meteoro", "Vainilla ", 90),
new Galleta("Estrella fugaz cometa ", "Coco ", 90)
};
// convierto el arreglo arrGalletas en una Lista de Galletas con asList()
List<Galleta> listaGalleta = Arrays.asList( arrGalletas );
// construyo una lista ligada con la listaGalletas para agregar elementos
LinkedList<Galleta> listaLigadaGalleta = new LinkedList<Galleta>( listaGalleta );
// creo otra galleta
Galleta talia = new Galleta("Estrellita de la televisin ", "Cajeta ", 95);
// checo numero de elementos en la lista ligada
System.out.println("Nmero de elementos en la lista ligada: " + listaLigadaGalleta.size()
);
Pgina 250 de 267
JAVA BSICO
// agrego una galleta a la lista ligada

listaLigadaGalleta.add( talia ); // agrego a la final de la lista ligada
// vuelvo a checar el numero de lementos
System.out.println("Nmero de elementos en la lista: " + listaLigadaGalleta.size() );
// agrego otra galleta a la mitad de la lista ligada
listaLigadaGalleta.add( (int)(listaLigadaGalleta.size() / 2 ), talia );
// checo de nuevo el nmero de galletas en la lista ligada
System.out.println("Nmero de elementos en la lista ligada: " + listaLigadaGalleta.size() );
// imprimo las galletas de la lista ligada con un ListIterator
ListIterator i = listaLigadaGalleta.listIterator();
while(i.hasNext())
System.out.println(i.next().toString() );
System.out.println("\nFin del programa.");
} // fin del main
}// fin de la clase ConvierteArrayaLista
Capture las pantallas de salida de ejecucin del programa junto y enveselas por
correo a su profesor en un archivo compactado. No olvide incluir su nombre en la
portada.
Pgina 251 de 267

JAVA BSICO
PRACTICA 11
Nombre: ________________________________________________________Fecha:_______
Apellido Paterno
Apellido Materno
Nombre(s)
Objetivo: El participante reconocer los smbolos grficos de un diagrama de

UML para definir una subclase que tenga una relacin is-a ( es una ) con otra
superclase existente. y producir un proyecto de tipo java applicacin que
mediante un diagrama de clases donde se aprecie la herencia con la notacin
grfica de UML haga su extrapolacin a cdigo en lenguaje Java.
Instrucciones: Lea con atencin y realice lo que se le pide en cada punto.

Desarrollo:
1. En base a las relaciones de herencia es-un ( is -a ) que se aprecian en la
Figura 1., donde la clase Bosque esta compuesta de una arreglo pinitos u
objetos de la clase Pino. A esta relacin de asociacin entre clases se le llama
composicin y es una asociacin fuerte. Esto quiere decir, para este caso, que
un Bosque no puede existir si no esta compuesto de uno o muchos objetos
Pino. Esta relacin en UML esta representada por un rombito negro que va de
la clase Bosque a la clase Pino. ( ojo esta relacin no es herencia sino
composicin y se conoce como la relacin tiene - un ) , vea la figura 1.
Figura 1. Relaciones de herencia y de composicin que es una asociacin fuerte entre la

clase Bosque a Pino. La etiqueta pinitos es el nombre de la relacin entre estas dos clases
Pgina 252 de 267
JAVA BSICO
Genere un nuevo Java Project HERENCIA y en el paquete ecologia escriba

los cdigos en Java de las clases mostradas en la figura 1. Agregue a cada
constructor una sentencia System.out.println() de salida a cada constructor, y a
la clase Bosque.java agrguele el mtodo public static void main( String args[]
) para ejecutar la aplicacin, como se ve en los cdigos que se listan a
continuacin:
Archivo Planta.java
package ecologia;
public class Planta {
public Planta() {
System.out.println("Hola soy una Planta");
}// fin de la clase Planta
Archivo Arbol.java
package ecologia;
public class Arbol extends Planta {
public Arbol() {
System.out.println("Hola soy un Arbol");
}// fin de la clase Arbol
Archivo Pino.java
package ecologia;
public class Pino extends Arbol {
public Pino() {
System.out.println("Hola soy un Arbol");
}// fin de la clase Pino
Archivo Bosque.java
package ecologia;
public class Bosque {
public Pino pinitos; // composicin o asociacin fuerte
public Bosque() {
pinitos = new Pino();
System.out.println("Hola soy un Bosque");
Bosque ajusco = new Bosque();
}// fin del main
}// fin de la clase Bosque
Pgina 253 de 267

JAVA BSICO
Salida al ejecutar el programa Bosque.java .

Compiling 1 source file to C:\PracticasJava\HERENCIA\build\classes
compile-single:
run-single:
Hola soy una Planta
Hola soy un Arbol
Hola soy un Arbol
Hola soy un Bosque
BUILD SUCCESSFUL (total time: 1 second)
Evaluacin:
Modifique las clases Planta.java, Arbol.java, Pino.java y Bosque.java
editndolas de acuerdo al diagrama UML de las relaciones de clases de la figura 2
y a los cdigos que se muestran a continuacin:
Archivo Planta.java
package ecologia;
public class Planta {
private String nombre; // atributos privados no se heredan
private int aos;
public Planta() { System.out.println("Soy una Planta"); }
public Planta (String nombre ) {
}
public Planta( String nombre, int aos) {
this(nombre);
this.aos = aos;
}
public String getNombre() { return nombre; }
public void setNombre(String val) { this.nombre = val; }
public int getAos() { return aos; }
public void setAos(int val) { this.aos = val; }
StringBuffer buf
= new StringBuffer("Planta nombre: " +
this.getNombre() );
return buf.toString();
}
} // fin de la clase Planta
Pgina 254 de 267

JAVA BSICO
Archivo Arbol.java
package ecologia;
public class Arbol extends Planta {
protected double diametrotronco;
protected double altura;
protected int noanillos;
public Arbol() {
System.out.println("soy un Arbol");
}
public Arbol( double diametrotronco ) {
this.diametrotronco = diametrotronco;
}
public Arbol(double diametrotronco, double altura ) {
this( diametrotronco );
this.altura = altura;
}
public Arbol(double diametrotronco, double altura,
int anillos, String nombre ) {
super ( nombre ); // invocando al constructor de la superclase
this.diametrotronco = diametrotronco;
this.altura = altura;
this.setAos( this.dameaos( anillos ) ); // calculando aos
}
public int dameaos(int noanillos) {
this.setAos( noanillos * 2 ); // por cada anillo hay 2 aos
return this.getAos() ;
}
/* sobreescribe al mtodo toString() de la superclase */
StringBuffer cad = new StringBuffer( super.toString());
cad.append("\tDimetro tronco: " + this.diametrotronco );
cad.append("\tAltura: " + this.altura );
cad.append( "\tAos: " + this.getAos() );
return cad.toString();
} // fin del mtodo toString
}// fin de la clase Arbol
Pgina 255 de 267

JAVA BSICO
Archivo Pino.java
package ecologia;
public class Pino extends Arbol {
protected String especie;
public Pino() {
System.out.println( "Soy un Pino");
}
public Pino( String especie ) {
this.especie = especie;
System.out.println("Soy un Pino de especie: "
+ this.especie );
}
public Pino( String especie, double diametrotronco, double altura,
int anillos, String nombre ) {
super( diametrotronco, altura, anillos, nombre);
this.especie = especie;
} // fin de constructor
public String toString(){
StringBuffer cadena = new StringBuffer( super.toString() );
cadena.append("\tEspecie : " + this.especie );
return cadena.toString();
} // fin del mtodo toString()
} // fin de la clase Pino
Archivo Bosque.java
package ecologia;
public class Bosque {
public Pino[] pinitos; // definicin de un arreglo de Pino
public Bosque() {
this.pinitos = new Pino[3]; // construccin de 3 referencias
// instanciacin de cada Pino para el array pinitos
pinitos[0]= new Pino("Pino Abeto", 150.0, 18.6 , 40, "Arbol" );
pinitos[1]= new Pino("Pino Piero", 18.0, 3.6 , 6, "Arbol" );
pinitos[2]= new Pino("Pino Japones", 150.0, 4.6 , 10, "Arbol" );
// salida a pantalla en un ciclo
for (int i=0; i < pinitos.length; i++ )
System.out.println( pinitos[ i ] ); // pintitos[i].toString()
Bosque ajusco = new Bosque(); // instancio un Bosque
System.out.println("Fin del programa Bosque.java");
} // fin del main
} // fin de la clase Bosque
Pgina 256 de 267

JAVA BSICO
Modifique el programa Pino.java. Agruegue otros 3 objetos de la clase Pino para

que sean 6 pinitos.
Figura 2. Jerarqua de clases resultado de la ingeniera en reversa.
No olvide guardar el proyecto y todos sus programas para integrarlos a su

prctica final al final del curso.
Ejecute el programa Bosque.java y mustresela a su profesor.
Fin del ejercicio.

Pgina 257 de 267
JAVA BSICO
PRACTICA 12
Nombre: ________________________________________________________Fecha:_______
Apellido Paterno
Apellido Materno
Nombre(s)
OBJETIVO: Reconocer la relacin de herencia que se establece cuando una

nueva clase es una subclase de otra superclase.
Distinguir los tipos de
miembros que se heredan como nuevos, recursivos y sobrescritos. Crear un
conjunto de clases estableciendo entre ellas la relacin de herencia, partiendo
desde una clase base abstracta y derivando a subclases concretas. Aplicar el
llamado a mtodos polimrficos declarados en la superclase abstracta y
redefinidos o sobrescritos en las subclases concretas.
Instrucciones:
1. Abra el IDE NetBeans 5.5.
2. Cree un proyecto de Java y pngale el nombre Polimorfismo a su nuevo
proyecto.
3. Escribiremos un programa que resuelva el siguiente Ejemplo 11.
Ejemplo 11: Supongamos que queremos hacer un software que maneje figuras
geomtricas. Nuestro software tendr como caracterstica principal, calcular sus
reas correspondientes, etc. Podemos partir de una definicin abstracta de figura,
entonces partimos de la definicin de una clase abstracta.
4. Cree una nueva clase abstracta dentro del proyecto Polimorfismo con el
nombre de Figura, con mbito pblico, dentro del paquete dgsca.unam. ,
y capture el cdigo siguiente:
Pgina 258 de 267

JAVA BSICO
package dgsca.unam;
// esta es la clase abstracta
public abstract class Figura
{
private double area; // variable miembro privada
// constructores
public Figura() // constructor por default
{
System.out.println("soy el constructor de la clase abstracta Figura() ");
public Figura(String tipo) // constructor con un argumento String
{
System.out.println("soy el constructor de la clase abstracta Figura() " +
" y voy a crear un " + tipo );
// mtodos abstractos
public abstract void dibuja();
public abstract void borra();
public abstract void calculaArea();
public abstract String escribeArea();
// mtodos accesores
// observe que una clase abstracta puede tener metodos concretos
public double getArea()
{
return this.area;
}
public void setArea( double area )
{
this.area = area;
}
} // Fin de la clase abstracta Figura
5. Complelo.
6. Si hay errores, depure y corrija los errores con el editor.
7. Cree una nueva clase dentro del proyecto Polimorfismo con el nombre de
Triangulo y que sea subclase de la clase abstracta Figura, con mbito
pblico, dentro del paquete dgsca.unam, y capture el cdigo siguiente:
Pgina 259 de 267

JAVA BSICO
package dgsca.unam;
public class Triangulo extends Figura
{
protected double base, altura;
//Constructores
public Triangulo( double base, double altura )
{
super ( "Tringulo");
this.base = base; this.altura = altura;
// mtodos redefinidos o sobreescritos.
public void borra()
{
System.out.println("borro tringulo" );
}
public void dibuja()
{
System.out.println("dibujo tringulo");
}
public void calculaArea()
{
this.setArea( this.base * this.altura / 2.0d ) ;
}
public String escribeArea()
{
this.calculaArea();
return "\nEl area de un tringulo de base: " + this.base + " y altura : " +
this.altura + " es igual a : " + getArea() ;
}
} // fin de la clase Triangulo
8. Complelo.
Rectangulo y que sea subclase de la clase abstracta Figura, con mbito
Pgina 260 de 267

JAVA BSICO
package dgsca.unam;
public class Rectangulo extends Figura
{
protected double alto , ancho;
public Rectangulo( double alto , double ancho )
{
super( "Rectngulo" );
this.alto = alto; this.ancho = ancho;
public void borra()
{
System.out.println("borro rectngulo" );
}
{
System.out.println("dibujo rectngulo");
}
{
this.setArea( this.ancho * this.alto ) ;
}
{
this.calculaArea();
return "\nEl area de un rectngulo de ancho: " + this.ancho + " y altura : " +
this.alto + " es igual a : " + getArea() ;
}
}// fin de la clase Rectangulo
11. Complelo.
Circulo y que sea subclase de la clase abstracta Figura, con mbito
Pgina 261 de 267

JAVA BSICO
package dgsca.unam;
public class Circulo extends Figura
{
protected double radio;
protected Circulo( double radio )
{
super( "Circulo") ; // invoco al constructor de la superclase abstracta
// Figura con un argumento String
this.radio = radio;
public void borra()
{
System.out.println("borro circulo" );
}
{
System.out.println("dibujo circulo");
}
{
this.setArea( Math.PI * radio * radio ) ;
}
{
this.calculaArea();
return "\nEl area de un circulo de radio: " + this.radio + " es igual a : " + getArea() ;
}
} // fin de la clase Circulo
UsaFiguras, con mbito publico, dentro del paquete dgsca.unam y con
mtodo main, y capture el cdigo siguiente:
Pgina 262 de 267

JAVA BSICO
package dgsca.unam;
public class UsaFiguras
{
public static void main( String[] args )
{
Figura f1 = new Circulo( 30.0d ); // upcasting
Figura f2 = new Triangulo( 30.0d , 40.0d ); // upcasting
Figura f3 = new Rectangulo( 40.0d , 30.0d ); // upcasting
f1.dibuja(); f1.borra();
System.out.println( f1.escribeArea() +
f2.escribeArea() +
f3.escribeArea() );
System.exit( 0 ); // fin del proceso
} // fin del mtodo main()
} // fin de UsaFiguras
15. Complelo.
17. Ejectelo. Al ejecutar este programa nos da el siguiente resultado:
soy el constructor de la clase abstracta Figura() y voy a crear un Circulosoy el
constructor de la clase abstracta Figura() y voy a crear un Tringulosoy el
constructor de la clase abstracta Figura() y voy a crear un Rectngulodibujo
circuloborro circulodibujo tringuloborro tringulodibujo rectnguloborro rectngulo
El area de un circulo de radio: 30.0 es igual a : 2827.4333882308138
El area de un tringulo de base: 30.0 y altura : 40.0 es igual a : 600.0
El area de un rectngulo de ancho: 30.0 y altura : 40.0 es igual a : 1200.0Fin del
programa
Process exited with exit code 0
18. Para ejercitar el polimorfismo dinmico, cree una nueva clase dentro del
proyecto Polimorfismo con el nombre de UsaFigurasDos, con mbito
publico, dentro del paquete dgsca.unam y con mtodo public static void
main( String args[] ) , y capture el cdigo siguiente:
Pgina 263 de 267

JAVA BSICO
/**
* Programa de java que ejemplifica el uso
* de las clases que heredan mtodos
* de una clase base para as poder
* implementar polimorfismo y el enlazamiento
* tardio o enlazamiento dinmico
* que ocurre en tiempo de ejecucin.
* @version 1.0
* Archivo: UsaFigurasDos.java
*/
package dgsca.unam;
public class UsaFigurasDos {

// este metodo regresa figuras al azar
public static Figura figuraalAzar() {
switch ( (int) (Math.random() * 3) ) {
case 0 : return new Circulo(30);
case 1 : return new Rectangulo(40,30);
case 2 : return new Triangulo(30, 40 );
default : return null;
}
}
public static void main( String argumentos[] ) {
Figura f[]= new Figura[9]; // crea un arreglo de 10 referencias a Figura
// llena el arreglo con figuras
for ( int i=0; i < f.length; i++ )
f[i] = figuraalAzar();
// Hace llamadas a los metodos polimrficos con
// enlazamiento dinmico o early binding
for ( int i=0; i < f.length; i++ )
System.out.println(f[i].escribeArea());
}
} // fin de UsaFigurasDos
19. Complelo.
Pgina 264 de 267

JAVA BSICO
21. Ejectelo. Al ejecutar este programa nos puede dar un resultado como el
siguiente ya que cambia debido al polimorfismo dinmico, porque la figura
que regresa el mtodo figuraalAzar() es aleatorio:
soy el constructor de la clase abstracta Figura() y voy a crear un Circulosoy el
constructor de la clase abstracta Figura() y voy a crear un Circulosoy el constructor
de la clase abstracta Figura() y voy a crear un Circulosoy el constructor de la clase
abstracta Figura() y voy a crear un Tringulosoy el constructor de la clase
abstracta Figura() y voy a crear un Rectngulosoy el constructor de la clase
abstracta Figura() y voy a crear un Circulosoy el constructor de la clase abstracta
Figura() y voy a crear un Rectngulosoy el constructor de la clase abstracta
Figura() y voy a crear un Circulosoy el constructor de la clase abstracta Figura() y
voy a crear un Tringulo
El rea de un circulo de radio: 30.0 es igual a : 2827.4333882308138
El rea de un tringulo de base: 30.0 y altura : 40.0 es igual a : 600.0
El rea de un rectngulo de ancho: 30.0 y altura : 40.0 es igual a : 1200.0
El rea de un rectngulo de ancho: 30.0 y altura : 40.0 es igual a : 1200.0
El rea de un tringulo de base: 30.0 y altura : 40.0 es igual a : 600.0Fin del
programaProcess exited with exit code 0.
Evaluacin: Ejecute de nuevo el programa del ejemplo 11, agregando una nueva
figura, por ejemplo el pentgono. Implemente los mtodos abstractos de la clase
abstracta Figura para la nueva subclase Pentgono:
// mtodos abstractos
public abstract void dibuja();
public abstract void borra();
public abstract void calculaArea();
public abstract String escribeArea();
Pgina 265 de 267

JAVA BSICO
Modifique el mtodo figuraalAzar() de la clase UsaFiguras2 para que tenga una

opcin que nos regrese un objeto un objeto de la clase Pentgono.
Capture las pantallas de salida de ejecucin del programa junto y enveselas por
correo a su profesor en un archivo compactado. No olvide incluir su nombre en la
portada.
Pgina 266 de 267

JAVA BSICO
Pgina 267 de 267

Manualjava STC

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manualjava STC

Cargado por

Copyright:

Formatos disponibles

JAVA BSICO

Av. Juan de Dios Btiz s/n esq. Miguel Othn de Mendizbal,

2.7.4 De creacin de un objeto .................................................................... 86

4.4.3 Arrays multidimensionales ............................................................... 132

Creacin y destruccin de objetos en una jerarqua de herencia ... 160

5.6 Redefinicin de miembros ...................................................................... 161

1. INTRODUCCION A LA TECNOLOGIA Y PLATAFORMA JAVA

Figura 1. James Gosling y su mascota en la camiseta Duke.

Oak se us para solicitar un proyecto sobre un sistema operativo para consolas de

desecho y no saba qu hacer con l. Por suerte, la revolucin de Internet haba

1.2 Panorama actual y tipos de ediciones del lenguaje

Es la edicin estndar anterior, pero con el agregado de distintas tecnologas

1.2.1Caractersticas del Lenguaje de programacin Java

Java es un lenguaje Orientado a Objetos porque ste paradigma de la

Interpretado: Java es un lenguaje interpretado, porque sus cdigos de programas

interfaces, ocultando as las implementaciones. Si la implementacin cambia como

(http://java.sun.com/docs/books/jls/) Language Specification.

Multitarea: Java es un lenguaje que soporta mltiples threads (hilos, procesos,

1.3 Instalacin de Java SE

Estos requerimientos estn publicados en:

El JDK es un conjunto de herramientas y utileras que en resumen son:

El entorno de programacin integrado ms popular es el NetBeans y la versin

Los requerimientos para instalar el NetBeans IDE 6.9 estn publicados en

Instalacin de JDK 6 Actualizacin 20 con el NetBeans 6.9 (o la versin ms

Figura 1-5. rbol de directorios o carpetas de instalacin del JDK 6

En el cuadro de dilogo que le pregunta si desea instalar el JDK, SE 1.6.0_20, se

Figura 1-6. Cuadro de dialogo de configuracin de la instalacin del JDK 6

El asistente instalar los siguientes componentes del JDK 6:

Por default el asistente le creara la siguiente ruta

extensin .jar. Aunque son archivos.jar, no debe descomprimirlos. El JDK puede

1.4 Elementos que integran JAVA SE

Plataforma de desarrollo (Windows, Linux, Mac OS X, o cualquier otro):

Las clases estn contenidas en los archivos con extensin .java

Cada clase tiene su propio archivo

Compilacin: al poco tiempo de aparecer en escena el lenguaje Java, las

tambin la tiene en mente. Podrn surgir placas base compartiendo procesadores

Java EE (Enterprice Edition):

JAVA ME (Micro Edition):

Escribe una vez y ejecuta en cualquier plataforma

JDK: en el caso de que adems de ejecutar las aplicaciones en el ordenador de

El quid de la cuestin est en tener instalada la MVJ propia de cada plataforma

1.5 Variables de ambiente

estn en la carpeta lib en formato .jar (Java Archive) y es el archivo tools.jar,

o si ya creaste la variable JAVAHOME

para apuntar a C:\Archivos de

programa\Java\jdk1.6.0_20\. se puede hacer lo siguiente:

Inicio->Configuracin ->Panel de Control ->Sistema ->Ventana de "Propiedades

1.6 Prueba de instalacin

Figura 1-8. Prueba de que esta ejecutndose el JRE versin 1.6.0_20

Su primera aplicacin de Java

Son ms parecidos a los programas que usted.

Suele usar en su computadora (los ejecuta localmente con su ratn o escribiendo

Compilacin y ejecucin del programa en Windows.

Figura 1-10. Compilando Hola.java en la consola de MSDOS.

Figura 1-11. Ejecucin del programa con el intrprete de Java JDK 6

1.7 Obtencin del IDE NetBeans 6.0

http://dlc.sun.com.edgesuite.net/netbeans/6.9/rc/ y descargue el NetBeans con las

Para iniciar el proceso de instalacin. Aparecer una ventana de configuracin del

Figura 1-13. Ventana de bienvenida del instalador del NetBeans 6.9

Figura 1-14. Donde se determina las carpetas o directorios de instalacin.

Le da clic al botn Next> y comienza la instalacin, ver Figura 1-15.

Figura 1-15.: Avance de instalacin, al cubrir el 100% se concluye la instalacin.

Al concluir, le pregunta si quiere contribuir con sus datos, y le da clic a Finish.En el