ASESOFTWARE S.A.

PROGRAMACION EN JAVA
Manual del Estudiante
Agosto 6 de 2012 Versión 3.0

© Asesoftware S.A.S. Reservados todos los derechos.

Ninguna parte de este documento puede ser reproducida o transmitida de ninguna forma, ni
por ningún medio ya sea electrónico o mecánico, con ningún propósito, sin la previa
autorización por escrito de Asesoftware Ltda.

Visual Cafe es marca registrada de Symantec.

Visual Age es marca registrada de IBM.
JDeveloper es marca registrada de Oracle Corporation.

PROGRAMACION BASICA EN JAVA

 ASESOFTWARE S.A.S

Tabla de Contenido

1 Introducción ....................................................................................................................... 1
1.1 Historia ........................................................................................................................... 1
1.2 Java y su JDK ................................................................................................................. 1
1.3 Arquitectura .................................................................................................................... 4
1.4 Por qué Utilizar Java....................................................................................................... 5
2 Fundamentos de Programación Orientada a Objetos.................................................... 9
2.1 Complejidad del Software .............................................................................................. 9
2.2 Paradigma Orientado a Objetos .................................................................................... 10
2.3 Conceptos Básicos OO ................................................................................................. 11
3 Programación Básica en Java......................................................................................... 17
3.1 Introducción .................................................................................................................. 17
3.2 Sintaxis ......................................................................................................................... 17
3.3 Bienvenida a la Programación en Java ......................................................................... 17
3.4 Variables y Tipos de Datos ........................................................................................... 19
3.5 Operadores .................................................................................................................... 21
3.6 Arreglos ........................................................................................................................ 24
3.7 Estructuras de Control .................................................................................................. 25
4 Clases en JAVA................................................................................................................ 33
4.1 Encapsulamiento y Visibilidad ..................................................................................... 34
4.2 Definición de Clases ..................................................................................................... 35
4.3 Declaración de Atributos .............................................................................................. 37
4.4 Declaración de Métodos ............................................................................................... 38
4.5 Manejo de la Memoria en Java. .................................................................................... 39

PROGRAMACION BASICA EN JAVA

 ASESOFTWARE S.A.S

5 Herencia ............................................................................................................................ 43
5.1 Redefinición de Métodos .............................................................................................. 44
5.2 Super ............................................................................................................................. 44
5.3 Clases Abstractas vs Clases Concretas ......................................................................... 44
5.4 Polimorfismo ................................................................................................................ 45
6 Cadena de caracteres (String) ........................................................................................ 47
6.1 Creación de Objetos Tipo String .................................................................................. 47
6.2 Comparación de Cadenas ............................................................................................. 47
6.3 Concatenación de Cadenas ........................................................................................... 48
6.4 Operaciones de búsqueda ............................................................................................. 48
6.5 Clase StringBuffer ........................................................................................................ 49
7 Interfaces .......................................................................................................................... 51
7.1 Definición de Interfaces ................................................................................................ 52
7.2 Implementación de Interfaces ....................................................................................... 53
8 Paquetes ............................................................................................................................ 55
8.1 Import ........................................................................................................................... 55
8.2 Package ......................................................................................................................... 56
8.3 CLASSPATH y el Sistema de Archivos ...................................................................... 56
8.4 Opcion -d ...................................................................................................................... 57
9 Colecciones ....................................................................................................................... 59
9.1 Definición ..................................................................................................................... 59
9.2 Tipos de Colecciones .................................................................................................... 59
9.3 Clases que implementan las interfaces ......................................................................... 61
9.4 Interfaz Iterator ............................................................................................................. 63
9.5 Las Interfaces de Map .................................................................................................. 63
9.6 Las clase Map ............................................................................................................... 64
9.7 Colecciones en JDK 1.1................................................................................................ 65
9.8 Clases Genéricas y Colecciones (J2SE 5.0) ................................................................. 65

PROGRAMACION BASICA EN JAVA

 ASESOFTWARE S.A.S

10 Excepciones .................................................................................................................... 68
10.1 Excepciones en Java ................................................................................................... 68
10.2 Throwable ................................................................................................................... 69
10.3 Manejo de excepciones ............................................................................................... 70
10.4 Captura de excepciones .............................................................................................. 70
10.5 Declaración de excepciones ........................................................................................ 72
10.6 Definición de nuevas excepciones .............................................................................. 73
10.7 Consideraciones .......................................................................................................... 74
10.8 Aserciones................................................................................................................... 74
11 Clases Anidadas ............................................................................................................. 76
11.1 Propiedades de las clases Internas .............................................................................. 79
11.2 Clases Internas vs. Anidadas ...................................................................................... 79
12 Streams ........................................................................................................................... 80
12.1 InputStream................................................................................................................. 80
12.2 OutputStream .............................................................................................................. 81
12.3 Manejo de archivos ..................................................................................................... 81
12.4 Serialización ............................................................................................................... 83
12.5 Sockets ........................................................................................................................ 85
13 Applets ............................................................................................................................ 88
13.1 Tag Applet de HTML ................................................................................................. 88
13.2 Ciclo de vida de un Applet ......................................................................................... 89
13.3 Parametrización de Applets ........................................................................................ 90
13.4 Restricciones de los Applets ....................................................................................... 91
14 Interfaces Gráfica de Usuario ...................................................................................... 92
14.1 Componentes AWT .................................................................................................... 92
14.2 Manejo de eventos ...................................................................................................... 95
15 Programación Multihilos (Threads) .......................................................................... 102
15.1 Fundamentos de los Hilos: ....................................................................................... 102

PROGRAMACION BASICA EN JAVA

 ASESOFTWARE S.A.S

15.2 Implementando la Interface Runnable ...................................................................... 103

15.3 Creando una subclase de la clase Thread ................................................................. 104
15.4 Programador de Hilos ............................................................................................... 105
15.5 Estado de los Hilos ................................................................................................... 105
15.6 Prioridades de los Hilos ............................................................................................ 106
15.7 Métodos isAlive() y join() ........................................................................................ 107
15.8 Método Thread.Yield() ............................................................................................. 108
15.9 Sincronización de Hilos (threads) ............................................................................. 109
15.10 DeadLock (Abrazo mortal) ..................................................................................... 110
15.11 Métodos wait() y notify()........................................................................................ 110
16 JDBC ............................................................................................................................. 113
16.1 Introducción .............................................................................................................. 113
16.2 Qué hace JDBC ? ...................................................................................................... 113
16.3 Interfaces que conforman el API JDBC ................................................................... 114
16.4 Drivers JDBC............................................................................................................ 114
17 Código JDBC ............................................................................................................... 116
17.1 Implementación de aplicaciones JDBC .................................................................... 116
17.2 Transacciones ........................................................................................................... 120
18 Ejercicios ...................................................................................................................... 121
18.1 Capitulo 1.................................................................................................................. 121
18.2 Capitulo 3.................................................................................................................. 122
18.3 Capitulo 4 y 5............................................................................................................ 124
18.4 Capitulo 6.................................................................................................................. 127
18.5 Manejo de archivos ................................................................................................... 130
18.6 Ejercicio Arreglos y Colecciones ............................................................................. 133
18.7 Ejercicio AWT .......................................................................................................... 137
18.8 Ejercicio. Interfaces Gráfica de Usuario - JDBC...................................................... 140

PROGRAMACION BASICA EN JAVA

 ASESOFTWARE S.A.S

1 Introducción

1.1 Historia

En 1991 Sun Microsystems dio inicio al proyecto de investigación Oak liderado por James
Gosling, con el objetivo de crear un lenguaje de programación liviano, rápido, eficiente y
portable que pudiera ser empleado en el desarrollo de software para electrodomésticos
como televisores, radios y reproductoras de videos.

A pesar de las bondades del lenguaje Oak, su verdadero potencial fue explotado a partir de
1994 con el desarrollo de un navegador Web denominado HotJava, con la capacidad de
cargar, instalar y ejecutar programas (denominados applets) de forma automática a través
de la red. Posteriormente, Netscape adoptó las mismas capacidades de HotJava,
consolidando a Java como el lenguaje de facto para el desarrollo de aplicaciones
interactivas y funcionales en el Web.

Actualmente, Java es empleado en diferentes aplicaciones y áreas como bases de datos,

servidores de aplicaciones, comunicaciones y procesamiento de imágenes entre otras. Así
mismo, en el mercado se encuentran múltiples herramientas de desarrollo para Java, como
NetBeans, JDeveloper, y Eclipse.

1.2 Java y su JDK

Java es un lenguaje de programación orientado a objetos de propósito general, con sintaxis

similar a C++. Para el desarrollo de programas Java, Sun Microsystems provee el Java
Development Kit (JDK), que es un conjunto de herramientas y APIs de libre distribución.

Este API ha pasado por múltiples versiones y realease que han extendido la funcionalidad y
aumentado la robustez y eficiencia del lenguaje. Las principales versiones del JDK son:

PROGRAMACION BASICA EN JAVA - 1

 ASESOFTWARE S.A.S

 JDK 1.02 (1995)

 JDK 1.1 (1997)
 JDK 1.2 o Java versión 2 (1998)
 JDK 1.3 (2000)
 JDK 1.4 (2002)
 JDK 1.5 (2004)
 JDK 1.6 (2006) o Java SE 6
 JDK 1.7 (2011) o Java SE 7

El siguiente diagrama ilustra los componentes (herramientas APIs) del JDK de Java:

Aplicaciones Java APPLETS

Java Development Kit JDK

Compilador Java Depurador Java

applet awt beans io lang

Máquina Virtual math net rmi security sql

de Java
text util accessibility swing corba

Win 32 Unix Mac Otros

Las principales herramientas que conforman el JDK son:

javac Compilador de programas Java, generando bytecode.

java Interpretador que permite ejecutar programas Java

Jre Java Runtime Interpreter.

jdb Depurador de programas Java

javadoc Generador de documentación en formato HTML de programas Java

PROGRAMACION BASICA EN JAVA - 2

 ASESOFTWARE S.A.S

appletviewer Visor de applets Java

javah Genera cabeceras de archivos C y su respectivo stub, para habilitar la

interacción de programas Java con otros lenguajes de programación

javap Permite examinar una clase Java para determinar sus interfaz
(métodos y atributos)

Los APIs que componen el JDK son:

applet Conjunto de clases para el desarrollo de aplicaciones

gráficas que corren embebidas en páginas HTML.

awt Abstract Windowing Toolkit. Contiene los componentes

Gráficos básicos.

io Clases que dan soporte a la lectura y escritura de datos.

lang Conforma el núcleo del modelo de clases en Java.

net Clases que implementan interfaces de comunicación, para

manipular protocolos y mecanismos de intercomunicación
como sockets y URLs http.

util Miscelánea de clases para la implementación de

estructuras de datos (como vectores y tablas de hash) y la
manipulación de fechas.

sql Clases de administración de drivers JDBC para el acceso a

bases de datos relacionales.

security Implementa las funcionalidades de criptografia, firmas

digitales y autenticación, requeridas en la construcción de
aplicaciones robustas y seguras en el Web

beans Núcleo del estándar para la construcción de software

basado en componentes.

rmi Remote Method Invocation. Interfaz para la invocación de

métodos en ambientes distribuidos.

PROGRAMACION BASICA EN JAVA - 3

 ASESOFTWARE S.A.S

1.3 Arquitectura

El proceso de compilación y ejecución de aplicaciones Java está diseñado para garantizar la

portabilidad del código fuente y del código compilado, siendo esta la principal
característica de Java.
Para lograr esta portabilidad, la arquitectura Java está basada en la Máquina Virtual Java y
el bytecode.

Código Fuente

.java

compilación

bytecode
110110100111000
1011101101100011
000110100111000
.class 1011101111100011
001011101101000
1011101101110001
001011100111000
10111011010000011
0010110100111000
1011010011100011
API
001010100111000
011010011100011

Runtime
Máquina Virtual
Sistema operativo

Hardware

1.3.1 Máquina Virtual Java

El código nativo (generado por compiladores como C), consiste de instrucciones

concretas para un micropocesador especifico que pueden ser ejecutadas directamente
sobre la máquina. Este código es dependiente de la máquina y del sistema operativo
para el cual fue compilado.

PROGRAMACION BASICA EN JAVA - 4

 ASESOFTWARE S.A.S

Los creadores de Java diseñaron una "máquina virtual", para garantizar la portabilidad
y la transparencia entre sistemas operacionales y procesadores, con su propio ejecutor
de instrucciones. Esta máquina virtual simula una CPU que toma como entrada el
bytecode e interpreta una a una las instrucciones, reflejando los cambios de estado del
programa que se está "ejecutando".

1.3.2 Bytecode

El compilador Java transforma el código fuente en código intermedio denominado

bytecode que es una secuencia de bytes que representa instrucciones para la Máquina
Virtual Java. El bytecode se almacena en archivos con extensión .class.

A pesar que Java es un lenguaje interpretado, la combinación de bytecode y la máquina

virtual garantiza tiempos de respuesta aceptables.

1.4 Por qué Utilizar Java

Las características o propiedades que explican la extraordinaria acogida del lenguaje de

programación Java son; simplicidad, paradigma orientado a objetos, confiabilidad,
seguridad, procesos livianos, portabilidad, internet, código móvil.

Simplicidad Ya que Java adopto la sintaxis de C++, los desarrolladores con

experiencia en este lenguaje estarán en capacidad de desarrollar
aplicaciones Java a través de un aprendizaje rápido y fácil.
Gracias a que la JVM provee un manejo automático de la memoria, en
Java no se emplean apuntadores. Adicionalmente, las cadenas y los
arreglos son objetos con propiedades y atributos.

Orientado a El paradigma Orientado a Objetos facilita el análisis, diseño,

objetos construcción y mantenimiento de aplicaciones complejas, gracias a los
mecanismos de encapsulamiento, herencia, polimorfismo y la
reutilización de código.

PROGRAMACION BASICA EN JAVA - 5

 ASESOFTWARE S.A.S

Confiabilidad Para el desarrollo de aplicaciones robustas, los desarrolladores deben

invertir esfuerzos y tiempo manejando la memoria y controlando los
eventos excepcionales o errores.
En Java, la memoria es manejada de forma automática por el recolector
de basura, que inspecciona y libera los espacios de memoria que han
dejado de ser usados.
En cuento a los eventos excepcionales, el compilador de Java hace una
revisión estricta del código, generando errores de compilación en caso de
encontrar instrucciones que tienen la potencialidad de generar
excepciones y que no son tenidas en cuenta por el programador.
El compilador de Java realiza validaciones adicionales como la
inicialización de variables antes de ser empleadas y la conversión
correcta entre tipos de datos.

Seguridad El runtime de Java realiza validaciones sobre el bytecode para evitar la

ejecución de programas malignos que intenten acceder a recursos críticos
o que intenten inestabilizar el sistema.
Adicionalmente, el runtime de Java segrega el software de acuerdo a su
origen. Si el bytecode reside en la máquina local, la ejecución del
programa tendrá privilegios sobre los diferentes recursos del sistema. En
caso que el bytecode provenga de una máquina remota, el programa no
tendrá acceso a recursos como el almacenamiento secundario y la red.

Procesos Los procesos livianos permiten la ejecución de múltiples flujos de control

livianos (hilos) concurrentemente. Las clases que implementan esta funcionalidad
hacen parte del núcleo del lenguaje Java, facilitando su programación y
entendimiento.

PROGRAMACION BASICA EN JAVA - 6

 ASESOFTWARE S.A.S

Portabilidad Una aplicación escrita y compilada con Java puede ser ejecutada
(interpretada) en diferentes plataformas, gracias a la utilización de la
máquina virtual de Java.
Interpretadores
(Máq Virtual)

Solaris
Código Fuente
Java bytecode
Compilador (portable)
00101110110100111000
Java 10111011010011100011
00101110110100111000 MSWindows
10111011010011100011
00101110110100111000
10111011010011100011
00101110110100111000
10111011010011100011
00101110110100111000
10111011010011100011
00101110110100111000
10111011010011100011
00101110110100111000

MAC
.java .class

Internet El API de Java provee clases que agilizan la construcción de aplicaciones

que requieran establecer conexiones TCP/IP a través de sockets y
protocolos como http.

Código móvil Los Applets de Java son denominados código móvil ya que son
transportados, instalados y ejecutados de forma automática.

1 http://www.serv
/aplic.html N
2 Enviar el
bytecote
3 Cargar el
bytecote
4 Interpretar el
bytecode
(ejecutar)

PROGRAMACION BASICA EN JAVA - 7

 ASESOFTWARE S.A.S

PROGRAMACION BASICA EN JAVA - 8

 ASESOFTWARE S.A.S

2 Fundamentos de Programación Orientada a Objetos

2.1 Complejidad del Software

El desarrollo de software involucra gran cantidad de aspectos técnicos y administrativos,

que hacen del proceso de desarrollo una tarea inherentemente compleja. Entre los aspectos
que derivan la complejidad del desarrollo de software, tenemos; manejo de requerimientos,
tamaño de las aplicaciones, nuevas tendencias tecnológicas, y el mantenimiento de las
aplicaciones.

1. Manejo de requerimientos: En el proceso de análisis de requerimientos, los

desarrolladores se enfrentan a usuarios con necesidades ambiguas y en algunos casos
contradictorias. Adicionalmente, el desconocimiento del negocio por parte de los
desarrolladores, dificulta la comunicación con los usuarios y la documentación de estos
requerimientos.
Estos requerimientos pueden variar durante la ejecución del desarrollo debido a
exigencias del negocio o a que los usuarios y desarrolladores logran una mayor
comprensión del sistema y encuentran la necesidad de replantear la funcionalidad de la
aplicación.
Por último, existen requerimientos no funcionales, como desempeño, costo, seguridad y
robustez.

2. Tamaño de las aplicaciones: Las exigencias de los usuarios y tecnológicas, hacen las
aplicaciones cada vez más voluminosas, conformadas por decenas o cientos de módulos
que deben ser construidos por diferentes desarrolladores.

3. Nuevas tendencias tecnológicas: Estas tendencias, enfrentan a los desarrolladores con

un requerimiento adicional; los diferentes componentes de software construidos deben
ser lo suficientemente flexibles para adaptarse a diferentes plataformas y arquitecturas
computacionales.

PROGRAMACION BASICA EN JAVA - 9

 ASESOFTWARE S.A.S

4. Mantenimiento de las aplicaciones: El mantenimiento surge por la necesidad de

corregir errores y/o para adaptar el sistema a nuevos requerimientos, y constituye la fase
más costosa del ciclo de vida del software. Es muy frecuente que esta fase deba ser
ejecutada por desarrolladores diferentes a los constructores iniciales de la aplicación.

2.2 Paradigma Orientado a Objetos

El enfoque OO permite la descomposición de sistemas complejos en componentes (que a su

vez se pueden descomponer) derivados de entidades relevantes encontradas en el dominio
del sistema. La principal ventaja de este tipo de descomposición es que cada componente se
puede verse como un pequeño sistema que es construido y mantenido de manera
independiente de los demás módulos.
A diferencia de las aplicaciones diseñadas bajo el esquema de descomposición funcional,
las aplicaciones OO son más adaptables y fáciles de mantener, ya que su diseño inicial no
está atado a requerimientos funcionales encontrados en un instante dado, sino que está
basado en las entidades y objetos del mundo real, los cuales tienden a perdurar así su
funcionalidad varíe.

2.2.1 Características y ventajas del paradigma OO

1. El modelo OO aplica para todo el ciclo de vida del software; análisis, desarrollo,
construcción y mantenimiento. Los conceptos y términos empleados en cada una de
estas fases se conservan, extiendiendose o refinando en cada fase.

2. El proceso de Análisis y Diseño OO, facilita el entendimiento de requerimientos y

la comunicación usuarios-desarrolladores, ya que lo que se busca en este proceso es
capturar (abstraer) la realidad a través del mapeo de entidades reales (con sus
atributos y operaciones) a entidades u objetos del modelo.

3. La interoperación entre componentes (objetos) se hace a través de interfaces bien

definidas que son independientes de la implementación, facilitando la coordinación
de las labores de desarrollo, y el mantenimiento.

2.2.2 Conceptos tomados de la ingeniería de software

Aunque los conceptos de abstracción de datos, ocultamiento de información y

encapsulamiento son aplicados a cualquier desarrollo de software, en el paradigma OO
tienen gran importancia y de hecho son la base del proceso de análisis y diseño OO.

PROGRAMACION BASICA EN JAVA - 10

 ASESOFTWARE S.A.S

2.2.2.1 Abstracción de datos

Esta técnica busca abordar la complejidad del dominio del problema, haciendo una
abstracción de las entidades mediante la creación de tipos de datos abstractos cuya
definición se compone de datos y funciones.

2.2.2.2 Ocultamiento de información

El diseño de componentes OO, busca ocultarle a los clientes de un determinado

componente la complejidad de los detalles de su implementación.

2.2.2.3 Encapsulamiento

Define el alcance de un componente, delimitando y controlando el acceso de los

clientes que desean utilizar los servicios del componente, Asociado al
encapsulamiento está el concepto de interfaz del objeto, la cual determina los
métodos y datos que pueden ser vistos y/o utilizados por otros objetos.

2.3 Conceptos Básicos OO

2.3.1 Objeto

La definición más importante en el paradigma OO es el objeto. Un objeto es una

entidad lógica que representa una entidad del mundo real. Las entidades del mundo real
se describen por medio de atributos y su conducta, que al nivel de objetos se
denominan atributos y métodos (o operaciones).

objeto

Atributos Estado (Información)

Métodos Comportamiento (conducta)

PROGRAMACION BASICA EN JAVA - 11

 ASESOFTWARE S.A.S

Un objeto es un dato abstracto encapsulado, cuyos atributos pueden ser otros objetos
con complejidad arbitraria. Esto nos permite crear correspondencias uno a uno entre los
objetos y las entidades del mundo real que estamos modelando. Una entidad simple del
mundo real se representa como un objeto simple (sin necesidad de descomponerla en
relaciones independientes).

Un objeto puede estar embebido en otros objetos, ser utilizado como parámetro y/o ser
utilizado como valor de retorno de alguna función (método).

2.3.2 Clase

Los objetos que comparten la misma funcionalidad y características pueden ser

agrupados en clases. De esta forma, una clase es la especificación genérica de un
conjunto de objetos similares. Los objetos que se crean a partir de la definición de una
clase se denominan instancias de esa clase.

2.3.3 Relaciones

Las relaciones representan los mecanismos de interacción entre objetos. Estas

relaciones pueden ser de los siguientes tipos:

Dependencia Indica que un elemento emplea (consulta y/o

modifica) otro elemento.

Asociación Especifican relaciones estructurales entre elementos.

Generalización Relaciona clases genéricas con clases especificas.

2.3.4 Métodos y mensajes

Los objetos no son entes aislados, sino por el contrario interactuan con otros objetos
para lograr el objetivo final de la aplicación. Esta interacción sigue el esquema
cliente/servidor, donde el objeto con el rol cliente solicita la ejecución de un servicio al
objeto con rol servidor.

1: retirar(monto)

c: CajetoAutomatico cta: CuentaAhorro

PROGRAMACION BASICA EN JAVA - 12

 ASESOFTWARE S.A.S

Cada objeto puede asumir el rol de cliente o servidor. Esta invocación de servicios se
denomina paso de mensajes entre objetos, y los servicios que presta un objeto están
representados por los métodos del objeto.
El conjunto de métodos o servicios que presta un objeto determina su conducta (como
responde o reacciona a las solicitudes externas).

2.3.5 Herencia

El mecanismo de herencia es una implementación de código compartido, que permite

la definición de nuevas clases de objetos (clases derivadas) a partir de clases existentes
(clases bases). Las clases derivadas heredan la información (atributos) y la conducta
(métodos) de la clase base.

Algunos lenguajes de programación soportan la herencia múltiple que consiste en la

definición de clases derivadas a partir de dos o más clases bases.

La herencia es empleada para especialización o generalización de clases.

2.3.5.1 Especialización

Punto

x: float
y: float

mover(px, py)
estaEn(Rectangulo)
distancia(Punto)

Pixel

color:TColor

pintarse()

La especialización, crea clases derivadas que extienden la clase base por medio de la
adición de métodos y atributos, haciéndolas más potentes y especializadas. Esto
permite la reutilización de código, disminuyendo los tiempos de desarrollo y la
probabilidad de errores, ya que un solo segmento de código es empleado múltiples
veces (una por cada clase derivada).

PROGRAMACION BASICA EN JAVA - 13

 ASESOFTWARE S.A.S

2.3.5.2 Generalización

En este tipo de herencia, las clases derivadas redefinen o sustituyen los métodos de
la clase derivada. Esto permite organizar las clases en jerarquías de tipos y subtipos,
que satisfacen la condición de que las instancias de una clase derivada (subclases)
son a su vez instancias de la clase base (superclase).

FiguraGeometrica

Rectangulo Circulo Triangulo

Los conceptos de especialización y generalización no son excluyentes entre si. Es

decir que es posible tener clases derivadas que son una especialización y una
generalización de su clase base. De hecho es el caso más frecuente en la
implementación de clases.

2.3.6 Polimorfismo

El polimorfismo (POLY: muchos, MORPHOS: formas) está relacionado con el

concepto de herencia por generalización y es quizás el mecanismo más importante en la
programación orientada a objetos.

El polimorfismo permite enviar un mensaje de propósito general a diferentes objetos,

los cuales pueden llegar a responder de forma diferente. El objeto cliente que envía el
mensaje no tiene que saber el tipo de dato especifico del objeto servidor.

Cuando se utiliza porlimorfismo, no se puede determinar en tiempo de compilación el

tipo de dato del objeto que debe responder al mensaje enviado. Por tal razón, se utiliza
el mecanismo de encadenamiento tardío (dynamic binding) para determinar el tipo de
dato del objeto en tiempo de ejecución y así poder seleccionar la implementación que
debe responder al mensaje enviado.

PROGRAMACION BASICA EN JAVA - 14

 ASESOFTWARE S.A.S

metodoEjemplo(FiguraGeometrica fg)
{
float area;
area = fg.calcularArea();
}

2.3.7 Sobrecarga

La sobrecarga permite que dos o más funciones puedan compartir su nombre siempre y
cuando las declaraciones de los parámetros sean diferentes. Esto busca hacer las
interfaces entre objetos más sencillas y fáciles de usar.
Adicionalmente a las funciones o métodos, es posible sobrecargar los operadores del
lenguaje de programación.

2.3.8 Persistencia

Persistencia es la propiedad de los objetos a sobrevivir más allá del tiempo de

ejecución. Esto significa que los objetos pueden ser almacenados en una base de datos
con el fin de recuperar su estado posteriormente.

PROGRAMACION BASICA EN JAVA - 15

 ASESOFTWARE S.A.S

PROGRAMACION BASICA EN JAVA - 16

 ASESOFTWARE S.A.S

3 Programación Básica en Java

3.1 Introducción

Este capitulo introduce las sentencias básicas de Java excluyendo las sentencias para
construir y manipular objetos. Ya que la sintaxis base de Java es muy similar a la sintaxis
del lenguaje C, los desarrolladores experimentados en C o C++ asimilarán este capitulo de
forma inmediata.

3.2 Sintaxis

La sentencias (operaciones simples) en Java se delimitan por el símbolo punto y coma (;) y
pueden llegar a extenderse en múltiples líneas de código. A continuación se presentan
ejemplos de sentencias en Java:

int estudiantes = 23;

System.out.println("Bienvenidos a la programacion en Java");
facturacion = estudiantes * COSTO_BASE;
estudiantes = estudiantes + 2;

Los bloques son sentencias conformadas por una o más sentencias simples delimitadas por
llaves ({ }).
Java es case-sensitive, es decir que las letras mayúsculas difieren de las minúsculas.

3.3 Bienvenida a la Programación en Java

Los conceptos del presente capitulo se introducen a partir del programa Bienvenida a la
programación en Java.

PROGRAMACION BASICA EN JAVA - 17

 ASESOFTWARE S.A.S

class Bienvenida
{
public static void main(String args[])
{
String mensaje = ", Bienvenido a la programacion en Java.";
System.out.println(args[0] + mensaje);
}
}

Para compilar este programa el código fuente se debe almacenar en un archivo tipo texto
con nombre Bienvenida y extensión java (teniendo en cuenta la distinción entre mayúsculas
y minúsculas). El proceso de compilación genera el bytecode de la clase Bienvenida en un
archivo denominado Bienvenida con extensión class. Para este proceso se emplea el
compilador de Java:

c:\> javac Bienvenida.java

En caso que la compilación haya sido satisfactoria, en el directorio actual se debe encontrar
el archivo Bienvenida.class.
Para ejecutar (interpretar) el programa se debe emplear el runtime de Java:

c:\> java Bienvenida Sebastian

Sebastian, Bienvenido a la programacion en Java.

3.3.1 Análisis del programa Bienvenida

Este programa está representado por la clase Bienvenida que contiene un único método
denominado main. El método main recibe como parámetros un arreglo de objetos tipo
String.

Las palabras claves del programa son:

class Encabezado de la definición de una nueva clase. En nuestro caso la clase

se denomina Bienvenida. Observe la correspondencia del nombre de la
clase con los nombres los archivos fuentes y bytecode.

public Especifica que el método main es visible para "todo el mundo"

PROGRAMACION BASICA EN JAVA - 18

 ASESOFTWARE S.A.S

static Indica que no es necesario crear instancias de la clase Bienvenida para

invocar el método main.

void El método main no tiene valor de retorno.

La primera sentencia del método main declara la variable mensaje de tipo String y la
inicializa con el literal ", Bienvenido a la programacion en Java.".

String mensaje = ", Bienvenido a la programacion en Java.";

La segunda sentencia es la invocación al método println del objeto out. out es un

atributo público de la clase System.

System.out.println(args[0] + mensaje);
| | |
| | |__ método invocado
| |______ atributo de tipo PrintStream
|_____________ nombre de clase

el método println recibe como parámetro el resultado de la evaluación de la expresión

args[0] + mensaje

que consiste en la concatenación de dos cadenas de caracteres.

3.4 Variables y Tipos de Datos

3.4.1 Variables

Las variables son localizaciones de memoria para el almacenamiento de valores. Java

tiene variables de instancia, variables de clase y variables locales. En este capitulo nos
concentraremos en las variables locales. Una variable se define por su
identificador(etiqueta empleada para referenciarla), su tipo de dato y su alcance.

Los identificadores de variables pueden incluir letras(a-z, A-Z), numeros (0-9) y los
símbolos subrayado(_) y pesos ($), donde el primer carácter no puede ser un número.

Los tipos de datos se pueden clasificar en:

 Tipos de datos básicos

PROGRAMACION BASICA EN JAVA - 19

 ASESOFTWARE S.A.S

 Clases e interfaces
 Arreglos

3.4.2 Tipos de datos básicos

Buscando mayor eficiencia, en Java los tipos de datos básicos no son orientados a
objetos(no poseen atributos ni métodos), sino por el contrario representan valores
atómicos como enteros, reales y caracteres. Estos tipos de datos son independientes de
la plataforma, por lo cual su tamaño y comportamiento son idénticos para todas las
implementaciones de JVM.

Los tipos básicos son; byte, short, int, long, float, double, char y boolean. No existe
posibilidad de crear, modificar o definir nuevos tipos de datos básicos. Cualquier otra
construcción como clases, interfaces o arreglos (predefinida o definida por el
programador) está basada en tipos básicos.

A continuación se especifican las propiedades de los tipos de datos numéricos:

Enteros
Tipo Tamaño Rango
byte 8 bits -128 a 127
short 16 bits -32,768 a 32,767
int 32 bits -2,147,483,648 a 2,147,483,647
long 64 bits -9223372036854775808 a 9223372036854775807
Reales
Tipo Tamaño Rango
float 32 bits 3.4e-038..3.4e+038
double 64 bits 1.7e-308..1.7e+308

El tipo de dato char es empleado para almacenar caracteres y tienen un tamaño de 16

bits siguiendo el estándar Unicode. Los literales de caracteres deben ir entre comillas
sencillas (ejemplo 'a'). Al igual que C, en Java existen los siguientes caracteres
especiales:

\n Nueva línea
\t Tabulador
\b Backspace
\r carriege return
\f formfeed
\\ backslash
\' Comilla sencilla
\" Comilla doble

PROGRAMACION BASICA EN JAVA - 20

 ASESOFTWARE S.A.S

Por último, el tipo booleano se emplea para representar valores lógicos (verdadero y
falso), y los posibles valores que puede tomar son true y false.

Para la declaración de variables se hace a través de una sentencia que especifica el tipo
de dato, el identificador y de forma opcional el valor inicial:

tipo_dato nombre_identificador = valor_inicial;

El siguiente segmento de código presenta ejemplos de declaraciones de variables:

int x;
int a, b, c;
float f_ejemplo = 3.14;
char c;
char letra = 'b';
boolean confirmado = true;

3.5 Operadores

Los operadores son símbolos especiales empleados en expresiones que se evalúan para
retornar un valor. Estos se pueden clasificar en aritméticos, de asignación, increméntales y
decrementales, relacionales, lógicos y bitwise.

3.5.1 Operadores aritméticos

Los operadores aritméticos son operadores binarios que retornan el resultado de

aplicaciones algebraicas. Los operandos pueden ser variables o valores literales que
representen datos enteros y/o reales.

Operación Operador Expresión Expresión en

aritmético algebraica Java
Suma + a + 25 a + 25
Substracción - r-3 r - 3
Multiplicación * a.b a*b
División / a÷b a/b
Módulo % a mod b a%b

El tipo de dato retornado por el operador división depende de sus operandos; en caso
que sus operandos sean enteros el valor retornado será un entero, y en caso que alguno
de los operandos sea real el valor retornado será un real.

En la construcción de expresiones complejas, se pueden emplear paréntesis para forzar

el orden de ejecución de las operaciones.

PROGRAMACION BASICA EN JAVA - 21

 ASESOFTWARE S.A.S

3.5.2 Operador de asignación

Al igual que C, Java dispone de operadores de asignación para abreviar sentencias de

asignación.

Las sentencias de la forma:

var = var op expresion;

pueden ser abreviadas por :

var op= expresion;

donde op es uno de los operadores aritméticos +, -, *, / o %.

3.5.3 Operadores incrementales y decrementales

El operador incremento (++) y el decremento (--) son operadores unarios. Estos son
empleados para incrementar o decrementar una variable en una unidad. De esta forma,
las siguientes expresiones son equivalentes.

a = a + 1;
a += 1;
a++;
++a;

El siguiente cuadro resume la utilización de estos operadores:

Operador Utilización Explicación

++ ++k Antes de utilizar el valor de la variable k en la
expresión, k se incrementa en una unidad.
k++ Primero se utiliza el valor de la variable k, y
posteriormente se incrementa en 1.
-- --k Antes de utilizar el valor de la variable k en la
expresión, k se decrementa en una unidad.
k-- Primero se utiliza el valor de la variable k, y
posteriormente se decrementa en 1.

A continuación se ilustra la utilización de los operadores aritméticos, incremento y

decremento a través de una aplicación Java:

PROGRAMACION BASICA EN JAVA - 22

 ASESOFTWARE S.A.S

class AritmeticaEjem {
public static void main (String args[]) {
int a;
int b = 10;
int c = 1;
b ++ ; // Incrementar el valor de b en uno
a = b - c;
b *= c; // Equivalente a : b = b*c;
c = ++a;
System.out.println(“El valor de a es = “ + a);
System.out.println(“El valor de b es = “ + b);
System.out.println(“El valor de c es = “ + c);
}
}

3.5.4 Operadores relacionales

Los operadores relacionales evalúan al valor lógico de la expresión, retornando un

valor booleano.

Operación Ejemplo
== Igualdad vBool = (b == c);
!= Diferencia vBool = (b != c);
> Mayor que vBool = (b > c);
< Menor que vBool = (b < c);
>= Mayor o igual que vBool = (b >= c);
<= Menor o igual que vBool = (b <= c);

donde vBool es una variable de tipo boolean.

3.5.5 Operadores Lógicos

Los operadores lógicos son empleados para combinar expresiones condicionales

simples. Los operadores lógicos son el y (and), el o (or) y la negación (not).

El siguiente cuadro resume los operadores lógicos en Java:

Operador lógico Ejemplo

& And vBool = b & c;
| Or vBool = b ¦ c;
^ Xor vBool = b ^ true;

&& short-circuit or vBool = b && c;

|| short-circuit and vBool = b ¦¦ false;

! not vBool = !b;

PROGRAMACION BASICA EN JAVA - 23

 ASESOFTWARE S.A.S

donde vBool, b y c son variables de tipo boolean.

Los operadores && y ¦¦ producen el mismo resultado lógico que los operadores & y ¦
respectivamente. La diferencia entre los operadores lógicos short-circuit y los
operadores lógicos tradicionales radica en la evaluación de las expresiones utilizadas
como operandos:

(expresion1 && expresion2)

En este caso, la expresion2 se evaluará sólo si la expresion1 retorne verdadero (true).

Observe que si la expresion1 es falsa (false) no es necesario evaluar la expresión de la
derecha para saber que la operación AND (&&) retorna falso (false). Mientras que

(expresion1 & expresion2)

siempre evaluará los dos operandos del AND (&).

3.6 Arreglos

Un arreglo es un objeto que contiene un conjunto de valores (objetos o tipos básicos) del
mismo tipo. Los arreglos son considerados como objetos en el lenguaje Java.

Para emplear arreglos se deben seguir los siguientes pasos:

1. Declarar una variable tipo arreglo.

int[] arregloEjemplo;
int otroEjemplo[];
String[] palabras;

En la declaración se especifica el tipo de dato de los elementos del arreglo, el

nombre de la variable con paréntesis cuadrados para indicar que se trata de una
variable tipo arreglo. Como se observa en los ejemplos, es posible colocar los
paréntesis cuadrados al lado del tipo de dato.

2. Crear un objeto de tipo arreglo y asignarlo a una variable.

arregloEjemplo = new int[20];

La creación de objetos en Java se hace a través del operador new. En el caso de

arreglos, es necesario especificar el número de elementos que conforma el
arreglo.

PROGRAMACION BASICA EN JAVA - 24

 ASESOFTWARE S.A.S

Al utilizar el operador new, todos los elementos del nuevo arreglo son
inicializados de forma automática, con cero (0) para valores numéricos, false
para booleanos, fin de cadena ('\0') para caracteres y null para objetos.

3. Acceder a los items del arreglo.

arregloEjemplo[0] = 25;
x = arregloEjemplo[1] + arregloEjemplo[8];

Los índices de los elementos del arreglo inician con el valor cero (al igual que
C). Para acceder al valor de un elemento del arreglo, se debe emplear el nombre
del arreglo y el índice del respectivo elemento entre paréntesis cuadrados.

3.6.1 Atributo length

Los arreglos poseen el atributo length que almacena la longitud del arreglo.

3.6.2 Arreglos multidimensionales

A pesar que Java no soporta directamente el concepto de arreglos multidimensionales,

es posible definirlos a través de arreglos cuyos elementos son a su vez arreglos.

int[][] m;
m = new int[10][15];
m[0][3] = 8;

Es mas, cada posición del arreglo de arreglos es independiente, y es posible que cada
subarreglo tenga longitud diferente.

Int a [][];
a = new int[3][];
a[1] = new int[1];
a[2] = new int[2];
a[3] = new int[10];

3.7 Estructuras de Control

Las instrucciones de flujo de control en Java son muy similares a las empleadas en C y
C++.

PROGRAMACION BASICA EN JAVA - 25

 ASESOFTWARE S.A.S

3.7.1 If-else

La proposición if-else expresa una toma de decisión.

if (expresion_booleana) bloque1 [else bloque2]

expresion_booleana Cualquier expresión booleana. Puede ser una variable o

literal de tipo boolean, o una expresión que involucre
operadores relacionales y/o lógicos.

bloque1 Conjunto de instrucciones que se ejecutarán en caso que

expresion_booleana evalue a true

bloque2 Conjunto de instrucciones que se ejecutarán en caso que

expresion_booleana evalue a false.

Ejemplo

int maximo;
if (a < b) {
maximo = b;
}
else {
maximo = a;
}

3.7.2 If-else if ... else

Esta construcción es empleada para expresar una decisión múltiple. Las expresiones
booleanas son evaluadas en orden y la primera que evalue a true hará que su bloque de
instrucciones asociado se ejecute. Solo un bloque de instrucciones es ejecutado.

if (expresion_booleana1)
bloque1
else if (expresion_booleana2)
bloque2
else if (expresion_booleana3)
bloque3
.....
[else bloqueOmision]

PROGRAMACION BASICA EN JAVA - 26

 ASESOFTWARE S.A.S

expresion_booleanaX Cualquier expresión booleana. Puede ser una variable o

literal de tipo boolean, o una expresión que involucre
operadores relacionales y/o lógicos.

bloqueX Conjunto de instrucciones que se ejecutarán en caso que

expresion_booleanaX sea la primera que evalue a true

bloqueOmision Conjunto de instrucciones que se ejecutarán en caso que

todas las expresiones booleanas evalúen a false.

Ejemplo

String nota = “Malo“;

if (promedio < 4.0){
nota = “Malo“;
}
else if(promedio < 7.0){
nota = “Regular“;
}
else if(promedio < 9.0){
nota = “Bueno“;
}
else {
nota = “Excelente“;
}

3.7.3 Switch

La estructura switch (estructura caso) implementa una decisión múltiple. Esta

estructura es más simple y fácil de comprender que la estructura if-else if...else.

switch(expresion) {
case valor1:
bloque1
break;
case valor2:
bloque2
break;
.....
default:
bloqueOmision
}

PROGRAMACION BASICA EN JAVA - 27

 ASESOFTWARE S.A.S

expresion Expresión que evalue a un valor de tipo básico.

valorX Valores que deben ser compatibles con el tipo de dato de

expresion.

bloqueX Conjunto de instrucciones que se ejecutarán en caso

valorX sea igual a expresion.

bloqueOmision Conjunto de instrucciones que se ejecutarán en caso

ninguno de los valores sea igual a expresion.

Ejemplo

char a;
String sOpt;
System.out.println("Digite un valor numérico entre 1 y 3: ");
a = (char) System.in.read();
switch(a) {
case '1' :
sOpt = "Opcion uno";
break;
case '2' :
sOpt = "Opcion dos";
break;
case '3' :
sOpt = "Opcion tres";
break;
default:
sOpt = "Opcion invalida";
}
System.out.println("Usted oprimio la " + sOpt);

3.7.4 Break

Permite terminar la ejecución de un bloque de control. En este caso los bloques deben
poseer un nombre (label) que los identifique.

break label;

Ejemplo

PROGRAMACION BASICA EN JAVA - 28

 ASESOFTWARE S.A.S

lb1: {
lb2: {
if (a > 5) {
break lb2
}
else {
break lb1
}
}
System.out.println("Despues del bloque lb2");
}
System.out.println("Despues del bloque lb1");

3.7.5 While

Ejecuta un conjunto de instrucciones, mientras la condición dada sea verdadera.

while (condicion) {
bloque
}

condicion Expresión booleana. El ciclo se mantendrá iterando

mientras condicion sea true.

bloque Conjunto de instrucciones que se ejecutan en cada

iteración del ciclo.

Ejemplo
int i = 0;
while (i < 10) {
System.out.println("Iteración número: " + i);
i++;
}

3.7.6 Do-while

Similar al while, excepto que se garantiza que el bloque de instrucciones se ejecuta por
lo menos una vez, asi la condición sea falsa.

do {
bloque
} while (condicion);

PROGRAMACION BASICA EN JAVA - 29

 ASESOFTWARE S.A.S

condicion Expresión booleana. El ciclo se mantendrá iterando

mientras condicion sea true.

bloque Conjunto de instrucciones que se ejecutan en cada

iteración del ciclo.

Ejemplo

int suma = 0;
int i = 1;
do {
suma += i;
i++;
} while (i < 10);

3.7.7 For

La estructura for por lo general es empleada para iteraciones simples en las cuales un
bloque de instrucciones se debe ejecutar un número determinada de veces y
posteriormente parar.

for (inicializacion ; condicion ; incremento) {

bloque
}

inicialización Sentencias para dar valores iniciales a las variables

empleadas en el ciclo.
condicion Expresión booleana. El ciclo se mantendrá iterando
mientras condicion sea true.

incremento Es una sentencia que es invocada en cada iteración. Por

lo general es un incremento (o decremento) de la variable
empleada como índice del ciclo.
bloque Conjunto de instrucciones que se ejecutan en cada
iteración del ciclo.

Ejemplo
for (int i=0 ; i < 10 ; i++) {
System.out.println("Iteración número: " + i);
}

PROGRAMACION BASICA EN JAVA - 30

 ASESOFTWARE S.A.S

3.7.8 Continue

Esta sentencia es utilizada en el interior de un ciclo (bloque del ciclo) para omitir la
ejecución de las sentencias restantes de la actual iteración, pero sin salir del ciclo.

Ejemplo (Imprimir los números impares)

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

if ( i % 2 == 0) {
continue;
}
System.out.println(“Iteración número: “ + i);
}

PROGRAMACION BASICA EN JAVA - 31

 ASESOFTWARE S.A.S

PROGRAMACION BASICA EN JAVA - 32

 ASESOFTWARE S.A.S

4 Clases en JAVA

El proceso de análisis orientado a objetos tiene como principal objetivo identificar las cosas
o entidades del mundo real que son relevantes para la aplicación que se desea construir.

Por ejemplo, para modelar la planta física de un campus universitario, los edificios, aulas,
laboratorios, oficinas y áreas libres son entidades relevantes para el sistema. Cada uno de
estas entidades tienen propiedades y un comportamiento especifico. Un aula tiene
capacidad, dimensiones y localización. En cuanto al comportamiento, una aula puede llegar
a rechazar su reserva en caso de estar previamente reservada.

En POO cada una de estas entidades se modela como clases. Una clase es una abstracción
de datos que representa las entidades del mundo real.

Las clases son la construcción base de los lenguajes orientados a objetos. Los objetos que
comparten la misma funcionalidad y propiedades son agrupados en clases. De esta forma,
en una clase se especifican las propiedades y comportamiento) de un conjunto de objetos
similares. Los objetos que se crean a partir de la definición de una clase se denominan
instancias de esa clase.

Aula

capacidad
dimensiones
localizacion
reservar()

Ejemplo de la clase Aula

PROGRAMACION BASICA EN JAVA - 33

 ASESOFTWARE S.A.S

4.1 Encapsulamiento y Visibilidad

Con el encapsulamiento de clases se busca ocultar las partes internas de la implementación

de la clase, y permitir el acceso y uso a las instancias de la clase solo a través de una
interfaz bien definida.
Lenguajes como Java poseen una construcción denominada paquete, que brinda un nivel
adicional de encapsulamiento. Un paquete encapsula una o más clases relacionadas entre
si, definiendo cuales de estas pueden ser empleadas desde el exterior del paquete y cuales
no.

awt

image Button

Checkbox

Choice

Label

El encapsulamiento se implementa por medio de la visibilidad que es un modificador de

acceso de cada uno de los elementos (atributos y métodos) de la clase. Este modificador
puede ser private, public , protected y friendly.

private Los métodos y atributos con acceso private solo son visibles
por los métodos de la misma clase. Esta es la visibilidad más
restrictiva.

public La visibilidad menos restrictiva es la public que permite que

los métodos y atributos sean accedidos por métodos de
cualquier otra clase, sin importar el paquete al que
pertenezcan.

friendly Los métodos y atributos friendly, son accesibles por cualquier

otra clase que pertenezca al mismo paquete.
Este es el modificador de acceso por omisión, y no es una
palabra clave válida en Java.

PROGRAMACION BASICA EN JAVA - 34

 ASESOFTWARE S.A.S

protected Este es un nivel de visibilidad intermedio entre public y

friendly.
Los métodos y atributos protected son accesibles desde
cualquier clase del mismo paquete. Adicionalmente, las clases
derivadas también tienen acceso a los métodos y atributos de la
clase base que sean protected, independientemente del paquete
en que se encuentren.

El siguiente cuadro resume los diferentes niveles de visibilidad en Java:

Visibilidad private friendly protected public

Para la misma
clase    
Para clases en el
mismo paquete   
Para clases en
otros paquetes 
Para clases
derivadas en el   
mismo paquete
Para clases
derivadas en  
otros paquetes

4.2 Definición de Clases

En términos del lenguaje de programación, las propiedades y el comportamiento de las

clases se implementan a través de atributos y métodos respectivamente.

La sintaxis para la definición de clases es:

[modificador] class NombreClase [extends ClaseBase]

[implements interfaces]
{
tipo atributo1;
tipo atributo2;

tipo metodo1 (parametros) {

cuerpo
}

tipo metodo2 (parametros) {

PROGRAMACION BASICA EN JAVA - 35

 ASESOFTWARE S.A.S

cuerpo
}

tipo metodo3 (parametros) {

cuerpo
}
}

donde

modificador Los modificadores de clase son; public, final y abstract.

extends Empleado para implementar herencia.

implements Enumera las interfaces que son implementadas por la clase

NombreClase Identificador válido para la clase que se está definiendo. Por

convención debe empezar con una letra en mayúscula (Aula,
Laboratorio, Cuenta ..).

El código fuente de la definición de clases se debe almacenar en un archivo con extensión

.java, y su nombre debe corresponder con el nombre de la clase.

Ejemplo: Definir la clase Punto:

public class Punto Punto
{
private int x; x : int
private int y; y : int

public Punto(int pX, int pY) { <<constructor>>

x = pX; Punto(pX : int, pY : int)
y = pY;
} trasladar(otro : Punto )
toString()
public void trasladar(Punto otro) {
x += otro.x;
y += otro.y;
}

public String toString() {

return "(" + x + "," + y +")";
}
}

PROGRAMACION BASICA EN JAVA - 36

 ASESOFTWARE S.A.S

4.3 Declaración de Atributos

Los atributos son variables que definen el estado de un objeto en un instante dado.

[visibilidad] [static] [final] tipo nombreAtributo [=

valorInicial];

El tipo de dato de estos atributos puede ser un tipo básico (float, int, char ..) o un clase
definida por el usuario o del API del JDK.

Para los identificadores de atributos y variables se sigue la convención de utilizar

minúsculas, siempre y cuando no sean constantes.

Si se desean definir atributos que son constantes se emplea final que especifica que el
valor inicial del atributo no puede ser modificado.

El modificador static determina si el atributo que se está declarando es una variable de

clase o de instancia.

Ejemplo:

class Prueba {
private float var1;
public int var2;
public final float PI = 3.14;
public static int total;
}

4.3.1 Atributos de instancia vs atributos de clase

Los atributos por omisión son atributos de instancia, mientras que los static son
atributos de clase.

Cada instancia tiene copias "propias" de los atributos de instancias, así que el valor que
posee cada objeto es independiente de los valores que tienen otros objetos.

Para los atributos de clase sólo se crea una copia, la cual es compartida entre todas las
instancias de la respectiva clase. Si un objeto modifica el valor de un atributo de clase,
este cambio se reflejará en cada una de las instancias de la clase.

PROGRAMACION BASICA EN JAVA - 37

 ASESOFTWARE S.A.S

4.4 Declaración de Métodos

La conducta de los objetos es determinada por los métodos que conforman su respectiva
clase. Estos métodos se pueden ver como funciones o procedimientos, que pueden ser
invocados según las reglas de visibilidad del método.

La sintaxis para la definición de métodos es:

[visibilidad] [static] [abstract] [final] tipoRetorno

nombreMetodo (tipo param1, tipo param2 ...)
{
cuerpo del método
}

visibilidad La visibilidad de los métodos puede ser public, protected, private o

tomar el valor por omisión friendly.

static Los métodos marcados como static se denominan métodos de clase.

Estos pueden ser invocados directamente a través de la clase sin
necesidad de crear instancias.
Los métodos static sólo pueden referenciar atributos static.

final Indica que este método no puede ser redefinido en las clases derivadas.
Este es un mecanismo de seguridad en java que evita que los métodos
sean reemplazados erróneamente.

tipoRetorno Es el tipo de valor que el método retorna como salida. Este puede ser un
tipo básico, el nombre de una clase o void si el método no retorna nada.

paramX Los parámetros de entrada al método. Estos parámetros pueden ser

objetos o tipos básicos.
Los tipos básicos se pasan por valor y los objetos por referencia. Si se
altera el estado de un objeto pasado por parámetro, estos cambios se
reflejan en el objeto original.

4.4.1 Métodos constructores y destructores

Los métodos constructores inicializan los atributos del objeto en el instante de su

creación y son invocados automáticamente. El nombre de estos métodos debe coincidir

PROGRAMACION BASICA EN JAVA - 38

 ASESOFTWARE S.A.S

exactamente con el nombre de la clase. Otra característica que distingue a estos

métodos es que no deben tener valor de retorno en su prototipo.

Complementariamente, las clases pueden incluir el método finalize que es el

destructor del objeto, el cual se invocado automáticamente en el instante que el objeto
es eliminado de memoria principal. La definición del método finalize es útil para la
liberación de recursos. Su prototipo es:
protected void finalize throws Throwable {
}

4.4.2 Sobrecarga

La sobrecarga permite que dos o más funciones compartan su nombre siempre y

cuando las declaraciones de los parámetros sean diferentes.

Nota: Java no soporta la sobrecarga de operadores.

4.4.3 Método main

El método main constituye el punto de entrada de una aplicación. Cuando se ejecuta

una clase Java directamente, el runtime asume que se trata de una aplicación y busca el
método main() para iniciar su ejecución. El prototipo de este método es:
public static void main (String[] args)

donde args es un arreglo de cadenas de caracteres que almacena cada uno de los
parámetros de la línea de comandos.

4.5 Manejo de la Memoria en Java.

Java provee un manejo automático de la memoria. Cuando usted crea un nuevo objeto, Java
reserva la cantidad de memoria requerida para dicho objeto de manera implícita. De esta
forma el programador no tiene que preocuparse por reservar memoria explícitamente.

De igual forma, cuando un objeto deja de ser utilizado (no hay variables que lo
referencian), Java lo destruye y libera la memoria ocupada por dicho objeto. Esto lo logra a
través de un mecanismo de recolección de basura automático (Garbage Collection) , que
periódicamente barre la memoria buscando objetos no utilizados.

PROGRAMACION BASICA EN JAVA - 39

 ASESOFTWARE S.A.S

4.5.1 Referencias a objetos

Cuando se asignan objetos a variables, o se pasan objetos como parámetros, se están

empleando o pasando referencias a los objetos y no el objeto en si, ni una copia de él.

Es posible tener una o más variables que referencien el mismo objeto en memoria.

4.5.2 Operador new

El operador new es utilizado para crear nuevas instancias de clases (objetos) asignando
espacio en memoria. Dentro de este proceso de creación, se invoca de forma automática
el constructor de la clase para inicializar los atributos del objeto. Finalmente, el
operador new retorna una referencia al objeto creado.

4.5.3 Operador punto (.)

La forma de acceder los atributos y métodos de una objeto es por medio del operador
punto. La forma general de acceder de un elemento de un objeto es:

referenciaObjeto . nombreAtributo
referenciaObjeto . nombreMetodo

Ejemplo:

Punto p1 = null; // no se ha asignado

Punto p2 = null; // no se ha asignado

p1 = new Punto(1,2);
p2 = new Punto(3,4);
...
p2 = p1;
p1.x = 5;
p1.y = 6;
System.out.println(“la posición de p1 es: “ + p1.x + “, “ + p1.y);
System.out.println(“la posición de p2 es: “ + p2.x + “, “ + p2.y);

Memoria
p1
5, 6
1, 2
p2

PROGRAMACION BASICA EN JAVA - 40

 ASESOFTWARE S.A.S

4.5.4 This

this es una variable especial que referencia al objeto actual (el objeto al cual pertenece
el método que está empleando la variable this). En el ejemplo Punto, el método
constructor puede reescribirse de la siguiente forma:

public Punto(int pX, int pY) {

this.x = pX;
this.y = pY;
}

PROGRAMACION BASICA EN JAVA - 41

 ASESOFTWARE S.A.S

PROGRAMACION BASICA EN JAVA - 42

 ASESOFTWARE S.A.S

5 Herencia

El mecanismo de herencia es una implementación de código compartido, que permite la

definición de nuevas clases de objetos (clases derivadas) a partir de clases existentes
(clases bases). Las clases derivadas heredan la información (atributos) y la conducta
(métodos) de la clase base.

La definición de clases derivadas se hace a través de la cláusula extends.

Ejemplo: Definir la clase Punto:

Punto

x : int
public class Punto3D extends Punto y : int
{
private int z; <<constructor>>
Punto(pX : int, pY : int)
public Punto3D(int pX, int pY, int pZ) {
trasladar(otro : Punto )
x = pX;
toString()
y = pY;
z = pZ;
}
Punto3D
public String toString() {
return z : int
"(" + x + "," + y + "," + z + ")";
} <<constructor>>
} Punto3D(
pX:int, pY:int,pZ:int)

toString()

En este caso, la clase Punto3D posee los atributos x, y y z.

Nota: Java no soporta la herencia múltiple.

PROGRAMACION BASICA EN JAVA - 43

 ASESOFTWARE S.A.S

5.1 Redefinición de Métodos

En el ejemplo anterior la clase Punto3D redefinio (reemplazo) el método toString que se

encontraba en la clase Punto.

5.2 Super

Así como this es una variable que referencia el objeto actual, super es una referencia al
objeto base. Super también es empleado para invocar los constructores de la clase base:

Ejemplo: El método constructor de la clase Punto3D puede ser reescrito empleando super y
así evitar la duplicación de código:

public Punto3D(int pX, int pY, int pZ) {

super(pX, pY);
z = pZ;
}

en este caso super(pX, pY) es una invocación al método constructor de la clase Punto.

5.3 Clases Abstractas vs Clases Concretas

A partir de una clase abstracta no se pueden generar instancias de objetos. El objetivo de

estas clases es proporcionar la declaración de atributos y métodos que puedan ser heredados
por nuevas clases. Las clases abstractas surgen en diseño, en el proceso de generalización
donde los métodos y atributos comunes son factorizados. Las clases abstractas tienen la
posibilidad de declarar exclusivamente el prototipo de los métodos sin especificar su
implementación. En estos casos la implementación deberá ser desarrollada por sus
respectivas clases derivadas que sean concretas.

Las clases a partir de las cuales se pueden crear instancias (objetos), se denominan clases
concretas, y por lo general representan entidades tangibles del mundo real.

Nota: Las clases heredadas de una clase abstracta deben implementar todos los métodos
abstractos declarados en la clase base, o ser a su vez declaradas abstractas.

Ejemplo:
abstract class Empleado {
String nombre;
float salario;
abstract int valorImpuesto();
public String toString() {

PROGRAMACION BASICA EN JAVA - 44

 ASESOFTWARE S.A.S

return nombre;
}
}

class Administrador extends Empleado{

Administrador(String nombre, float salario) {
this.nombre = nombre;
this.salario = salario;
}
int valorImpuesto() {
return salario * 0.1;
}
}

5.4 Polimorfismo

El polimorfismo (Poly: muchas, Morphos: forma), permite definir el mismo método en

muchas clases.

Método (Mensaje) Clase Resultado

Circulo

dibujar Cuadrado

Linea

El polimorfismo facilita el mantenimiento y crecimiento de las aplicaciones OO. Por

ejemplo, evita tener que mantener estructuras tipo switch utilizadas para tomar decisiones
dependiendo del objeto al cual se le desea enviar un mensaje.

Cuando se utiliza polimorfismo, no es posible determinar en tiempo de compilación el tipo

del objeto que debe responder el mensaje enviado. Por tal razón, se utiliza el mecanismo de
encadenamiento tardío (dynamic binding) para determinar el tipo de objeto en tiempo de
ejecución y así poder seleccionar la implementación que debe responder al mensaje
enviado.

Ejemplo:

Dadas las siguientes clases:

PROGRAMACION BASICA EN JAVA - 45

 ASESOFTWARE S.A.S

class A {
public String info(){
return “Datos de la clase A“;
}
}

class B extends A{
public String info(){
return “Datos de la clase B“;
}
}

class C extends A{
public String info(){
return “Datos de la clase C“;
}
}
el mecanismo de polimorfismo se aplica en el siguiente segmento de código:
:
void imprimirInfo(A obj){
System.out.println(obj.info());
}
:
Teniendo en cuenta el siguiente principio ; "Si B es una clase derivada de A y objB es una
instancia de B, entonces objB también es una instancia de A". Continuando con el ejemplo
anterior, las siguientes invocaciones al método imprimirInfo son válidas:

B objB = new B();

C objC = new C();

imprimirInfo(objB);
imprimirInfo(objC);

En este caso cual es el resultado ?.

PROGRAMACION BASICA EN JAVA - 46

 ASESOFTWARE S.A.S

6 Cadena de caracteres (String)

El núcleo de Java provee la clase String para la implementación y manipulación de cadenas

de caracteres.

Por la frecuencia de utilización de la clase String y por presentar características especiales

con respecto a la sintaxis y semántica general de Java, se ha dedicado un capitulo aparte
para el estudio de esta clase. Las propiedades de la clase String son:
1. String es una clase final, por lo cual no se pueden crear clases derivadas a partir de ella.
2. Los objetos de tipo String son NO MODIFICABLES después de su creación.
3. Una cadena de caracteres se delimita por comillas dobles, y es por definición un objeto
de tipo String.

6.1 Creación de Objetos Tipo String

Por medio del siguiente constructor se pueden crear objetos tipo String:
String(char[] caracteres, int posIni, int numeroCaracteres)

Ejemplo
char[] arregloCar = {'d', 'a', 't', 'o'};
String varStr = new String(arregloCar);
String varOtra = new String(arregloCar, 0, 4);

Aunque las sentencias del ejemplo anterior son correctas, Java provee un mecanismo más
simple de crear objetos tipo String;

String varStr = "dato";

6.2 Comparación de Cadenas

Para la comparación de cadenas de caracteres la clase String provee los métodos equals y
equalsIgnoreCase:

PROGRAMACION BASICA EN JAVA - 47

 ASESOFTWARE S.A.S

if ( str.equals("dato") ) {
....
}

6.3 Concatenación de Cadenas

Java no soporta la sobrecarga de operadores, con la excepción del operador +, que cuando
opera sobre objetos String actúa como el operador de concatenación.

Si el operador + tiene como operandos un String y un valor numérico, sobre el valor

numérico se aplica conversión automática de datos transformándolo en una cadena de
caracteres.

Ejemplo:

class Prueba {
public static void main(String[] args) {
String mensaje;
int numParam = args.lenght;
mensaje = "los parametros de la línea de comandos son : " +
numParam;
System.out.println(mensaje);
}
}

6.4 Operaciones de búsqueda

Para realizar búsqueda de cadenas están las siguientes funciones:

boolean endsWith (String s): Retorna verdadero si la cadena finaliza con s.

boolean startsWith (String s): Retorna trae si la cadena inicia con s.

int indexOf (String cadena): Retorna la posición donde se encuentra la cadena.

int lastIndexOf (String cadena): Retorna la posición donde se encuentra la cadena

pero iniciando la búsqueda de atrás hacia adelante.

PROGRAMACION BASICA EN JAVA - 48

 ASESOFTWARE S.A.S

6.5 Clase StringBuffer

La clase StringBuffer representa una cadena de texto que puede ser modificada
dinámicamente, y por ende es mucho más eficiente en algoritmos que manipulan
intensamente cadenas de texto. No existe una relación de herencia entre esta clase y la clase
String; usted no puede asignar un objeto String a una variable declarada como StringBuffer.

Sin embargo usted puede crear un nuevo String de un StringBuffer invocando el método
toString.

Los siguientes son los constructores de la clase:

StringBuffer (). Crea una StringBuffer vacio.

StringBuffer (String stringInicial). Crea una StringBuffer que inicialmente contiene la

cadena stringInicial.

StringBuffer (int capacidad). Crea un StringBuffer que inicialmente contiene con la

cadena capacidad indicada.

Los siguientes son los métodos de modificación de un StringBuffer:

StringBuffer append(String s). Modifica el string adicionando la cadena al final.

StringBuffer insert (int punto, String cadena): Modifica el string insertando la cadena
en la posición indicada por el parámetro punto.

StringBuffer reverse(). Reversa el orden del StringBuffer.

void setCharAt (int punto, char ch). Modifica el string cambiando el caracter ‘ch’ en la
localización especificada por el parámetro punto.

void setLength(int newLength): Establece la longitud del string.

PROGRAMACION BASICA EN JAVA - 49

 ASESOFTWARE S.A.S

PROGRAMACION BASICA EN JAVA - 50

 ASESOFTWARE S.A.S

7 Interfaces

Interfaz

Implementación

Una interfaz es similar a una clase abstracta, que provee los prototipos de los métodos que
se espera sean implementados por las clases concretas. Las interfaces no proveen el cuerpo
(implementación) de los métodos.

El principal uso de las interfaces es proveer métodos comunes a diferentes clases, sin
requerir el mecanismo de generalización(polimorfismo sin requerir jerarquías de herencia).

Se dice que una clase implementa una interfaz cuando la clase implementa cada uno de los
métodos definidos en la interfaz. A diferencia de la herencia, una clase puede implementar
múltiples interfaces, solucionando así la limitante de herencia simple en Java.
<<interface>>
Cuenta Producto

Cuenta Cuenta Tarjeta Prestamo CDT

Ahorro Corriente Credito

PROGRAMACION BASICA EN JAVA - 51

 ASESOFTWARE S.A.S

Por medio de las interfaces se puede resolver la compilación de clases mutuamente

referenciadas.

7.1 Definición de Interfaces

La definición de una interfaz es similar a la definición de una clase, omitiendo el cuerpo de

los métodos:

interface NombreInterfaz extends inter1, inter2

{
tipo final atributo1 = valor;
tipo metodo1 (parametros);
tipo metodo2 (parametros);
}

El prototipo de los métodos puede especificar su visibilidad.

Ejemplo:

interface Activo
{
void depreciar();
float costo();
}

PROGRAMACION BASICA EN JAVA - 52

 ASESOFTWARE S.A.S

7.2 Implementación de Interfaces

En la declaración de clases se debe especificar se está implementado alguna interfaz:

Ejemplo

class Edificio implements Activo

{
private float valorMetro;
private int totalMetros;
private String direccion;

public Edificio(float valorMetro, float totalMetros,

String direccion)
{
this.valorMetro = valorMetro;
this.totalMetros = totalMetros;
this.direccion = direccion;
}

// Implementación de la interfaz Activo

void depreciar() {
valorMetro *= 0.9;
}
float costo() {
return totalMetros * valorMetro;
}
}

PROGRAMACION BASICA EN JAVA - 53

 ASESOFTWARE S.A.S

PROGRAMACION BASICA EN JAVA - 54

 ASESOFTWARE S.A.S

8 Paquetes

En el desarrollo de aplicaciones pequeñas, que no involucren un número considerado de

clases es posible trabajar sin paquetes. Pero para aplicaciones complejas, los paquetes
ayudan a modularizar y organizar el software por medio de la agrupación de clases
relacionadas.

Un paquete es una colección de clases y paquetes. Esta definición recursiva permite

organizar las clases en una estructura jerárquica similar a la jerarquía de directorios de un
sistema de archivos.

8.1 Import

La sentencia import se emplea al inicio de los archivos fuentes para importar clases que se
encuentran en otros paquetes.
Los paquetes se referencian y recorren a través del operador punto:

pkg1.pkg2.pkg3.ClaseA

en este caso estamos referenciando la clase ClaseA que se encuentra en el paquete pkg3,
que a su vez se encuentra en el paquete pkg2. Por último, pkg2 se encuentra en el paquete
raíz pkg1.

Es posible importar una clase especifica o todas las clases de un paquete;

import java.util.Vector;
import java.awt.*;

PROGRAMACION BASICA EN JAVA - 55

 ASESOFTWARE S.A.S

El paquete java.lang es el paquete por omisión, por lo cual si se desean emplear clases de
este paquete no es necesario hacer el import explícitamente.

8.2 Package

Para incorporar una clase en un paquete es necesario introducir la sentencia package como
primera línea de código en el archivo fuente donde se está declarando la clase.

Ejemplo

package pck1;
import java.util.Vector;
impot java.awt.Applet;
public class Clase1 {
public metodo1 () {
System.out.println(“Ejemplo“);
}
}
class Clase2 {
public metodo2 () {
System.out.println(“Ejemplo“);
}
}
class Clase3 {
public metodo3 () {
System.out.println(“Ejemplo“);
}
}

8.3 CLASSPATH y el Sistema de Archivos

CLASSPATH es una variable de ambiente que determina los directorios del sistema de
archivos que son utilizados como raíces de los paquetes. Tanto el compilador como el
runtine de Java utilizan la variable CLASSPATH para determinar la localización de las clases
refenciadas.

La jerarquía de paquetes se ve reflejada en el sistema de archivos. Si se especifica la

siguiente sentencia:
import banco.productos.cuentas.CuentaCorriente;

debe existir la siguiente estructura de archivos en su disco:

PROGRAMACION BASICA EN JAVA - 56

 ASESOFTWARE S.A.S

/usr/rgalindo/classes/
banco/
productos/
cuentas/

y en el interior del directorio cuentas debe estar almacenado el archivo

CuentaCorriente.class

Complementariamente, la variable CLASSPATH debe estar direccionando (como raíz de las

clases de Java) el directorio classes:

setenv CLASSPATH /java/lib/classes.zip:/usr/rgalindo/classes:.

8.4 Opcion -d

El compilador de Java (javac) ofrece la opción -d que permite definir el directorio donde se
deben almacenar los archivos compilados (.class)

javac -d /usr/rgalindo/classes *.java

en este caso, los diferentes .class se almacenarán en el directorio adecuado según lo

especificado en la sentencia package de los archivos fuentes.

PROGRAMACION BASICA EN JAVA - 57

 ASESOFTWARE S.A.S

PROGRAMACION BASICA EN JAVA - 58

 ASESOFTWARE S.A.S

9 Colecciones

9.1 Definición

Una colección es un simple objeto que representa un grupo de objetos llamados elementos.

9.2 Tipos de Colecciones

La estructura de las colecciones se diseño para conseguir diferentes objetivos, como

mejorar rendimiento, permitir trabajar con las diferentes colecciones en forma similar, con
alto grado de interoperabilidad, y que fueran fáciles de extender o adaptar.

Los tipos de colecciones varían dependiendo del mecanismo usado para almacenar,
acceder a datos, o en las reglas usadas para ordenar los objetos de la colección.

El API Collections provee una variedad de interfaces y clases que nos proporcionan
implementaciones diferentes de las interfaces estándar.

Las interfaces que soportan las colecciones se resumen a continuación:

9.2.1 Interfaces del API Collection

 Interfaz Collection

Es la base sobre la cuál se construye la estructura de las colecciones. A continuación se

presentan los métodos declarados en esta interfaz:

PROGRAMACION BASICA EN JAVA - 59

 ASESOFTWARE S.A.S

Método Descripción
Boolean add (Object obj): Adiciona objetos a la colección.
Devuelve true si obj fue agregado a la
colección.
o false si el objeto ya es miembro de la
colección o si la colección no admite
duplicados.
Boolean remove(Object obj): Remueve un objeto de la colección.
Devuelve true si el elemento fue removido,
si no retorna false.

Int size(): Devuelve el número de elementos

guardados en la colección.

 Interfaz Set

Hereda de Collection, se define como un conjunto de elementos no ordenados y no

permite duplicados.
No agrega nuevos métodos y sus valores deben ser únicos.

Ejemplo:

import java.util.*;
public class SetEjemplo{
public static void main(String[] args){
Set set= new HasSet();
set.add("uno");
set.add("dos");
set.add("tres");
set.add(new Integer(4));
set.add(new Float(5.0F));
set.add("dos"); // Los duplicados no son adicionados
set.add(new Integer(4)); // Los duplicados no son adicionados
System.out.println(set);
}
}

 Interfaz List

Hereda de Collection, declara el comportamiento de una colección que almacena una

sucesión de elementos ordenados y permite agregar duplicados.
Define algunos métodos que permiten adicionar y remover elementos dependiendo del
índice especificado.

PROGRAMACION BASICA EN JAVA - 60

 ASESOFTWARE S.A.S

Métodos Descripción
void add(int indice, object obj) : Inserta el objeto a la lista en la posición
que indica el índice.

Object get(int indice ) : Retorna el objeto almacenado en el índice

especificado
Object set (int indice, Object obj) Agrega un elemento a la lista en la
posición especificada

Ejemplo:

import java.util.*;

public class ListEjemplo{

public static void main(String[] args){
List list= new ArrayList();
list.add("uno");
list.add("dos");
list.add("tres");
list.add(new Integer(4));
list.add(new Float(5.0F));
list.add("dos"); // Los duplicados son adicionados
list.add(new Integer(4)); // Los duplicados son adicionados
System.out.println(list);
}
}

9.3 Clases que implementan las interfaces

Implementaciones Map Implementaciones Set Implementaciones List

HashMap HashSet ArrayList
Hashtable LinkedHashSet Vector
TreeMap TreeSet LinkedList
LinkedHashMap

 Clase TreeSet

Proporciona una implementación de la interfaz Set que usa una estructura de árbol para el
almacenamiento de los elementos.
Los objetos se organizan en forma ascendente, los tiempos de acceso y recuperación son
rápidos siendo una excelente alternativa en situaciones donde se requiera almacenar gran
cantidad de información.

PROGRAMACION BASICA EN JAVA - 61

 ASESOFTWARE S.A.S

 ArrayList y LinkedList

Dos clases que implementan la interfaz List son : ArrayList y LinkedList. Se pueden usar
dependiendo de las necesidades específicas.
Si se necesita soportar accesos aleatorios, remover un rango de elementos de la lista y
recorrer la lista en una sola dirección de principio a fin el ArrayList es una buena
alternativa.
Pero si necesita recorrer una lista en forma secuencias en ambas direcciones LinkedList
ofrece la mejor implementación.

<< interface >>

Collection

+add(Objeto obj) :boolean

+remove(Objetc obj): boolean
+size() :int
+isEmtpty(): boolean
+iterator() :Iterator

<< interface >> << interface >>

Set List

+add(Objeto obj) :boolean +add(int index, Objeto obj) :void

+remove(Objetc obj): boolean +remove(int index): Object
+size() :int +get(int index) :Object
+isEmtpty(): boolean +set(int index , Object obj): Object
+iterator() :Iterator +indexOf(Object obj) :int
+listIterator() :ListIterator

HashSet ArrayList LinkedList

PROGRAMACION BASICA EN JAVA - 62

 ASESOFTWARE S.A.S

9.4 Interfaz Iterator

Esta interfaz proporciona métodos que permiten recorrer una colección en la dirección
principio–fin. Si la colección es un Set la iteración no es ordenada. Para el caso de un List
se puede utilizar la interfaz ListIterator que hereda de Iterator y permite recorrer la
colección en forma bidireccionalmente de principio-fin con el método next () o de fin-
principio con el método previous ().
El método remove permite remover de la colección el elemento retornado por los métodos
next () y previous durante una iteración.
El método set reemplaza el elemento indicada por el cursor.

<< interface >>

Iterator

+hasNext() :boolean
+next(): Object
+remove()

<< interface >>

ListIterator

+hasPrevious() :boolean
+previous() :Object
+add(Object obj)
+set(Object obj)

9.5 Las Interfaces de Map

Además de las colecciones Java 2 agregó al paquete java.util los mapas. Un mapa es un
objeto que almacena relaciones u asociaciones entre claves y valores., dada una clave se
puede recuperar su valor. La clave debe ser única pero los valores pueden ser duplicados.

9.5.1 Interfaz Map

Mapea claves únicas a valores. Una clave es un objeto que se usa para recuperar un
valor.

PROGRAMACION BASICA EN JAVA - 63

 ASESOFTWARE S.A.S

Los mapas giran alrededor de dos operaciones básicas, get (Clave) para recuperar y put
() para adicionar un objeto en el Map.
Los mapas no son colecciones pero se puede obtener una vista colección de un mapa,
utilizando el método entrySet () que retorna un Set con los elementos.
Para obtener una vista de las claves usamos keySet() y para los valores se usa values().
Mediante la vista de colección los mapas se integran a la estructura de las colecciones.

 Interfaz SortedMap

Hereda de Map y asegura que las claves se ordenen en forma ascendente. Los mapas
ordenados permiten la manipulación eficiente de submapas o subconjunto de mapas.

9.6 Las clase Map

 HashMap

Implementa la interfaz Map y hereda de AbstractMap, usa una tabla de dispersión para
implemementar la interfaz Map. No garantiza el orden de los elementos, en otras palabras
el orden en que se agregaron los elementos no necesariamente es el orden en que los lee el
Iterator.
Una tabla de dispersión solo permite almacenar objetos que sobrescriban los métodos
hashCode() e equals() definidos en la clase java.lang.Object.
El método hashCode () debe calcular y devolver el código de dispersión del objeto para que
posteriormente el método equals compare los objetos.
La principal diferencia entre un Hashtable y un Hashmap, es que el Gastable no permite
almacenar valores nulos.

 Clase TreeMap

Implementa la interfaz Map usando el ordenamiento tipo árbol. Un TreeMap proporciona

un medio eficiente de almacernar y de recuperación rápida de objetos. Los elementos que
se van a agregrar a la colección deben implementar la interfaz Comparable para que sean
ordenables.

 Clase TreeSet

Proporciona una implementación de la interfaz Set con los elementos ordenados en forma
de árbol.
A diferencia de TreeMap, TreeSet no necesita implementar la interfaz Comparable.

PROGRAMACION BASICA EN JAVA - 64

 ASESOFTWARE S.A.S

9.7 Colecciones en JDK 1.1

Las clases como Vector, Stack, Hashtable, Properties que fueron introducidas desde el JDK
1.0 y JDK1.1 continúan existiendo pero han sido reestructuradas para que puedan
interactuar con la nueva API Collection.

Por ejemplo la clase Vector ahora implementa la interfaz List, la clase Stack es una
subclase de Vector y adiciona las operaciones tipicas de push(), pop() y peek().
La clase Hashtable es una implementación de Map, y la clase Properties es una subclase de
Hashtable que sólo usa Strings para las claves y valores.
Estas colecciones se consideran hilos-seguros por que están sincronizadas lo cual hace
pesada su implementación.

9.8 Clases Genéricas y Colecciones (J2SE 5.0)

Las clases genéricas son un mecanismo introducido en J2SE 5.0 que proporciona mayor
confiabilidad a las aplicaciones escritas en Java, reduciendo la probabilidad de errores de
código ocasionados por operaciones de “casting” y en general por la manipulación de tipos
de objetos. Adicionalmente, abre la posibilidad de tener diseños de clases fácilmente
reutilizables, reduciendo el esfuerzo en codificación.

La implementación de colecciones en J2SE 5.0 se encuentra basada en clases genéricas. El

siguiente segmento de código ilustra el uso de listas en versiones previas:

1 List listaEnteros = new LinkedList();

2 listaEnteros.add(new Integer(0));
3 Integer x = (Integer) listaEnteros.iterator().next();

En la línea de código 3, el programador realizó el casting a Integer, implicando que: el

programador debe ser conciente de que el objeto listaEnteros almacena objetos de tipo
Integer; se espera que todos los objetos adicionados a esta lista hayan sido de tipo Integer;
se puede llegar a producir un error en ejecución en caso que se hayan insertado objetos de
tipo diferente a Integer.

Con clases genéricas, este segmento de código corresponde a:

1 List<Integer> listaEnteros = new LinkedList<Integer>();
2 listaEnteros.add(new Integer(0));
3 Integer x = listaEnteros.iterator().next();

PROGRAMACION BASICA EN JAVA - 65

 ASESOFTWARE S.A.S

En la línea 1 se introduce un nuevo elemento a la sintaxis de Java, denominado parámetro

de tipo. Con esta declaración, al igual que en el segmento anterior, se creó un objeto de tipo
List. La diferencia radica en que ésta lista almacenará exclusivamente objetos Integer, con
las siguientes implicaciones: el compilador detectará errores al insertar objetos
incompatibles; el compilador validará tipos de datos al recuperar objetos de la lista. Esto
redunda en programas más robustos, confiables y fáciles de mantener.

9.8.1 Iteradores

La interfaz Iterator en JSEE 5.0 también es genérica y su definición es:

public interface Iterator<E>

{
E next();
Bolean hasNext();
void remove();
}

Esta definición emplea un variable de tipo denominado E. Esta variable de tipo asume
el tipo de objeto que se desee en el instante de declarar variables. A continuación se
presenta el uso de la interfaz genérica Iterator:

List<Integer> listaEnteros = new LinkedList<Integer>();

listaEnteros.add(new Integer(13));
listaEnteros.add(new Integer(23));
listaEnteros.add(new Integer(33));
listaEnteros.add(new Integer(43));

Iterator<Integer> it = listaEnteros.iterator();
while (it.hasNext()) {
Integer x = it.next();
System.out.println(x);
}

J2EE 5.0 introduce una forma más elegante de iterar las colecciones:

List<Integer> listaEnteros = new LinkedList<Integer>();

listaEnteros.add(new Integer(13));
listaEnteros.add(new Integer(23));
listaEnteros.add(new Integer(33));
listaEnteros.add(new Integer(43));

for (Integer x : listaEnteros) {

System.out.println(x);
}

La sentencia “for each” tiene la forma

PROGRAMACION BASICA EN JAVA - 66

 ASESOFTWARE S.A.S

for (Elemento x : c) {
procesar x.....
}

y aplica para cualquier objeto que implemente la interfaz Iterable, la cual es extendida
por la interfaz Collection.

PROGRAMACION BASICA EN JAVA - 67

 ASESOFTWARE S.A.S

10 Excepciones

Durante la ejecución de una aplicación, el flujo normal de control puede verse afectado por
situaciones excepcionales, como datos en formatos erróneos, archivos corruptos, daños en
los periféricos o en los medios de almacenamiento y ruptura en conexiones de red, entre
otros.

Las aplicaciones robustas y libres de bugs tienen la capacidad de responder adecuadamente

ante situaciones excepcionales, retornando el control del programa a un flujo normal sin
impactar el sistema ni la labor del usuario. Este tipo de aplicaciones exigen que los
desarrolladores de software prevean cada evento y situación que pueda ocurrir sobre el
sistema (tarea eventualmente imposible en aplicaciones complejas).

10.1 Excepciones en Java

En Java las excepciones son eventos o situaciones no contempladas en el comportamiento

normal o deseado de un programa, que son "lanzadas" durante su ejecución y que rompen
el flujo normal del programa.

Java le permite al programador las siguientes operaciones:

1. Manejar las excepciones y recuperar el programa, retornándolo a un estado estable.

2. Definir y lanzar excepciones propias del negocio ("generar error al intentar asignar un
instructor a dos cursos que se dictan en el mismo horario").

3. Separar el código de manejo de errores del código que implementa la lógica normal del
programa:

PROGRAMACION BASICA EN JAVA - 68

 ASESOFTWARE S.A.S

Sin excepciones Con excepciones

int leerArchivo(String arch) leerArchivo (String arch)
{ {
int codError = 0; try
codError = abrirArchivo(arch); {
if (codError < 0) { vArch = Archivo.abrir(arch);
return -1; do{
}else { dato = vArch.leerLinea();
do { }while( !EOF)
dato = leerLinea();
if (dato == null) { }catch (ArchivoNoExiste){
cerrarArchivo(arch); // procesar error
return -2; }catch (FormatoInvalido){
} // procesar error
}while(dato != EOF) }finally {
cerrarArchivo(arch); cerrarArchivo(arch);
} }
} }

10.2 Throwable

La implementación de excepciones en Java se basa en la clase Throwable. Cuando un

evento anormal es detectado, la máquina virtual de Java crea un objeto de tipo Throwable y
le delega al interpretador de Java la responsabilidad de buscar un segmento de código que
le de manejo a dicho evento excepcional (lanza la excepción).

A continuación se presenta un segmento de la jerarquía de clases que se desprenden de

Throwable:
Throwable

Error Exception

RuntimeException IOException AWTException

NullPointerException EOFException

PROGRAMACION BASICA EN JAVA - 69

 ASESOFTWARE S.A.S

Las clases más relevantes en esta jerarquía son:

Error Los objetos de este tipo, representan errores

irrecuperables producidos en el interior de la máquina
virtual de Java. Se espera que nunca sucedan.

Exception Estas son las excepciones que pueden ser capturadas y

manejadas por el programador.

RuntimeException Representan errores de programación, como intentar

acceder a la casilla de un arreglo inexistente.
No es obligatorio proveer código para el manejo de estas
excepciones.

Otras clases El compilador exige que estas excepciones sean manejas

derivadas de por el programador.
Exception

10.3 Manejo de excepciones

El compilador de Java exige que los métodos atrapen (catch) o declaren todas la posibles
excepciones (excepto las RuntimeExcepcion) que puedan ser lanzadas (thrown) por las
instrucciones internas del método. Al intertar compilar una clase que viole la regla anterior,
el compilador fallará y generará el siguiente mensaje de error:

Exception java.io.IOException must be caught, or it must be declared in the throws clause

of this method.

10.4 Captura de excepciones

La captura de excepciones se realiza por medio de bloques try-catch.

try {
// código protegido
} catch (tipoExcepcion1 e){
// procesar error;
} catch (tipoExcepcion2 e ) {
throw e; // re-enviar
} finally {
// ejecutar siempre
}

PROGRAMACION BASICA EN JAVA - 70

 ASESOFTWARE S.A.S

10.4.1 Cláusula try

La cláusula try especifica un bloque de instrucciones que estará protegido ante la

ocurrencia de excepciones, garantizando que estas serán manejadas para evitar la
ruptura del programa.

Una sentencian try debe estar acompañada de una o más cláusulas catch para
especificar que tipos de excepciones son manejadas.

10.4.2 Cláusula catch(ClaseException ex)

Uno o más bloques catch definen los manejadores de excepciones de un bloque try. La
sentencia catch requiere un parámetro cuyo tipo debe corresponder a una clase que
herede de Throwable. Si el catch tiene como parámetro una clase base, entonces este
bloque catch define un manejador de excepciones generico que atrapa todas la
excepciones representadas por clases derivadas de la clase utilizada como parámetro
del catch.

10.4.3 Cláusula finally

La cláusula finally es utilizada para definir instrucciones que se deben llevar a cabo,
independientemente de la ocurrencia o no ocurrencia de excepciones. (por ejemplo
liberar recursos).

Ejemplo:

class SumaParametros {
public static void main(String[] args) {
int suma = 0;
int[] datos = new int[5];
try {
for (int i=0; i<args.length; i++) {
datos[i] = Integer.parseInt(args[i]);
suma += datos[i];
}
System.out.println("Total " + suma);
} catch(NumberFormatException e) {
System.out.println("Los parametros deben ser numeros");
} catch(ArrayIndexOutOfBoundException e) {
System.out.println("Arreglo desbordado");
}
}
}

PROGRAMACION BASICA EN JAVA - 71

 ASESOFTWARE S.A.S

10.5 Declaración de excepciones

Un método que en su interior invoque instrucciones que puedan generar excepciones, tiene
la posibilidad de manejar dichas excepciones por medio de un bloque try-catch o
declararlas.
La declaración de excepciones es empleado para propagar las excepciones al método
invocador.

10.5.1 Cláusula throws

La cláusula throws puede hacer parte del prototipo de un método, y es empleada para
indicar que excepciones no son manejadas en el interior del método, y que serán
propagadas hacia el método que haga la invocación.

tipoRetorno nombreMetodo (tipo param1, tipo param2 ...)

[throws Excepcion1, Excepcion2]
{
cuerpo del método
}

Ejemplo:
class SumaParametros {
static int suma;

static void acumular(String str) throws NumberFormatException {

suma += Integer.parseInt(str);
}

public static void main(String[] args) {

suma = 0;
try {
for (int i=0; i<args.length; i++) {
acumular(args[i]);
}
System.out.println("Total " + suma);
} catch(NumberFormatException e) {
System.out.println("Los parametros deben ser numeros");
}

}
}

PROGRAMACION BASICA EN JAVA - 72

 ASESOFTWARE S.A.S

10.6 Definición de nuevas excepciones

A pesar que el API de Java ofrece un gran número de excepciones predefinidas (clases
derivadas de Throwable), en el desarrollo de aplicaciones se puede requerir la definición de
excepciones propias del negocio para facilitar el entendimiento de los sucesos no deseados
en la aplicación.

Para definir nuevas excepciones , basta con crear una clase derivada de alguna clase que
pertenezca a la jerarquía Throwable.

Ejemplo: El intentar realizar una transferencia de fondos por un valor superior al saldo de la
cuenta origen debería generar una excepción.

class MontoInvalidoException extends Exception

{
String mensaje;
MontoInvalidoException(String mensaje){
this.mensaje = mensaje;
}
public String toString() {
return “Exception MontoInvalido “ + mensaje;
}
}

10.6.1 Lanzamiento explícito de excepciones

Una vez se han definido nuevas excepciones, el programador tiene la posibilidad de

lanzarlas cuando se detecte el suceso excepcional. La sentencia throw es utilizada para
lanzar de forma explícita una excepción:

throw objetoThrowable;

donde objetoThrowable debe ser una referencia a una instancia de objeto de una clase
derivada de Throwable. Ejemplo:
class CuentaAhorro{
public void transferencia(Cuenta ctaDestino, float monto) throws exception {
if (monto <= 0) {
Exception e = new MontoInvalidoException(
“El monto no puede ser negativo”);
throw e;
}
:
}
}

PROGRAMACION BASICA EN JAVA - 73

 ASESOFTWARE S.A.S

10.7 Consideraciones

 Cuándo capturar excepciones ?

 Cuándo propagar excepciones ?
 Cuándo definir nuevas clases derivadas de Exception ?
 Es conveniente capturar excepciones RuntimeException ?

10.8 Aserciones

Las aserciones son especialmente útiles en tiempo de desarrollo y depuración, por que
ayudan a seguir la ejecución del código , con una característica particular que pueden ser o
no utilizadas en tiempo de ejecución. Las aserciones se agregaron a partir de la versión 1.4
J2DK por lo que sería imposible compilar código de aserciones con una versión anterior.
La idea es que si se tiene conocimiento de un resultado o del comportamiento de alguna
variable, se utilicen las aserciones para evaluar un caso excepcional en que esa variable o
elemento se comporte de manera distinta. Aunque estos comportamientos se pueden
evaluar con una excepción se recomienda usar las aserciones ya que estas solamente se van
a utilizar en el periodo de prueba, y luego en tiempo de ejecución no es necesario que se
ejecuten.

La sintaxis es la siguiente :

/**
Tiene que dar true para que la suposición sea aceptada, en caso de ser false
java termina abruptamente a través de una excepción llamada AssertionError.
*/
assert expresión booleana;

/**
Este módelo es mas usado cuando la expresión booleana pueda retorna false,
En tal caso toma la segunda expresión sin importar el tipo de dato de ésta
por que se convierte en String y es pasado como como argumento al constructor
de la excepción AsserTionError para que imprima ese elemento cuando arroja
el mensaje de la excepción.
*/
assert expresión booleana : expresión de culaquier tipo

PROGRAMACION BASICA EN JAVA - 74

 ASESOFTWARE S.A.S

10.8.1 Como utilizar las Aserciones

Las aserciones son generalmente usadas para verificar lógica interna de un método o un
pequeño grupos de métodos. Las aserciones pueden considerarse como precondiciones
de código, en caso de requerir evaluar el valor de alguna variable antes de realizar
alguna acción.
Por ejemplo si se quiere que la variable ‘Y’ sea positiva, podemos utilizar la siguiente
aserción.

assert(Y>0); Si el assert es falso inmediatamente se produce una excepción.

Pero también las aserciones son útiles como postcondición de un código, esto cuando
se sabe que un método debe retornar algo con ciertas características, evaluando sí el
valor retornado cumple con esas características.

Por defecto las aserciones están desactivadas, por esta razón para poder compilar y
ejecutar un programa debemos hacerlo de la siguiente manera:

javac –source 1.4 ClaseAssercion.java

Por medio de la instrucción –source 1.4 se le indica a java que compile considerando el
concepto de aserciones, sin esa opción java no reconoce la sentencia assert y arrojara
un error de compilación.

Para el proceso de ejecución como las aserciones por defecto están desactivadas, y si
deseamos activarlas debemos digitar la siguiente instrucción:

Java –ea ClaseAssercion

Java –enableasertion ClaseAssercion

Si ejecutamos el programa de la manera tradicional las aserciones no son tomadas en

cuenta.

PROGRAMACION BASICA EN JAVA - 75

 ASESOFTWARE S.A.S

11 Clases Anidadas

Las clases anidadas fueron adicionadas en el JDK 1.1. La característica especial de estas
clases es que se definen dentro de la definición de otra clase.
Se utilizan principalmente para agrupar clases que según el paradigma orientado a objetos
deberían estar agrupadas juntas de acuerdo con la lógica que manejan, y así poder controlar
la visibilidad de una, dentro de la otra.
Estas clases se construyen dentro de otra clase y pueden poseer todos lo posibles
modificadores de visibilidad como los métodos y atributos de clase.
Por tanto una clase anidada puede ser private, public, protected o default. Las propiedades
de cada uno de sus modificadores se mantienen, por ejemplo si una clase anidada se declara
protected podrá ser accedida por todas las clases y subclases dentro y fuera del paquete que
la contiene.

Ejemplos:

public class Outer{

private int size;

public class Interna{

public void metodo(){
size++:
}
}
}

public class TestInterna{

public static void main(String[] args){
Outer outer= new Outer();
Outer.Interna interna= outer.new Interna();
interna.metodo();
}
}

PROGRAMACION BASICA EN JAVA - 76

 ASESOFTWARE S.A.S

public class Outer{

private int size;

public class Interna{

private int size;
public void metodo(){
size++: //Parametro local
this.size++; // Atributo de la clase Interna
Outer.this.size++; // Atributo de Outer
}
}
}

PROGRAMACION BASICA EN JAVA - 77

 ASESOFTWARE S.A.S

Las clases anidadas pueden estar declaradas dentro de un método:

Ejemplo:

public class Outer3{

private int size;
public Object ObtieneClaseInterna(int variable){
final int finalVariableLocal=5;
class Interna{
public String metodo(){
:
:
}
}
return new Interna();
}

public static void main(String arg[]){

Outer3 outer= new Outer3();
Object obj= outer.ObtieneClaseInterna(14);
System.out.println("Oject :"+obj);
}
}

PROGRAMACION BASICA EN JAVA - 78

 ASESOFTWARE S.A.S

11.1 Propiedades de las clases Internas

 Dentro del alcance que contiene la clase anidada, podemos referirnos a la clase anidada
por su nombre Interna interna = new Interna().
 Fuera de ese alcance se debe referir la clase como “Outer.Interna” y el nombre de
clase interna debe ser diferente de la clase que la contiene.
 Se puede crear una clase anidada dentro de un método. Estas se denominan clases
locales.
 Las clases locales pueden acceder variables locales incluyendo los argumentos del
método, siempre y cuando estas variables tengan el modificador final.
 La clases anidadas pueden ser abstract
 Un interface puede ser también anidada, e implementada de igual forma.
 Excepto para las clase locales, las clases anidadas pueden ser declaradas con cualquier
modificador de visibilidad.
 Las clases anidadas son compiladas cuando la clase que la contiene es compilada. El
.class que genera será del estilo: Outer$Interna.class

11.2 Clases Internas vs. Anidadas

La clases anidadas pueden ser declaradas static, es cuyo caso no necesitan una referencia de
la clase que las contiene. Ej: Externa.Interna objeto= new Externa.Interna();
Si se van a declarar variables o métodos static dentro de una clase interna , es necesario que
dicha clase se declare static.
Ahora, si se declara static no va tener acceso a los elementos de la clase externa.
La idea de la clase static es obviar el paso de instancias de la clase externa en donde se
encuentra la clase interna o anidada. Es posible declarar en una clase interna estática
atributos o métodos no estáticos, sin embargo para poder acceder a dichos elementos es
necesario una instancia de la clase interna.

La clase anidadas no static son conocidas como “Clases Internas.”

Las clases internas pueden acceder a variables de instancia de la clase que la contiene
usando la referencia this.

Las clases internas no pueden declara miembros static. En caso de necesitar de éstas, deben
ser declaradas en la clase que la contiene para que puedan ser usadas.

PROGRAMACION BASICA EN JAVA - 79

 ASESOFTWARE S.A.S

12 Streams

Un Stream es el medio de comunicación entre un origen de información y su destinatario.El

origen y destino de la información puede ser cualquier productor y receptor de bytes, como
un archivo, una conexión de red, el teclado o el monitor del computador. Las clases para el
manejo de streams se encuentran en el paquete java.io.

12.1 InputStream

InputStream es una clase abstracta que define los métodos fundamentales para la lectura de
información en el lado destinatario de los Streams.

Los métodos que conforman esta clase son:

read Lee los bytes disponibles en el stream. Este es un método

sobrecargado que ofrece las siguientes opciones:
read()
read(byte[] b)
read(byte[]m int off, int len)
skip(long n) Salta n bytes desde la posición actual del stream.
available() Retorna el número de bytes disponibles en el Stream
close() Cierra el stream
mark(int max),mark coloca marca el punto actual en el stream, con el objetivo que
reset() posteriormente se pueda regresar a él.
reset retorna el stream a un punto previamente marcado,
permitiendo releer los bytes posteriores a dicho punto.
max es el máximo número de bytes que el stream puede
memorizar. En caso de excederse este limite, la marca se
invalidará.
markSupported Indica si el Stream soporta mark/reset

PROGRAMACION BASICA EN JAVA - 80

 ASESOFTWARE S.A.S

12.2 OutputStream

OutputStream es una clase abstracta que representa un Stream de salida. Los métodos de
esta clase son:

write Escribe bytes en el stream. Este método puede emplearse con

los siguientes prototipos:
write(int b)
write(byte b[])
write(byte b[], int off, int len)
flush() Transfiere los bytes almacenados en el buffer del stream a su
destino.
close() Cierra el stream.

12.3 Manejo de archivos

La principal aplicación de Streams es el acceso a archivos. Java provee diferentes clases

para la manipulación de archivos, la mayoría de ellas derivadas de InputStream y
OutputStream.

12.3.1 File

Los objetos que son instancias de la clase File, representan y describen un archivo o
directorio.

Los métodos que provee está clase retornan las propiedades del archivo:

canRead()
canWrite()
exists()
getAbsolutePath()
getName()
getPath()
isDirectory()
isFile()
lastModified()
list(), list(FilenameFilter)

Adicionalmente, existen métodos para modificar el estado del archivo:

delete()
mkdir()
renameTo()

PROGRAMACION BASICA EN JAVA - 81

 ASESOFTWARE S.A.S

Ejemplo:

File f = new File("c:\\datos.txt");

System.out.println("El tamaño del arreglo es: " + f.length());

12.3.2 FileInputStream, FileOutputStream

FileInputStream y FileOutputStream son clases derivadas de InputStream y

OutputStream respectivamente, empleadas para leer y escribir archivos.

Estas clases extienden sus respectivas clases bases con los métodos finalize() y
getFD(). finalize() es el destructor de la clase que garantiza que el archivo se cerrara
cuando el objeto sea eliminado por el Garbage Collector. getFD() retorna un objeto de
tipo FileDescriptor que representa el descriptor de archivo respectivo del sistema
operativo.

Los constructores de estas clases pueden recibir como parámetro un String, un objeto
tipo File o un objeto FileDescriptor.

Ejemplo:

import java.io.*;

public class ManejoArchivos {

public static void main(String[] args) {
try{
String mensaje = "Parametros : ";
FileOutputStream streamSalida =
new FileOutputStream("c:\\doc\\datos.txt");

for(int i=0; i<args.length; i++) {

mensaje += " " + args[i];
}

for (int j=0; j<mensaje.length(); j++) {

streamSalida.write(mensaje.charAt(j));
}
streamSalida.close();
}catch(IOException e) {
System.out.println("Error: " + e);
}
}
}

PROGRAMACION BASICA EN JAVA - 82

 ASESOFTWARE S.A.S

12.3.3 BufferedReader y BufferedWriter

La implementación de caches temporales en la lectura y escritura de streams, permiten

aumentar el desempeño de las operaciones lectura/escritura.

Cuando se emplea cache en la lectura de un Stream, por cada acceso al medio físico, el
buffer es llenado. Posteriores lecturas de bytes realizadas por el programa son
obtenidas del buffer.

De forma similar, cuando un programa escribe a un Stream los bytes son almacenados
temporalmente en el buffer hasta que este se llene. Los datos serán enviados a su
respectivo destino cuando el buffer esté lleno.

El JDK 1.02 provee las clases BufferedOutputStream, BufferedInputStream para las

operaciones de entrada/salida. Estas son clases concretas derivadas de OutputStream e
InputStream respectivamente, que no adicionan métodos nuevos.

El JDK 1.1 introdujo las clases BufferedReader y BufferedWriter, especializadas en

manejo de archivos texto, que garantizan un buen desempeño en las operaciones de
entrada/salida y un desarrollo rápido y robusto. Estas clases reemplazan las clases
DataInputStream y DataOutputStream del JDK1.02 en las operaciones de
lectura/escritura de archivos texto.

FileReader fr = new FileReader("ejemplo.txt");

BufferedReader in =
new BufferedReader(fr);
String str;

while ((str = in.readLine()) != null) {

System.out.println(str);
}
in.close();

12.4 Serialización

La serialización es una de las principales características adicionadas al API de Java por el

JDK1.1. La serialización es un mecanismo que permite enviar y recibir un objeto hacia y
desde un stream.

La serialización es la base de la persistencia en Java (salvar objetos en un medio

permanente), y de RMI (Remote Method Invocation).

PROGRAMACION BASICA EN JAVA - 83

 ASESOFTWARE S.A.S

La serialización está basada en las clases ObjectInputStream y ObjectOutputStream que

poseen los métodos readObject() y writeObject respectivamente:

readObject() Reconstruye el objeto actual de un stream para

emplearlo como valor de retorno.
En general, es necesario hacer casting del valor de
retorna para convertir la referencia de tipo Object al
tipo del objeto correspondiente.
writeObject(Object obj) Serializa y escribe en el stream el objeto pasado
como parámetro.

12.4.1 Interfaz Serializable

Los objetos que pueden ser serializados deben implementar la interfaz Serializable.
Esta interfaz no posee definición de métodos, pero si exige que todos los atributos de
las clases que la implementan, también implementen la interfaz Serializable.

La mayoría de las clases que conforman el API de Java implementan la interfaz

Serializable.

Nota: Los tipo básicos no son Serializables.

12.4.2 Modificador transient

transient es un modificador que aplica a los atributos de instancia de una clase. Este
modificar indica que el atributo no debe ser serializado en caso de emplear el método
writeObject.

Esto es deseable en atributos que pueden ser derivados de otros atributos o que son
creados en por el constructor de la clase.

Ejemplo:

Crear un stream de salida:

FileOutputStream fOut = new FileOutputStream("c:\\archivo.txt");

ObjectOutputStream out = new ObjectOutputStream(fOut);
Punto p1 = new Punto(1,2);
out.writeObject(p1);

PROGRAMACION BASICA EN JAVA - 84

 ASESOFTWARE S.A.S

Crear un stream de entrada:

FileInputStream fIn = new FileInputStream("c:\\archivo.txt");

ObjectInputStream in = new ObjectInputStream(fIn);
Punto p1 = (Punto) in.readObject;

12.5 Sockets

A pesar que el tema de comunicaciones en Java requiere más que un capitulo, en este
numeral introducimos el mecanismo de Sockets para ilustrar la funcionalidad de Streams y
Serialización en contextos diferentes al sistema de archivos.

Los Sockets permiten establecer un puente de comunicación entre procesos que pueden
estar corriendo en máquinas remotas interconectados via TCP/IP. Está comunicación es
bidireccional y está basada en el esquema Cliente/Servidor, donde el proceso servidor está
permanentemente activo, esperando la solicitud de algún cliente. Los servidores se
identifican por una dirección IP (máquina en la cual están corriendo) y un puerto
(identificación del proceso).

En Java los procesos Cliente y Servidor se representan por las clases Socket y ServerSocket
respectivamente.
Cliente Servidor

ServerSocket(puerto,
tamCola);

Socket(host, puerto); accept()

OutputStream OutputStream

InputStream InputStream

close() close()

Las operaciones o pasos que ejecuta el cliente son:

1. Crear un objeto de tipo Socket, pasándole al constructor la identificación (ip, puerto)

del servidor al cual se desea conectarse. Esto establecerá la comunicación entre los dos
procesos.
2. Una vez el socket está abierto, el cliente puede emplear los streams de entrada y de
salida, establecidos en la creación del socket.

PROGRAMACION BASICA EN JAVA - 85

 ASESOFTWARE S.A.S

3. Leer y escribir desde y para los streams de entrada y salida.

4. Por último, el cliente puede cerrar la conexión (cerrar los streams y el socket).

Ejemplo de una aplicación cliente

sck = new Socket(“152.9.200.50”, 1357);

br = new BufferedReader(
new InputStreamReader(sck.getInputStream()));
bw = new BufferedWriter(
new OutputStreamWriter(sck.getOutputStream()));

bw.write("Este es un texto de prueba\n");

bw.flush();

String respuesta = br.readLine();

System.out.println(respuesta);
br.close();
bw.close();
sck.close();

El servidor debe realizar las siguientes tareas.

1. Crear el servidor por medio del constructor de la clase ServerSocket, el cual recibe el
puerto por el cual atenderá a sus clientes. Este debe ser un puerto no reservado por otro
servidor.
2. Invocar el método accept, que es un método bloqueante (detiene la ejecución de las
instrucciones hasta que un evento suceda), que queda en espera de la conexión de un
cliente.
3. Una vez un cliente se ha conectado, se establecen los streams de entrada/salida que
permiten comunicar los dos procesos.
5. Leer y escribir desde y para los streams de entrada y salida.
6. Cerrar la conexión con el cliente.

Ejemplo de una aplicación servidor:

ssck = new ServerSocket(pto);

clt = ssck.accept();
br = new BufferedReader(
new InputStreamReader(clt.getInputStream()));
bw = new BufferedWriter(
new OutputStreamWriter(clt.getOutputStream()));
String dato = br.readLine();
bw.write( "ECO: " + dato.toUpperCase() );
bw.flush();
br.close();
bw.close();
clt.close();

PROGRAMACION BASICA EN JAVA - 86

 ASESOFTWARE S.A.S

12.5.1 Sockets y serialización

En los anteriores ejemplos de sockets, se emplearon las clases BufferedReader y

BufferedWriter para acceder a los streams, permitiendo enviar y recuperar cadenas de
caracteres. Si se desea intercambiar objetos complejos, dichas clases se deben
reemplazar por las clases ObjetInputStream y ObjectOutputStream.

Ejemplo:

InputStream is = sck.getInputStream();
ObjectInputStream ois = new ObjectInputStream(is);
Date fecha = (Date)ois.readObject();

OutputStream os = sck.getOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(new Date());

PROGRAMACION BASICA EN JAVA - 87

 ASESOFTWARE S.A.S

13 Applets

Un Applet es una aplicación pequeña que es accedida desde un servidor Web, transportada
a través de la red, instalada automáticamente y ejecutada como parte de una página HTML.
Estos son denominados subprogramas, ya que corren bajo el control de otro programa, que
generalmente es una navegador del web.

Para la implementación de Applets, Java provee la clase Applet que implementa la

funcionalidad necesaria para transportase, instalarse y ejecutarse de forma automática.

Ejemplo:

import java.awt.*;
import java.applet.*;
public class BienvenidaApplet extends Applet {
public void paint (Graphics g){
g.drawString(“Bienvenidos !“, 20, 20);
}
}

Este ejemplo crea la clase derivada BienvenidaApplet de la clase Applet. Esta clase
implementa el método paint, el cual es invocado cada vez que se requiera refrescar la
ventana en la cual está corriendo el Applet.

Para probar el applet BienvenidaApplet es necesario tener una página HTML que lo
contenga:

<applet code="BienvenidaApplet.class" width=200 height=40>

</applet>

13.1 Tag Applet de HTML

Para embeber un Applet en el interior de una página HTML, la página debe emplear el tag
Applet con la siguiente sintaxis:

PROGRAMACION BASICA EN JAVA - 88

 ASESOFTWARE S.A.S

<APPLET
[CODEBASE = URL] CODE = nombreapplet.class
[ALT = texto] [NAME = nombreInst]
[WIDTH = pixels][HEIGHT = pixels]
[ALIGN=alinear][VSPACE=pixels] [HSPACE=pixels]
>
[<PARAM NAME = param1 VALUE = value1 >]
[<PARAM NAME = param2 VALUE = value2 >]
[ Mensaje ]
</APPLET>

donde:
CODEBASE Especifica el URL raíz, donde se encuentra el
bytecode (archivos .class) que implementa el applet

CODE Nombre del archivo .class que implementa el applet.

Este atributo es obligatorio.

ALT Texto alterno que es desplegado en el navegador en

caso que el applet no pueda ser ejecutado.

NAME Nombre de instancia para el applet. Este atributo es

utilizado para comunicar applets que residan en la
misma página HTML.

PARAM NAME Permite crear applets parametricos.

13.2 Ciclo de vida de un Applet

Los Applets pasan por diferentes estados durante su ejecución en el navegador. Estos son:

Creación Cuando el bytecode es cargado desde el servidor, se crea

un objeto de tipo Applet en el cliente.

Inicialización Una el objeto Applet es creado, se inicializan los valores

de sus atributos.

Suspensión Cuando la página que contiene el Applet pierde el foco o

simplemente el usuario navega a otra página, la ejecución
del applet se suspende.

PROGRAMACION BASICA EN JAVA - 89

 ASESOFTWARE S.A.S

Reinicialización Esta etapa se genera cuando la página que contiene el

applet obtiene nuevamente el foco.

Descarga Este estado sucede cuando el usuario cierra el navegador.

Para cada uno de los estados por los cuales puede pasar un Applet, existe un método que se
puede redefiner para dar uso óptimo de la aplicación. Estos métodos son:

init() Es el primer método invocado una vez el applet ha sido

cargado, por lo cual es utilizado para inicializar variables.

start() Es invocado después del método init y cada vez que la

página HTML que contiene el applet pase a ser la página
activa del navegador.

stop() El navegador invoca este método cuando la página HTML

que contiene el applet es abandonada o cuando la página
pierde el foco.
Este método permite optimizar el sistema, mediante la
suspención de tareas que no tiene sentido se ejecuten
mientras el applet no es visible.

destroy() Invocado en el instante que el navegador decida remover

de memoria el applet.
En este método se pueden liberar recursos reservados por
el Applet.

13.3 Parametrización de Applets

El tag Param de HTML es empleado para pasar parámetros al Applet. La sintaxis es:
<PARAM NAME=param1 VALUE=value1 >
donde param1 es el nombre del parámetro y value1 el valor que toma dicho parámetro. Un
tag APPLET puede presentar cero, uno o más tag PARAM.

Para capturar el valor de los parámetros, la clase Applet posee el método getParameter que
recibe el nombre del parámetro y retorna un String con su respectivo valor.

Ejemplo:

PROGRAMACION BASICA EN JAVA - 90

 ASESOFTWARE S.A.S

<applet code=“TextoApplet.class“ width=200 height=40>

<param name=texto value=“Esta es una prueba”>
</applet>

public class TextoApplet extends Applet {

String strTexto
public void init() {
strTexto = getParameter(“texto”);
}
public void paint (Graphics g){
g.drawString(strTexto, 20, 20);
}
}

13.4 Restricciones de los Applets

Los requerimientos de seguridad y confiabilidad de un ambiente abierto y libre como

internet, exigen que las aplicaciones que los usuarios corran en sus navegadores garanticen
que no harán uso inadecuado del sistema. Por está razón los applets presentan las siguientes
restricciones:

1. No pueden acceder al sistema de archivos de la máquina cliente.

2. No pueden establecer comunicación con servidores diferentes al servidor que almacena
el bytecode que implemente el Applet.
3. No pueden invocar programas del cliente
4. No pueden cargar librerías (DLLs)

PROGRAMACION BASICA EN JAVA - 91

 ASESOFTWARE S.A.S

14 Interfaces Gráfica de Usuario

Las interfaces Gráfica de Usuario se desarrollan con el API Abstract Window Toolkit
(AWT), que provee los elementos o componentes gráficos como Botones, Ventanas y
Listas de selección. Adicionalmente, este API define el sistema de manejo de eventos para
la programación de aplicaciones gráficas. Las clases que conforman el API AWT se
encuentran en el paquete java.awt.

14.1 Componentes AWT

Una aplicación gráfica está conformada por componentes AWT anidados, donde la ventana
es el componente principal que actúa como contenedor de componentes AWT.

Los componentes AWT se pueden clasificar en las siguientes categorías:

Contenedores Son objetos que pueden contener otros componentes, incluyendo

otros contenedores. Panel y Applet son ejemplos de clases que
representan componentes contenedores.
El método add permite adicionar componentes al contenedor.
Canvas Un canvas es un área de dibujo, por medio de la clase Graphics.
UI Los componentes UI (User Interface) son elementos como
botones, menús, cajas de texto, radio buttons y listas de
selección.
Ventanas Son componentes como ventanas, marcos (frames), y cajas de
dialogo.

El siguiente diagrama ilustra un segmento de la jerarquía de clases de componentes del

AWT:

PROGRAMACION BASICA EN JAVA - 92

 ASESOFTWARE S.A.S

Component

Canvas Container TextComponent Button

Panel Window TextField

Applet Frame Dialog

La siguiente tabla presenta los componentes UI de AWT con sus respectivos métodos.

Label Es un texto empleado como etiqueta de Label(String)

otros componentes Label()
getText()
setText()
Buttons Representan botones, los cuales Button()
responden al oprimirlos. Button(String)
getLabel()
setLabel()
Checkbox Componente que puede ser seleccionado Checkbox()
o deseleccionado. Checkbox(String)
getLabel()
setLabel()
getState()
setState()
CheckboxGroup Clase empleada para crear Radio CheckboxGroup()
Buttons (uno o más CheckBox, donde
uno solo puede estar seleccionado).

Para adicionar opciones al Radio Checkbox(String,

Buttons se deben crear objetos tipo CheckboxGroup,
Checkbox, pasando como segundo boolean)
parámetro el objeto CheckboxGroup.

PROGRAMACION BASICA EN JAVA - 93

 ASESOFTWARE S.A.S

Choice Son listas de selección descolgantes, Choice()

donde usted puede seleccionar una getItem(int)
opción. countItems()
getSelectedIndex()
getSelectedItem()
select(int)
select(string)
TextField Area donde se puede editar un línea de TextField(int)
texto. TextField(String)
TestField(String, int)
getText()
setText(String)
getColumns()
select(int, int)
selectAll()
isEditable()
setEditable(boolean)
getEchoChar()
echoCharIsSet()

A continuación se presenta un applet con componentes UI:

import java.awt.*;
import java.applet.*;

public class ComponenteUI extends Applet {

public void init() {
setLayout(new GridLayout(2,2));

Label lb = new Label("Ejemplo label");

Button bt = new Button("Cancelar");
Checkbox cb = new Checkbox("Estudiante ?");
Panel pn = new Panel();

CheckboxGroup cbg = new CheckboxGroup();

Checkbox rb1 = new Checkbox("Amarillo", cbg, true);
Checkbox rb2 = new Checkbox("Azul", cbg, true);
Checkbox rb3 = new Checkbox("Rojo", cbg, true);

Choice ch = new Choice();

ch.addItem("Bogota");
ch.addItem("Cali");
ch.addItem("Medellin");

this.add(lb);
this.add(bt);
this.add(cb);

PROGRAMACION BASICA EN JAVA - 94

 ASESOFTWARE S.A.S

this.add(pn);

pn.add(rb1);
pn.add(rb2);
pn.add(rb3);
pn.add(ch);
}
}

14.2 Manejo de eventos

A partir del JDK 1.1 el manejo de eventos sigue el modelo de delegación. Las definiciones
más importantes en este modelo son:

Evento Los eventos son representados por clases derivadas de la

clase EventObject.

Los métodos de las interfaces Listener reciben como

parámetros objetos tipo Event.

Listener Es un objeto "escuchador" que define uno o más métodos

que son invocados como respuesta a un evento originado
por otro objeto.

Las clases que se emplean como Listener deben

implementar alguna interfaz tipo Listener.

Originador de eventos Es un objeto que origina o dispara eventos.

Generalmente son componentes UI.
Estos poseen los métodos setTipoEventoListener y
addTipoEventoListener para registrar los listener que
responderan al evento TipoEvento.

Ejemplo: Las siguientes clases conforman una aplicación con manejo de eventos:

import java.awt.*;
import java.applet.*;
import java.awt.event.*;

public class Basico extends Applet {

public void init() {

FlowLayout ly = new FlowLayout();
setLayout(ly);

PROGRAMACION BASICA EN JAVA - 95

 ASESOFTWARE S.A.S

TextField tf = new TextField("0");

add(tf);

Actualizador actualizador = new Actualizador(tf);

Button bAdicionar = new Button("Adicionar");
add(bAdicionar);
bAdicionar.addActionListener(actualizador);
}
} // fin de la Basico

class Actualizador implements ActionListener

{
TextField campoTexto;

public Actualizador(TextField tf) {

campoTexto = tf;
}

public void actionPerformed(ActionEvent ae) {

String comando = ae.getActionCommand();
String strValorActual = campoTexto.getText();
int valorActual = Integer.parseInt(strValorActual);

valorActual++;
campoTexto.setText( "" + valorActual );
}

} // fin de la clase Actualizador

A continuación se describe el manejo de eventos del ejemplo anterior:

ActionListener Es una interfaz definida en el AWT que declara el método

actionPerformed.

Actualizador Es una clase Listener (por implementar a ActionListener).

bAdicionador Instancia de la clase Button, que actua como originador de

eventos. Al invocar el método addActionListener:

bAdicionar.addActionListener(actualizador);

registra el objeto actualizador como su listener. De esta forma, si

sucede un evento sobre el botón, este se propagará al objeto
actualizar que es una instancia de la clase Actualizador.

Basico Clase derivada de Applet que sirve de contenedor de los objetos

actualizador y bAdicionar.

PROGRAMACION BASICA EN JAVA - 96

 ASESOFTWARE S.A.S

14.2.1 Jerarquía AWTEvent

java.awt.AWTEvent
java.awt.event.ComponentEvent (redimensionar un componente, mover)
java.awt.event.FocusEvent (obtener o perder el foco)
java.awt.eventInput
java.awt.event.KeyEvent
java.awt.event.MouseEvent
java.awt.event.ContainerEvent
java.awt.event.WindowEvent

java.awt.event.ActionEvent (ejecutar una acción o comando)

java.awt.event.AdjustmentEvent (Un valor es ajustado)
java.awt.event.ItemEvent (Cambiar el estado de un Item)
java.awt.event.TextEvent (Cambiar el texto de un componente)

14.2.2 Listener

Por cada clase Event existe una interfaz. A su vez, esta interfaz declara un método por
cada tipo de evento que la clase Event representa. Por ejemplo, la interfaz
FocusListener define los métodos focusGained() y focusLost().

A continuación se listan las interfaces Listener:

Interfaz Métodos
ComponentListener componentHidden
componentMoved
componentResized
componentShown
ContainerListener componentAdded
componentRemoved
FocusListener focusGained
focusLost
KeyListener keyPressed
keyReleased
keyTyped
MouseListener mouseClicked
mouseEntered
mouseExited
mousePressed
mouseReleased
MouseMotionListener mouseDragged
mouseMoved

PROGRAMACION BASICA EN JAVA - 97

 ASESOFTWARE S.A.S

Interfaz Métodos
WindowListener windowActivated
windowClosed
windowClosing
windowDeactivated
windowDeiconified
windowIconified
windowOpened
ActionListener actionPerformed
AdjusmentListener adjustmentValueChanged
ItemListener itemStateChanged
TextListener textValueChanged

14.2.3 Originador de eventos

Los objetos que generan o disparan eventos pueden registrar uno o más objetos listener
que respondan a los eventos, mediante los métodos addTipoEventoListener.

La siguiente tabla define los métodos para registrar listener de cada componente:

Componente Método Listener

Component addComponentListener ComponentListener
addFocusListener FocusListener
addKeyListener KeyListener
addMouseListener MouseListener
addMouseMotionListener MouseMotionListener
Container addContainerListener ContainerListener
Dialog addWindowListener WindowListener
Frame addWindowListener WindowListener
Button addActionListener ActionListener
Choice addItemListener ItemListener
Checkbox addItemListener ItemListener
List addActionListener ActionListener
addItemListener ItemListener
Scrollbar addAdjustmentListener AdjustmentListener
TextArea addTextListener TextListener
TextField addTextListener TextListener
addActionListener ActionListener

PROGRAMACION BASICA EN JAVA - 98

 ASESOFTWARE S.A.S

14.2.4 Adaptadores

AWT provee clases denominadas Adaptadores que implementan las interfaces listener.
La implementación que proveen las clases adaptador se hace a través de métodos
vacíos.

El objetivo de estas clases es facilitar y hacer más entendible el desarrollo de clases

listener.

Por ejemplo, si se desea crear una clase listener para capturar y procesar el evento
mouseClicked, esta clase debe implementar la interfaz MouseListener:

class ManejarClick implements MouseListener {

public int contador;

public ManejarClick() {
contador = 0;
}
public void mousePressed(MouseEvent e) {
}
public void mouseReleased(MouseEvent e) {
}
public void mouseEntered(MouseEvent e) {
}
public void mouseExited(MouseEvent e) {
}

public void mouseClicked(MouseEvent e) {

contador++;
}
}

El incoveniente de esta implementación consiste en la necesidad de implementar

métodos vacíos para poder compilar la clase.

Al emplear la clase MouseAdapter, la clase ManejarClick es:

class ManejarClick extends MouseAdapter {

public int contador;

public ManejarClick() {
contador = 0;
}
public void mouseClicked(MouseEvent e) {
contador++;
}
}

PROGRAMACION BASICA EN JAVA - 99

 ASESOFTWARE S.A.S

Las clases adaptadores que provee el AWT son:

ComponentAdapter
ContainerAdapter
FocusAdapter
KeyAdapter
MouseAdapter
MouseMotionAdapter
WindowAdapter

Observe que no existen clases adaptador para interfaces con un solo método.

PROGRAMACION BASICA EN JAVA - 100

 ASESOFTWARE S.A.S

PROGRAMACION BASICA EN JAVA - 101

 ASESOFTWARE S.A.S

15 Programación Multihilos (Threads)

Java proporciona soporte para programación multihilo. Un programa multihilo contienen

dos o mas partes que se pueden ejecutar de manera concurrente o simultanea. Cada parte
del programa se denomina Hilo (thread), y cada hilo define un camino de ejecución
independiente.
Podríamos decir que la programación multihilos es una forma especializada de multitarea,
que distingue entre dos tipos de tareas: basada en procesos y basada en hilo.
Un proceso es un programa que se esta ejecutando, por tanto una multitarea basada en
procesos significa que su ordenar puede ejecutar dos o mas programas concurrentemente,
siendo el programa la unidad mas pequeña de código que el programador de tareas puede
utilizar. Por ejemplo ejecutar un editor de textos y al mismo tiempo el compilador de Java.
En un ambiente de multitarea basada en Hilos, el hilo es la unidad mas pequeña de código
que el programador de hilos puede seleccionar. Esto significa que un programa multihilo
puede ejecutar 2 o mas partes del programa de manera concurrente. Los hilos son tareas que
no requieren muchos recursos de la CPU, comparten el mismo espacio de direccionamiento
y el mismo programa.

15.1 Fundamentos de los Hilos:

Un “thread”o hilo es un proceso o programa en ejecución que consume recursos del

sistema, compartiéndolos con el resto del programa.

Cuando un programa Java (Aplicación o applet) inicia su ejecución hay un hilo

ejecutándose. Este hilo de denomina normalmente hilo principal desde el cual se crean el
resto de hilos en el programa y debe ser el ultimo hilo que termine su ejecución.
El hilo principal se puede controlar a través del método currentThread() que es un miembro
static de la clase Thread.

static Thread currentThread();

Otra forma de conceptualizar un Hilo es definirlo como una CPU virtual con su propio
código y datos, la cual es encapsulada en una instancia de la clase Thread.

PROGRAMACION BASICA EN JAVA - 102

 ASESOFTWARE S.A.S

CPU

Código Datos

 CPU
 Código: Código que la CPU esta ejecutando.
 Datos: Los datos sobre los cuales el código trabaja.

Se pueden crear hilos de dos (2) formas.

 Crear una clase que implemente la interfaz Runnable, e implementar el método run(). El
constructor con argumentos de la clase Thread recibe a través de la instancia de
Runnable el código y datos que el hilo necesita para correr.

 Creando una subclase de la clase Thread que implementa el método run().

15.2 Implementando la Interface Runnable

Permite abstraer la unidad de código que vamos a ejecutar. Se puede construir un hilo sobre
cualquier instancia de una clase que implemente la interfaz Runnable. Para ello la clase
debe implementar un único método llamado run(). Este método definirá el código que
constituye el nuevo hilo, y será el punto de entrada para la ejecución de otro hilo
concurrentemente.
Después de crear la clase que implemente la interfaz Runnable se creara una instancia de
Thread en otra clase o el misma, pasando como argumento al constructor de Thread la
instancia de la clase que implemento la interfaz Runnable.
El hilo que se acaba de crear no comenzara su ejecución hasta que llame al método start()
de la clase Thread, convirtiéndolo en elegible para ser ejecutado por parte del programador
de hilos.

Ejemplo:

PROGRAMACION BASICA EN JAVA - 103

 ASESOFTWARE S.A.S

public class ClaseThread{

public static void main(String arg[]){
ClaseRunnable obj = new ClaseRunnable();
Thread hilo = new Thread(obj);
Hilo.start();
}
}

public class ClaseRunnable implements runnable{

int i =0;
public void run(){
i=0;
while(true){
System.out.println("Hola"+ i++);
if(i==50){
break; // Permite salir o terminar el ciclo
}
}
}
}

15.3 Creando una subclase de la clase Thread

La segunda forma de crear un hilo es crear una nueva clase que herede de la clase Thread.
La nueva clase debe sobrescribir el método run(), que será el punto de entrada del nuevo
hilo.
public class NuevoHilo extends Thread{
public void run(){
for(int i=0;i<500;i++){
System.out.println("valor de i"+i);
}
}

public static void main(String[] args){

NuevoHilo hilo= new NuevoHilo();
hilo.start(); //Comienza el hilo
}
}

El método run() no se llama directamente, se debe llamar al método start() de la clase padre
(Thread) y este método registra el thread con el programador de hilos quien se encargara de
ordenar cuando ejecutar el hilo y al mismo tiempo llamar al método run()

PROGRAMACION BASICA EN JAVA - 104

 ASESOFTWARE S.A.S

15.4 Programador de Hilos

El programador de Hilos es un procedimiento por el cual diferentes procesos se turnan

tiempo de uso del procesador y puede ser parte de la JVM o del sistema operativo.
En el proceso de programación de hilos debemos distinguir entre dos tipos de modelos de
programación : Preemptive (El tiempo de la CPU que utiliza el hilo depende de la prioridad
del hilo) y Time-Sliced (Consiste en darle a cada hilo igual cantidad de tiempo de CPU).
La tecnología java usualmente trabaja con el modelo preemptive que consiste en que
muchos hilos están en estado runnable o listos para comenzar su ejecución pero solo uno
esta corriendo a la vez , este hilo continua ejecutándose hasta que termina y otro hilo de alta
prioridad comienza a ejecutarse.
Los hilos pueden moverse de un estado a otro para permitir que otros hilos se ejecuten.

15.5 Estado de los Hilos

Blocked

Runnable: El hilo esta listo para ejecutarse y esperando que el programador de hilos le
permita correr.

Running: El hilo se este ejecutando en el método run().

Blocked : Temporalmente el hilo esta bloqueado por que no encontró los recursos de I/O
que necesitaba o por que se pauso por la llamada a los método sleep(), join(), yield(), o
wait().

Dead : El hilo termino su ejecución. En este estado el hilo no puede volver a ser ejecutado.

PROGRAMACION BASICA EN JAVA - 105

 ASESOFTWARE S.A.S

15.6 Prioridades de los Hilos

El programador o Schedule de hilos utiliza las prioridades de los hilos que van de 1 a 10
para decidir cuándo permitir la ejecución de un hilo.
Para obtener la prioridad de un hilo podemos utilizar el método getPriority().
y para establecer una prioridad utilizamos el método setPriority(int nivel) donde nivel es
valor que se le asignara como prioridad al hilo.
La clase Thread incluye unas constantes que podemos utilizar para asignar prioridades.

Thread.MIN_PRIORITY =1;
Thread.NORM_PRIORITY =5;
Thread.MAX_PRIORITY =10;
Por defecto cuando se crea un hilo su prioridad es 5.

Método Thread.sleep()

Este método es una de las maneras de pausar un hilo por un periodo de tiempo, que puede
ser milisegundos o nanosegundos.

public class NuevoThread implements Runnable {

private String nombre;
private Thread t;

public NuevoThread(String nombreHilo) {

nombre = nombreHilo;

/*La palabra 'this' significa que llame al método run()

de este objeto*/
t = new Thread(this, nombre);
System.out.println("Hilos Creados: " + t);
t.start(); // Comienza el hilo
}

public void run() {

try {
System.out.println("El Hilo :" + t
+ ":comienza su ejecuciòn");
for(int i = 5; i > 0; i--) {
System.out.println(nombre + ": " + i) ;
Thread.sleep(5000);
}
}catch(InterruptedException e){
System.out.println(nombre + " Interrumpido") ;
}
System.out.println("El Hilo de nombre :" + nombre
+" termima se ejecución");
}

PROGRAMACION BASICA EN JAVA - 106

 ASESOFTWARE S.A.S

public static void main(String arg[]){

new NuevoThread("uno");
new NuevoThread("dos");
new NuevoThread("tres");
}
}

15.7 Métodos isAlive() y join()

Para conocer si un hilo en particular se esta ejecutando, utilizamos el método

final boolean isAlive()
que devuelve true en caso de que se este ejecutando todavía. Este método es útil en
ocasiones, pero el método que utilizamos habitualmente para asegurarnos que un hilo
termine su ejecución antes del hilo principal es join()
Podemos usar cualquiera de sus formas:

final void join() throws InterrutedException

final void join(long millis) throws InterrutedException
final void join(long millis, long nano) throws InterrutedException

El método join() causa que el hilo que actualmente se este ejecutando espere hasta el hilo
que invoco el método termine su ejecución.

Veamos una modificación del ejemplo anterior para ilustrar el uso de los métodos:

public class NuevoThread implements Runnable {

public String nombre;
public Thread t;

public NuevoThread(String nombreHilo) {

nombre = nombreHilo;

/*La palabre 'this' significa que llame al método run()

de este objeto*/
t = new Thread(this, nombre);
System.out.println("Hilos Creados: " + t);
t.start(); // Comienza el hilo
}

public void run() {

try {
System.out.println("El Hilo :" + t.getName()
+ ":Entro al método Run()");
for(int i = 5; i > 0; i--) {

PROGRAMACION BASICA EN JAVA - 107

 ASESOFTWARE S.A.S

System.out.println(nombre + ": " + i);

Thread.sleep(1000);
}
}catch(InterruptedException e){
System.out.println(nombre + " Interrumpido") ;
}
System.out.println("El Hilo :"+ nombre
+" termima se ejecución");
}
}

public class DemoJoin {

public static void main(String arg[]) {

NuevoThread ob1= new NuevoThread("Uno");

NuevoThread ob2= new NuevoThread("Dos");
NuevoThread ob3= new NuevoThread("Tres");

System.out.println("El hilo uno esta vivo ="

+ ob1.t.isAlive());
System.out.println("El hilo dos esta vivo ="
+ ob2.t.isAlive());
System.out.println("El hilo tres esta vivo ="
+ ob3.t.isAlive());
try {
System.out.println("Espera la finalización de los
otros hilos");
ob1.t.join();
ob2.t.join();
ob3.t.join();
}catch(InterruptedException e){
System.out.println("Interrupción Hilo principal");
}
System.out.println("El hilo uno esta vivo :"
+ ob1.t.isAlive());
System.out.println("El hilo dos esta vivo :"
+ ob2.t.isAlive());
System.out.println("El hilo tres esta vivo :"
+ ob3.t.isAlive());
System.out.println("Salida del hilo principal");
}
}

15.8 Método Thread.Yield()

Use este método para darle la oportunidad a otros hilos de ejecutarse. Si otros hilos están en
estado runnable, al invocar yield() el hilo cede el tiempo asignado de CPU , y se coloca en
el pool de runnable, permitiendo que otros hilos de igual o mayor prioridad puedan

PROGRAMACION BASICA EN JAVA - 108

 ASESOFTWARE S.A.S

ejecutarse. Si no hay hilos en el pool de runnable no hace nada. Se diferencia con el método
sleep() por que sleep() si permite que se ejecuten hilos de cualquier prioridad.

15.9 Sincronización de Hilos (threads)

Cuando dos o mas hilos quieren acceder a un recurso compartido, es necesario asegurarse
de alguna manera que solo un hilo a la vez pueda acceder al recurso, y evitar el riesgo de
dañar la consistencia de los datos. Este proceso se llama sincronización.
La clave para la sincronización es el concepto de monitor. Monitor es un objeto que se
utiliza con cerrojo.
La sincronización en java es sencilla por que todos los objetos poseen su propio monitor.
Para entrar en el monitor de un objeto basta con invocar al método modificado con la
palabra synchronized. Mientras un hilo este en un método sincronizado, todos los demás
hilos que intenten entrar al código sincronizado deberán esperar en el pool de hilos
asociado al objeto dueño del monitor a que el monitor sea liberado.

Para sincronizar un código podemos utilizar dos técnicas, pero ambas utilizan la palabra
reservada synchronized.

 Colocar la palabra synchronized como modificador del método, permitiendo que todo el
código del método quede sincronizado. Esta técnica tiene la ventaja de que al generar la
documentación de la aplicación con el javadoc, el usuario tiene la ventaja de saber que
se esta trabajando con métodos sincronizados y diseñar la aplicación contra posibles
deadlock (abrazo mortal). Sin embargo tiene la desventaja de sacrificar desempeño de
la aplicación por tener mucho tiempo el monitor del objeto.

Public synchronized void meted(String nombre){

:
:
}

 Sincronizar sólo una parte del código del método.

Public void método(String nombre){

Synchronized(this){
:
:
}
}

PROGRAMACION BASICA EN JAVA - 109

 ASESOFTWARE S.A.S

15.10 DeadLock (Abrazo mortal)

En programas multilhilos donde están compitiendo por acceso a múltiples recursos una
condición conocida como deadlock o abrazo mortal puede ocurrir.
Este fenómeno puede ocurrir por ejemplo cuando un hilo ‘A’ esta esperando el monitor del
hilo ‘B’, pero el hilo ‘B’ esta esperando a su vez el monitor del hilo ’A’. En esta situación
ninguno puede proceder hasta el otro termine de pasar el bloque sincronizado. Como
ninguno puede proceder ni liberar el monitor, se produce el abrazo mortal.

Java no puede evitar esa condición, es responsabilidad del programador manejar esta
situación. Como regla general para evitar esta condición en caso de tener muchos objetos
que deseen tener acceso sincronizado a su código, debe tener una decisión del orden en el
cual se deberán obtener los monitores de los objetos e implementarlo en la aplicación. La
liberación deberá ser en el orden inverso en que se obtuvieron.

15.11 Métodos wait() y notify()

La clase java.lang.Object provee dos métodos, wait() y notify() para permitir la

comunicación entre hilos. Estos métodos deben ser llamados dentro del código
sincronizado. Un hilo que llama a wait() libera la CPU y al mismo tiempo libera el monitor

PROGRAMACION BASICA EN JAVA - 110

 ASESOFTWARE S.A.S

o cerrojo. Este hilo entra al pool de hilos en espera el cual es manejado por el objeto que
posee el código sincronizado y que llamo al método wait()... (objeto.wait()).

Wait() : indica al hilo que realiza la llamada que debe liberar el monitor y quedar en espera
hasta que algún otro hilo entre en el mismo monitor (código sincronizado) y llame al
método notify()

notify() : activa el primer hilo que llamo a wait().

notifyAll() : activa todos los hilos que llamaron wait() en el mismo objeto. El hilo de
prioridad mas alta será el primero en ejecutarse.

Ejemplo de un Productor y un Consumidor.

Dentro del get() se llama a wait(), esto ocasiona que el hilo suspenda su ejecución hasta
que el productor notifique con el método notify() que los datos están listos para ser
recuperados. Cuando sucede esto, se reanuda la ejecución dentro del get(), una vez
obtenidos los datos desde el método get() se llama a notify(), esto le indica al productor que
puede colocar mas datos. Dentro del put() el método wait() suspende la ejecución hasta que
el consumidor haya recuperado el dato. Cuando la ejecución continua continúa se coloca el
siguiente dato en la cola y se llama a notify(), lo que le indica al consumidor que puede
retirarlo o consumirlo.

/* Clase que contiene Contiene los métodos sinchronizados put() y get()*/

public class ClaseSincronizada{
int n;
boolean valueSet=false;

public synchronized int get(){

if(!valueSet){
try{
wait();
}catch(InterruptedException e){
System.out.println("Captura excepcion InterruptedException ");
}
}
System.out.println("Consume"+n);
valueSet=false;
notify();
return n;
}
public synchronized void put(int n){
if(valueSet){
try{
wait();
}catch(InterruptedException e){
System.out.println("Captura excepcion InterruptedException ");

PROGRAMACION BASICA EN JAVA - 111

 ASESOFTWARE S.A.S

}
}
this.n=n;
valueSet=true;
System.out.println("Produce"+n);
notify();
}
}

/*Clase productor, coloca recursos*/

public class Productor implements Runnable{
ClaseSincronizada h;
public Productor(ClaseSincronizada h){
this.h=h;
new Thread(this,"Productor").start();
}
public void run(){
int i=0;
while(i<20){
h.put(i++);
}
}
}

/*Clase Consumidor consume recursos*/

public class Consumidor implements Runnable{
ClaseSincronizada h;
public Consumidor(ClaseSincronizada h){
this.h=h;
new Thread(this,"Consumidor").start();
}

public void run(){

int i=0;
while(i<20){
h.get();
}
}
}

/*Clase ejecutora, contiene el método main, punto de arranque de la

aplicación.*/
public class ejecutora{

public static void main(String[] args){

ClaseSincronizada s= new ClaseSincronizada();
new Productor(s);
new Consumidor(s);
}
}

PROGRAMACION BASICA EN JAVA - 112

 ASESOFTWARE S.A.S

16 JDBC

16.1 Introducción

JDBC es un API que permite enviar sentencias SQL estándares hacia una base de datos
relacional. La principal ventaja de la utilización de este API, es su independencia del motor
de bases de datos que se esté empleando. Así, una aplicación cliente desarrollada con Java
y JDBC es independiente de la plataforma (sistema operativo, hardware) y del motor de
bases de datos donde reside la información.

La implementación de JDBC está basada en el concepto de driver. Un driver es un

componente de software empleado como puente entre la aplicación Java y el motor de la
base de datos.

16.2 Qué hace JDBC ?

JDBC es un estándar de bajo nivel que provee la siguiente funcionalidad:

1. Establecer conexiones con bases de datos.

2. Enviar sentencias SQL (update, insert, delete, select).
3. En caso de consultas, recuperar y procesar el conjunto de registros respuesta.
4. Invocar procedimientos almacenados.
5. Definir transacciones.
6. Acceder a la MetaData de la base de datos.

JDBC se considera como un API de bajo nivel ya que no pretende abstraer como objetos
los conceptos de tablas, registros y columnas.

PROGRAMACION BASICA EN JAVA - 113

 ASESOFTWARE S.A.S

16.3 Interfaces que conforman el API JDBC

El API JDBC está conformada de las siguientes clases e interfaces:

DriverManager Carga los drivers JDBC y crea las conexiones a la base de

datos.

Connection Representa una conexión a una base de datos.

Statement Representa la sentencia SQL a ser ejecutada sobre la base

de datos. Las interfaces PreparedStatement y
CallableStatement, son extensiones de Statement.

ResultSet Representa el conjunto de registros respuestas de la

ejecución de un query.

La declaración de estas interfaces se encuentra en el paquete java.sql

16.4 Drivers JDBC

JDBC está basado en drivers los cuales son componentes de software proveídos y/o
optimizados por cada motor de bases de datos. Cada driver debe proveer la implementación
a las interfaces Connection, Statement, PreparedStatement, CallableStatement, ResultSet y
Driver.

16.4.1 Tipos de Drivers JDBC

Los drivers JDBC se pueden clasificar en:

Tipo Descripción 100% Protocolo

Java de red
JDBC-ODBC Este driver es proveido por Java Software. En NO Directo
bridge este caso las invocaciones SQL son
trasladadas a un driver ODBC (Open Database
Connectivity).
Se requiere instalación en la máquina cliente.

PROGRAMACION BASICA EN JAVA - 114

 ASESOFTWARE S.A.S

Tipo Descripción 100% Protocolo

Java de red
Native-API La invocaciones SQL son trasladadas al API NO Directo
de interconexión cliente/servidor del
respectivo motor de bases de datos.

JDBC-Net Las invocaciones SQL son trasladadas a un SI Via

protocolo de red estándar independiente del Servidor
motor. La traducción de las sentencias del
protocolo de red estándar al motor de base de
datos es efectuada por un servidor con la
capacidad de establecer conexiones con
múltiples bases de datos.

Native- Convierte las invocaciones SQL, al protocolo SI Directo

protocol de red usado por el motor de bases de datos.

Aplicación Java

API
JDBC
Driver Manager Driver JDBC

JDBC-ODBC Native-API Net-Protocol Native-Protocol

Bridge Partly-Java all-Java all-Java

Implementaciones
del driver JDBC

Driver ODBC API Cliente Servidor SMBD

propietario de red

SMBD

PROGRAMACION BASICA EN JAVA - 115

 ASESOFTWARE S.A.S

17 Código JDBC

Este capítulo ilustra la utilización de las interfaces que conforman el API JDBC
(Connection, Statement, PreparedStatement y CallableStatement).

17.1 Implementación de aplicaciones JDBC

Para la implementación de aplicaciones JDBC se deben tener en cuenta los siguientes

pasos:

1. Importar las clases y definiciones de interfaces del paquete java.sql.

2. Cargar y registrar los drivers JDBC.
3. Abrir una conexión a la base de datos.
4. Crear una sentencia SQL.
5. Ejecutar la sentencia.
a. En caso de ser una sentencia SELECT, se deben procesar los registros respuesta.
6. Cerrar la sentencia.
7. Comprometer cambios.
8. Cerrar la conexión.

El siguiente programa ilustra la utilización de JDBC para consulta:

1 import java.sql.*;
2
3 class Cliente {
4 public static void main (String args[]) {
5
6 Class.forName ("oracle.jdbc.driver.OracleDriver");
7
8
9 Connection conn = DriverManager.getConnection(
10 "jdbc:oracle:thin:@10.57.56.25:1521:bdA",
11 "usuario", "clave");
12
13 Statement stmt = conn.createStatement();
14
15 ResultSet rset = stmt.executeQuery("select nombre from Cliente");

PROGRAMACION BASICA EN JAVA - 116

 ASESOFTWARE S.A.S

16
17 while( rset.next () ) {
18 System.out.println (rset.getString(1));
19 }
20 }
21 }

A continuación se describen las instrucciones relevantes al API JDBC del ejemplo:

Línea Instrucción Explicación

1 import java.sql.*; Importa las clases e interfaces que conforman el API
JDBC.

6 Class.forName( Carga los drivers JDBC. La clase Driver

driver);
automáticamente se registra ante el DriverManager al
instante de cargarse.

9 getConnection( Retorna un objeto tipo Connection que representa la

url,
usuario, conexión con la base de datos.
clave ); El formato del URL de conexión depende del driver. En
general sigue el siguiente esquema:

jdbc:<subprotocol>:<subname>

13 createStatement() Una vez la conexión ha sido establecida, el método

createStatement crea un objeto tipo Statement que
representa la sentencia que se desea ejecutar sobre la
base de datos.

15 executeQuery(query) Ejecuta sobre la base de datos la sentencia Select

expresada como una cadena de caracteres.

Como resultado se obtiene un objeto tipo ResultSet que

representa el conjunto de registros respuesta.

17 next() El método next de la clase ResultSet, recupera el

siguiente registro de la consulta, dejándolo como
registro actual. next() retorna false en caso que no
existan más registros.

18 getString(i) Retorna el valor almacenado en la i-esima columna del

registro actual.

PROGRAMACION BASICA EN JAVA - 117

 ASESOFTWARE S.A.S

17.1.1 Interface Statement

Los principales métodos de esta clase son:

executeQuery(query) Ejecuta una sentencia SELECT sobre la base de

datos y retorna su respectiva respuesta en un objeto
tipo ResultSet.

executeUpdate(dml) Este método ejecuta la sentencia de DML (update,

insert, delete) sobre la base de datos, retornando el
número de registros afectados por la instrucción.

17.1.2 Interface ResultSet

Los objetos de tipo ResultSet permiten acceder a los registros retornados por una
sentencia SELECT. Cada ResultSet mantiene una referencia al registro actual. El
registro actual se actualiza cada vez que se invoque el método next().

Las columnas (o campos) del registros actual son accedidas por medio de los métodos
getXXX (donde XXX corresponde al tipo de dato de la columna). Las columnas en los
métodos getXXX pueden ser especificadas por el nombre (String) o por el índice de la
columna (int).

La siguiente tabla enumera la familia de métodos getXXX:

Método Tipo retornado

getAsciiStream java.io.InputStream
getBignum java.lang.Bignum
getBinaryStream java.io.InputStream
getBoolean boolean
getByte byte
getBytes byte[]
getDate java.sql.Date
getDouble double
getFloat float
getInt int
getLong long

PROGRAMACION BASICA EN JAVA - 118

 ASESOFTWARE S.A.S

Método Tipo retornado

getObject java.lang.Object
getShort short
getString java.lang.String
getTime java.sql.Time
getTimestamp java.sql.TimeStamp
getUnicodeStream java.io.InputStream

17.1.3 Interface PreparedStatement

Esta es un interface derivada de Statement. Su objetivo es definir sentencias

parametrizables que se esperan sean ejecutadas múltiples veces. En este caso, la
instrucción SQL es analizada y validada sintácticamente por la base de datos solo una
vez, así sea invocada múltiples veces.

Los objetos de tipo PreparedStatement son creados al invocar el método

prepareStatement de la clase Connection.

La parametrización se logra por medio del símbolo ?, en los campos que pueden
modificados:

PreparedStatement ps = conn.prepareStatement(
"insert into personas values(?, ?, ?)");

Los datos pendiente por definir (?), son llenados por medio de la familia de métodos
setXXX.

ps.setInt(1, 25);
ps.setString(2, "SEBASTIAN");
ps.setString(3, "RODRIGUEZ");

Una vez cada una los parámetros (símbolo ?) han sido reemplazados, se puede invocar
la ejecución de la sentencia:

int totalReg = ps.executeUpdate();

17.1.4 Inteface CallableStatement

Esta interface es empleada para invocar funciones o procedimientos almacenados.

Los objetos de tipo CallableStatement son creados al invocar el método prepareCall de

la clase Connection:

PROGRAMACION BASICA EN JAVA - 119

 ASESOFTWARE S.A.S

CallableStatement cs = conn.prepareCall(
"{call obtener_nombre(?,?)}");

En la utilización de CallableStatement, se debe tener presente que existen parámetros

de entrada (IN), de salida (OUT) o de entrada-salida (INOUT).

Los parámetros de entrada deben ser reemplazarlos por su respectivo valor, usando los
métodos setXXX :

cs.setInt(1, 1234);

Los parámetros de salida deben ser registrados antes de ejecutar la sentencia, con el fin
de determinar el tipo de dato que se espera sea retornado:

cs.registerOutParameter(2, Types.VARCHAR);

Una vez se ha ejecutado la sentencia, se pueden recuperar los parámetros de salida por
medio de los métodos getXXX:

cs.executeUpdate();
String strNombre = cs.getString(2);

17.2 Transacciones

Por omisión, las operaciones de acceso y modificación de la base de datos tienen la

propiedad auto-commit (las modificaciones son comprometidas por cada sentencia
ejecutada).

La clase Connection provee el método setAutoCommit, que permite habilitar o inhabilitar

la opción auto-commit. Si se desean emplear transacciones (múltiples instrucciones en una
sola transacción), se debe realizar la siguiente invocación:

conn.setAutoCommit(false);

17.2.1 Commit y Rollback

Si la opción auto-commit está inhabilitada, el programador puede comprometer o

deshacer los cambios, invocando los métodos commit() y rollback()
respectivamente.

Estos son métodos de la clase Connection.

PROGRAMACION BASICA EN JAVA - 120

 ASESOFTWARE S.A.S

18 Ejercicios

18.1 Capitulo 1.

1. La portabilidad de Java consiste en:

a. El código fuente es compatible en cualquier sistema operativo.
b. El código compilado de java, corre en cualquier sistema operativo sin
directamente.
c. El código compilado de java corre bajo una máquina virtual, la cual se
encuentra disponible para cualquier sistema operativo comercial.
d. El código java se parece a C++ por lo cual es conocido por la comunidad de
desarrolladores.

Respuesta (C)

2. El compilador de java generada un código denominado:

_______________________

Respuesta (Bytecode)

3. Enumere y describa brevemente 3 APIs del Java Development Kit.

PROGRAMACION BASICA EN JAVA - 121

 ASESOFTWARE S.A.S

Respuesta

io Clases que dan soporte a la lectura y escritura de datos.

util Miscelánea de clases para la implementación de estructuras de datos (como vectores

y tablas de hash) y la manipulación de fechas.

sql Clases de administración de drivers JDBC para el acceso a bases de datos

relacionales.

18.2 Capitulo 3.

1. Cual debe ser el prototipo del método main() para que sea empleado como punto de
entrada de una aplicación Java:

Respuesta

public static void main (String[] args)

{
}

2. De acuerdo al siguiente segmento de código, cual de las afirmaciones son válidas:

int[] arrA;
int[] arrB;
arrB = arrA;
arrA = new int[10];

a. Refereciar a arrB[1] es equivalente a referenciar arrA[1];

b. arrA posee 10 elementos, cada uno de ellos con el valor cero.
c. arrA[10] es igual a cero.
d. arrA.length es igual a 10.

Respuesta (b) y (d)

PROGRAMACION BASICA EN JAVA - 122

 ASESOFTWARE S.A.S

3. El resultado en consola del siguiente segmento de código es:

_______________________

int[] arrA = new int[4];

int x=0;
arrA[++x] = 1;
System.out.println("arrA["+x+"] = " + arrA[x]);

Respuesta arrA[1] = 1

4. ECO de frases en reversa: Desarrolle un programa que recibe como argumentos las
palabras que conformen una frase, y que imprima dicha frase al revés:
>java ReversarFrase esta es prueba facil
>facil prueba una es esta

5. Encontrar el “centro de gravedad” de un arreglo. En este caso debemos asumir que

el valor almacenado en cada casilla es un peso y que la palanca es más fuerte a
medida que se aleja del centro de apoyo. De esta forma, el centro corresponde al
indice (k) que cumple:

k-1 n
∑ (k-i) . arr[i] = ∑ (j-k) . arr[j]
i=0 j=k+1
donde n es el tamaño de arreglo arr.

Por ejemplo, el centro del siguiente vector es la casilla 2:

6 0 8 4 1 2

Observe que 6*2 + 0*1 es igual a 4*1 + 1*2 + 2*3.

Notas:
1. Los datos del arreglo se reciben de la línea de comandos. Ejemplo
>java Centro 6 0 8 4 1 2
2. Emplee el método parseInt de la clase Integer para convertir cadenas de
texto a valores numéricos.
3. Emplee el método abs de la clase Math para calcular el valor absoluto de
un valor entero.

PROGRAMACION BASICA EN JAVA - 123

 ASESOFTWARE S.A.S

4. Sugerencia: cree un método auxiliar denominado pesoPalanca que

determine el peso de la palanca de un determinado fragmento del arreglo.
5. No todo arreglo posee centro.

18.3 Capitulo 4 y 5

1. Cuales de las siguientes afirmaciones son ciertas:

a. A partir de clases abstractas no se pueden crear instancias de objetos.

b. Todos los métodos de las clases abstractas son abstractos.
c. Las clases abstractas pueden llegar a ser clases derivadas.
d. Las clases concretas deben implementar todos los métodos abstractos de su
respectiva clase base.

PROGRAMACION BASICA EN JAVA - 124

 ASESOFTWARE S.A.S

2. Considere la siguiente jerarquía de herencia:

<<abstract>>
MedioTransporte

Terrestre Aereo

Automovil Moto Avion

1. MedioTransporte trans1;
2. Terrestre terr1, terr2;
3. Automovil aut1;
4. Avion av1;
5. Moto mt1, mt2;

6. trans1 = new Moto() ;

7. aut1 = new Automovil() ;
8. av1 = new Avion();

9. terr2 = aut1;
10. mt1 = trans1;
11. mt2 = av1;

Cuales de las siguientes afirmaciones son correctas:

a. La línea 6 no compila ya que la clase MedioTransporte es abstracta.
b. La línea 9 no compila ya que requiere el casting (Terrestre).
c. La línea 10 es correcta ya que trans1 en efecto está referenciando un objeto
de tipo Moto.
d. La línea 11 compila, pero genera un error al correr.

3. Respuesta Ninguna
En a no se esta creando una instancia
En b no se requiere cast
En c no se puede convertir un medio de transporte hacia moto
En d no se puede convertir avión hacia moto

PROGRAMACION BASICA EN JAVA - 125

 ASESOFTWARE S.A.S

4. Cual es el resultado de la ejecución del siguiente programa:

1. public class ClassA {

2. static int atributo1;
3. protected int atributo2;
4. protected int atributo3;
5. public void metodo1() {
6. this.atributo1 = 10;
7. this.atributo2 = 20;
8. this.atributo3 = 30;
9. }
10. public String toString() {
11. return "Valores: "+atributo1+" "+this.atributo2+" "+this.atributo3;
12. }
13. }

1. public class ClassB extends ClassA {

2. public void metodo1() {
3. this.atributo1 = 5;
4. this.atributo2 = 15;
5. this.atributo3 = 25;
6. }
7. }

1. public class Principal {

2. public static void main(String[] args) {
3. ClassA obj1, obj2;
4. obj1 = new ClassA();
5. obj2 = new ClassB();
6. obj1.metodo1();
7. obj2.metodo1();
8. System.out.println("Obj1 : " + obj1);
9. System.out.println("Obj2 : " + obj2);
10. }
11. }

Respuesta

Valores: 5 20 30
Valores: 5 15 25

5. Sobrescriba el método toString() en la clase Persona. Este método debe retornar una
cadena como la concatenación de nombres, primer apellido y segundo apellido. Ej:
Jairo Orlando Perez Silva.

Respuesta

public String toString()

{
Return (this.PrimerNombre + “ “ + this.SegundoNombre + “ “ +
this.PrimerApellido + “ “ + this.SegundoApellido);

PROGRAMACION BASICA EN JAVA - 126

 ASESOFTWARE S.A.S

6. Sobrescriba el método toString() en la clase Instructor. Al igual que en Persona,

debe concatenar nombres, primer apellido y segundo apellido, pero adicionalmente
debe ilustrar la categoría. Ej: Jairo Orlando Perez Silva (DBA).

Respuesta

public String toString()

{
Return (Super.toString() “ “ + this.Categoria);
}

18.4 Capitulo 6

1. ECO de palabras en reversa: Desarrolle un programa que recibe como argumentos

las palabras que conformen una frase, y que imprima dicha frase con sus respectivas
palabras al revés:
>java ReversarFrase esta es prueba facil
>licaf abeurp se atse

Respuesta

public static void main(String[] args) {

// Reversar frase

/*StringBuffer st;

for (int i=args.length-1; i >= 0 ;i-- )

{
st= new StringBuffer(args[i]);
System.out.print(st.reverse() + " ");
}
}

2. Implemente en la clase Persona el método “public boolean equals(Object obj)” . Se

considera que dos objetos tipo Persona representan al mismo individuo si:

PROGRAMACION BASICA EN JAVA - 127

 ASESOFTWARE S.A.S

a. Poseen los mismos apellidos y nombres

b. Poseen los mismos apellidos y una de las personas tiene un único nombre
que corresponde al primer nombre de la otra persona. Ej: “Maria Yolanda
Rojas Perez” es equivalente a “Maria Rojas Perez”.

Respuesta
En la clase Persona

public boolean equals(Object obj){

if (this.PrimerNombre == ((Persona)obj).PrimerNombre &&

(this.SegundoNombre == ((Persona)obj).SegundoNombre
|| (((Persona)obj).SegundoNombre == null)) &&
this.PrimerApellido == ((Persona)obj).PrimerApellido &&
this.SegundoApellido == ((Persona)obj).SegundoApellido)

{
return(true);
}
else
{
return(false);
}
}

En la clase de prueba

Persona p1= new Persona();

p1.PrimerNombre="Paula";
p1.SegundoNombre="Andrea";
p1.PrimerApellido="Vargas";
p1.SegundoApellido="Barrero";

Persona p2= new Persona();

p2.PrimerNombre="Paula";
//p2.SegundoNombre="Catalina";
p2.PrimerApellido="Vargas";
p2.SegundoApellido="Barrero";

if (p1.equals(p2))
{
System.out.println("Son iguales");
}
else
System.out.println("No son iguales");

PROGRAMACION BASICA EN JAVA - 128

 ASESOFTWARE S.A.S

3. Implemente los siguientes métodos en la clase PrincipalPersonas.java:

public void Imprime en pantalla la información de los

imprimirInstructores(Persona[] instructores.
personas)
public void Imprime en pantalla las personas que se
repetidas(Persona[] personas) encuentran más de una vez en el listado.

PROGRAMACION BASICA EN JAVA - 129

 ASESOFTWARE S.A.S

18.5 Manejo de archivos

a) Realizar una función que lea el contenido de un archivo (ejemplo Bienvenida.java y

lo copie hacia un nuevo archivo).

Respuesta

public class ManejaArchivo {

// TODO Auto-generated method stub

public static void main(String[] args) {
try{

FileReader fr = new FileReader("C:\\Java\\Bienvenida.java");

FileWriter fw = new FileWriter("C:\\Java\\BienvenidaCopy.java");

BufferedReader in =
new BufferedReader(fr);
BufferedWriter out =
new BufferedWriter (fw);

String str;

while ((str = in.readLine()) != null) {

out.write (str );
out.newLine();

}
in.close();
out.close();

}catch(IOException e) {
System.out.println("Error: " + e);
}

}
}

PROGRAMACION BASICA EN JAVA - 130

 ASESOFTWARE S.A.S

b) Realizar una función que escriba en un archivo un objeto de tipo persona y

posteriormente lo recupere).

Respuesta

public static void main(String[] args) {

/* try {

//Escribir archivo
FileOutputStream fOut = new
FileOutputStream("c:\\java\\persona.txt");
ObjectOutputStream out = new ObjectOutputStream (fOut);

Persona p1= new Persona();

p1.PrimerNombre="Paula";
p1.SegundoNombre="Andrea";
p1.PrimerApellido="Vargas";
p1.SegundoApellido="Barrero";
out.writeObject(p1);

}
catch (FileNotFoundException ex) {
ex.printStackTrace();
}
catch (IOException ex) {
ex.printStackTrace();
}*/

try {
FileInputStream fIn = new FileInputStream("c:\\java\\persona.txt");
ObjectInputStream in = new ObjectInputStream(fIn);
Persona p2 = (Persona) in.readObject();
System.out.println(p2);

}
catch (FileNotFoundException ex) {
ex.printStackTrace();
}
catch (IOException ex) {
ex.printStackTrace();
}
catch (ClassNotFoundException ex) {
ex.printStackTrace();

PROGRAMACION BASICA EN JAVA - 131

 ASESOFTWARE S.A.S

}
}

PROGRAMACION BASICA EN JAVA - 132

 ASESOFTWARE S.A.S

18.6 Ejercicio Arreglos y Colecciones

1. Cuáles de las siguientes son sentencias son válidas para inicializar un arreglo?

I. int[] aobj = {0, 1, 2};

II. int[4] aobj = {0, 1, 2};

III. int[] aobj = new int[3];

(a) Sólo I y III

(b) Sólo I y II
(c) Sólo I
(d) Sólo III

Respuesta (a)

2. Para el siguiente fragmento de código Java.

public class Arr{
public static void main(String[] args) {

int[] a = {1, 2, 3};

System.out.println(a[1]);
System.out.println(a[3]);
}
}

¿Cuáles de las siguientes sentencias son verdaderas en relación al resultado de

ejecutar el programa?

(a) Se imprime número 3 y una excepción de runtime termina la ejecución.

(b) Se imprime número 1 y no hay una terminación anormal.
(c) Se imprime número 2 y no hay una terminación anormal.
(d) Se imprime número 2 y una excepción de runtime termina la ejecución.

Respuesta (d)

PROGRAMACION BASICA EN JAVA - 133

 ASESOFTWARE S.A.S

3. Según el fragmento de código siguiente, ¿cuál es el índice del elemento que contiene
45?
int[] numbers = {-1, 45, 6, 132};

(a) 2

(b) 45

(c) 0

(d) 1

Respuesta (d)

4. Considere el siguiente segmento de código Java.

int[] arr;
arr = new int[3];
arr[2]=19;
arr[1]=17;
arr[0]=15;

Cual sentencias es sintácticamente correcta y es semánticamente idéntica al segmento

de programa?

(a) int[3] arr = {15, 17, 19};

(b) int arr[3]= {15, 17, 19};
(c) int arr = {15, 17, 19};
(d) int[] arr= {15, 17, 19};

Respuesta (d)

5. ¿En cuál de las siguientes formas pueden agregarse elementos a una colección
implementada por java.util.ArrayList?
I. Items pueden ser insertados al inicio de la colección.

PROGRAMACION BASICA EN JAVA - 134

 ASESOFTWARE S.A.S

II. Items pueden ser insertados entre dos ítems de la colección.

III. Items pueden ser adicionados al final de la colección.

(a) Sólo I y III

(b) I, II, y III
(c) Sólo III
(d) Sólo I

Respuesta (b)

6. La clase java.util.ArrayList implementa una colección que:

(a) No puede ser accedida usando un entero indice

(b) Puede crecer para acomodar los nuevos items
(c) Puede almacenar sólo variables primitivas tal como enteros o boolean
(d) Puede almacenar solo instancias de la clase java.lang.String

Respuesta (b)

7. Un objeto que contiene métodos que recorre una colección linealmente desde el inicio
hasta el fin se conoce como.

(a) loop
(b) iterator
(c) int
(d) Exception

Respuesta (b)

8. Cuáles de las siguientes sentencias no son verdaderas de la clase

PROGRAMACION BASICA EN JAVA - 135

 ASESOFTWARE S.A.S

java.util.ArrayList?

(a) Items almacenados por un objeto ArrayList pueden ser accesados usando
indices enteros.
(b) Una vez un objeto es insertado en una instancia de ArrayList, este nunca
puede ser eliminado.
(c) El constructor de la clase ArrayList, cuando es llamado sin argumento, Causa
que un ArrayList vacio sea construido.
(d) Una instancia de ArrayList puede crecer para acomodar nuevos items cuando
la colección está llena.

Respuesta (b)

PROGRAMACION BASICA EN JAVA - 136

 ASESOFTWARE S.A.S

18.7 Ejercicio AWT

1. Considere el siguiente segmento de código Java.

PrintWriter fileOut = new PrintWriter(
new FileWriter("output.txt"));

Si el archivo output.txt ya existe, Que sucederá cuando el programa se ejecute?

(a) Un run-time error probablemente se genere.

(b) El contenido existente de output.txt probablemente se borre.
(c) El contenido existente del output.txt probablemente se mantenga.
(d) Un FileAlreadyExists exception probablemente sea lanzado.

Respuesta (b)

2. In Java, El layaout por defecto de un componente JPanel es

(a) GridBagLayout
(b) BorderLayout
(c) FlowLayout
(d) GridLayout

Respuesta (c)

3. La parte del view del paradigma Model-View-Controller (MVC) es la

(a) Lista de clases abstractas en una aplicaciòn

(b) Conocimiento de la abstracciòn del dominio de una aplicaciòn
(c) Mecanismo automático por el cual se muestra la interfaz de usuario y los
eventos que se comunica entre el modelo y el controlador

PROGRAMACION BASICA EN JAVA - 137

 ASESOFTWARE S.A.S

(d) Manera en que el conocimiento de la abstracciòn del dominio de una aplicaciòn

es presentado al usuario.

Respuesta (d)
4. Cuáles de las siguientes sentencias son verdaderas con respecto al manejo de eventos
en Java?
I. Cuando un componente GUI es creado, el component automaticamente tiene
la habilidad para generar eventos durante la interacción con èl usuario.

II. Cada objeto Listener debe estar registrado con el componente específico
para que el objeto Listener responda.

(a) Ninguno
(b) Solo II
(c) I y II
(d) Solo I

Respuesta (c)
5. En Java, Cual es la firma del método de la interfaz WindowListener donde se
adiciona el código para finalizar un programa cuando el botón es presionado?

(a) void windowDeactivated (WindowEvent we)

(b) void windowClosing (WindowEvent we)
(c) void windowAdapter (WindowEvent we)
(d) void windowClosed (WindowEvent we)

6. Cuál de los siguientes eventos Java es generado cuando un componente JButton es

presionado?

(a) ButtonEvent
(b) ClickEvent
(c) ActionEvent
(d) WindowEvent

PROGRAMACION BASICA EN JAVA - 138

 ASESOFTWARE S.A.S

Respuesta (c)
7. La clase ListSelectionEvent y la interface ListSelectionListener estàn
disponibles en el paquete ____________ de Java.

(a) java.awt.event
(b) java.event
(c) javax.event
(d) javax.swing.event

Respuesta (d)
8. Cuál de los siguientes eventos Java es generado cuando el botón cerrar de un
componente JFrame es presionado?

(a) ExitEvent
(b) DisposeEvent
(c) CloseEvent
(d) WindowEvent

Respuesta (d)

PROGRAMACION BASICA EN JAVA - 139

 ASESOFTWARE S.A.S

18.8 Ejercicio. Interfaces Gráfica de Usuario - JDBC

Implementando la capa de base de datos del sistema de Café Gourmet

Descripcion
La clase CatalogGUI mostrará al usuario el detalle del catálogo de productos de la tienda
de café Gourmet. Esta sencilla interfaz contiene los siguientes componentes:

 Un JList que muestra el código de cada producto del catálogo

 Un JPanel que presenta el detalle del producto

 Un JTextArea que sirve como un área de estado

Para visualizar el detalle de un producto el usuario selecciona el producto de la lista. La
aplicación responderá mostrando el detalle del producto en el JPanel y un mensaje de
estado en el JTextArea.

Figure 1 Ejecución de CatalogGUI

El siguiente diagrama de clases resalta en color la clase usada para implementar la interfaz
gráfica:

PROGRAMACION BASICA EN JAVA - 140

 ASESOFTWARE S.A.S

Figure 2 Diagrama de Clases

La Clase CatalogGUI organiza los componentes en una ventana, y maneja los eventos de la
lista.

La Clase DataField contiene un par nombre/valor que representa un atributo que es

almacenado en el objeto. Una complete implementación del DataField es proporcionada.

Las classes Product, Coffee, y CoffeeBrewer tienen un método llamado getDataFields

que retorna un ArrayList objetos de tipo DataField con el detalle de los productos:

 En la clase Product, el método getDataFields retorna un ArrayList con objetos

DataField para los atributos "codigo", "descripcion" y "precio".

 En la clase Coffee, el método getDataFields retorna un ArrayList con objetos

DataField para los atributos "codigo", "descripcion", "precio", "origen", “Sabor",
"aroma", "acidez" and "cuerpo".

 En la clase CoffeeBrewer, el método getDataFields retorna un ArrayList con

objetos de tipo DataField para representar los atributos "codigo", "descripcion",
"precio", "modelo", "Suministro de agua" and "numero de tazas".


PROGRAMACION BASICA EN JAVA - 141

 ASESOFTWARE S.A.S

 La FileCatalogLoader lee los productos de un archivo texto y construye el catálogo

que es mostrado a través de la interface gráfica.


Una completa implementación de las clases Product, Coffee, y CoffeeBrewer

La clase Catalog tiene un método llamado getCodes que retorna un arreglo de código de
productos que usa el CatalogGUI para llenar el JList. Una complete implementación
Catalog es proporcionada.

Archivos
Los siguientes archivos son necesarios:
 student-files.zip:

o Archivos de clases
 Product.class

 Coffee.class

 CoffeeBrewer.class

 Catalog.class

 CatalogLoader.class

 FileCatalogLoader.class
 DataFormatException.class

 DataField.class

o Documentacion
 Product.html

 Coffee.html

 CoffeeBrewer.html

 Catalog.html

 CatalogLoader.html

 FileCatalogLoader.html
 DataFormatException.html

PROGRAMACION BASICA EN JAVA - 142

 ASESOFTWARE S.A.S

 DataField.html

o Archivo Java

 CatalogGUI.java— una completa implementación

o Archivo de datos para el test

 catalog.dat — Archivo con la información de los productos

o Archivo de Base de datos

 DBProductos — Base de Datos de dónde se van a extraer el conjunto

de productos de la tabla producto. Para identificar el tipo de producto
la tabla tiene el campo tipo con los siguientes valores posibles:
Producto, Maquina y cafè

Tareas
o Cambiar la implementación de manejo de archivos planos hacia consultas de
base de datos (Access)
o Modificar la interface con el fin de permitir modificar uno de los atributos
del producto.
o Modificar la interface para permitir eliminar productos de la base de datos
o Modificar la interface para permitir adicionar productos.
o Documentar cada una de las anteriores funcionalidades para posteriormente
generar documentación con Javadoc

PROGRAMACION BASICA EN JAVA - 143

 ASESOFTWARE S.A.S

Solución
public CatalogSolution loadCatalog(String filename)
throws FileNotFoundException, IOException, DataFormatExceptionSolution {

CatalogSolution catalog = new CatalogSolution();

ProductSolution product= null;

try {
Class.forName ("sun.jdbc.odbc.JdbcOdbcDriver");

//
Connection conn = DriverManager.getConnection("jdbc:odbc:cafe");
Statement stmt = conn.createStatement();
ResultSet rset = stmt.executeQuery("select codigo,descripcion,precio from Producto where
tipo='producto'");

while( rset.next () ) {
//System.out.println (rset.getString(1));
//System.out.println (rset.getString(2));
//System.out.println (rset.getDouble(3));
product= new ProductSolution(rset.getString(1),rset.getString(2),23f);
catalog.addProduct(product);
}

}
catch(ClassNotFoundException e){
e.printStackTrace();
}
catch(SQLException e){
e.printStackTrace();
}
return catalog;
}

PROGRAMACION BASICA EN JAVA - 144