1 Introducción al Desarrollo el'.

l Lenguaje Java
 Indice

La tecnología Java ..................................................................................................... 1

El lenguaje de programación Java ........................................................................... 1
La plataforma Java ................................................................................................. 1
Tipos de programas en Java ................................................................................... 2
Compilación y ejecución de programas Java ............................................................ 2
Creación de aplicaciones con el JDK ........................................................................ 5
Creación de applets con el JDK ............................................................................... 7
Sintaxis de Java ..................................................................................................... 9
Comentarios ........................................................................................................ 10
Palabras clave ...................................................................................................... 11
Literales .............................................................................................................. 11
Expresiones y Operadores .................................................................................... 12
Variables y tipos de datos ..................................................................................... 14
Bloques y sentencias ............................................................................................ 16
Arreglos (Arrays) .................................................................................................. 19
Conceptos de la Programación Orientada a Objetos (OOP) ........................................ 21
Objeto ..........................................................................................................,. ...... 21
Clase ................................................................................................................... 21
Mensajes y métodos ............................................................................................. 22
r ---, Encapsulamiento .................................................................................................. 22
Herencia ....................................................................... : ...................................... 23
Polimorfismo ........................................................................................................ 24
Abstracción .......................................................................................................... 24
Trabajando con clases y objetos en Java .................................................................. 25
Definición de clases .............................................................................................. 25
Declaración de variables de instancia .................................................................... 25
Implementación de métodos ................................................................................. 25
Constructores y creación de objetos ...................................................................... 26
El operador new .................................................................................................. 27
Escribir un Método finalize() ................................................................................. 28
Acceso a variables y métodos ............................................................................... 29
Variables y métodos de clase ................................................................................ 31
Heredando clases en Java .................................................................................... 34
Sobrecarga de métodos y de constructores ........................................................... 34
Sobre escritura de métodos ............................................................ : ..................... ;36
La referencia this ................................................................................................. 37
La referencia null ................................................................................................. 37
Clases abstractas ................................................................................................. 38
Interfaces ............................................................................................................ 38
Paquetes y Modificadores de acceso ......................................................................... 39
Paquetes ............................................................................................................. 39
Control de acceso a miembros de una clase ........................................................... 43
Excepciones ......... :.................................................................................................. 44
try ... catch ... finally ................................................................................................ 44
Clase Exception ................................................................................................... 45
Capturar excepciones ........................................................................................... 46
Jerarquía de las excepciones ................................................................................. 46

2
 La tecnología Java

La tecnología Java consta de un lenguaje de programación y una plataforma.

El lenguaje de programación Java

Java es un lenguaje de programación de alto nivel que tiene las siguientes características:

Orientado a objetos
Distribuido y dinámico
Robusto
Seguro
Multitarea
Porta ble

La mayoría de los lenguajes de programación se caracterizan poi ser interpretados o

compilados, lo que determina la manera en como serán ejecutados en una computadora.

Java tiene la característica de ser al mismo tiempo compilado e interpretado. El compilador

es el encargado de convertir el código fuente de un programa en un código intermedio
llamado bytecode que es independiente de la plataforma en que se trabaje y que es
ejecutado por el intérprete de Java que forma parte de la Máquina Virtual de Java.

Compilación y ejecución de programas en Java.

ArchivoJava
Arch1vo.class
1 ¡__,....(compilador)__,.,.. Byrecode

Intérprete Intérprete Intérprete

Código
fuente

Macos

La plataforma Java

Una plataforma es el ambiente de hardware o software en el cual se ejecutan los

programas. En general, la mayoría de las plataformas pueden ser descritas como una
combinación de hardware y sistema operativo. Algunas de las plataformas más populares
son Windows, Solaris, Linux y Macos.

1
La plataforma Java difiere de las anteriores en que ésta es una plataforma basada
únicamente en software que corre por encima de las plataformas basadas en hardware.

La plataforma Java consta de dos componentes:

La Máquina Virtual de Java (JVM)

La Interfaz de Programación de Aplicaciones de Java (API Java)

A continuación se muestra una representación de los elementos que forman parte de la
plataforma Java.

Programas Java 1'-

API java 1

Maquma Vnt:ual de Java ,

' ...._ Platafmma
-.....-- Java
Plataf onnas de hardware I~

'
.. ,,

Tipos de programas en Java

Los programas en Java suelen estar en una de las siguientes categorías:

Applets

Los applets son pequeños programas que se incorporan en una página Web y que por lo
tanto, necesitan de un Navegador Web compatible con Java para poder ejecutarse. A
menudo los applets se descargan junto con una página HTML desde un Servidor Web y se
ejecutan en la máquina cliente.

Aplicaciones

Las aplicaciones son programas standalone de propósito general que normalmente se

ejecutan desde la línea de comandos del sistema operativo. Con Java se puede realizar
cualquier programa que normalmente se crearía con algún otro lenguaje de programación.

Servlets

Los servlets al contrario de los applets son programas que están pensados para trabajar
en el lado del servidor y desarrollar aplicaciones Web que interactúen con los clientes. Los
servlets son una alternativa de la programación CGI tradicional.

Compilación y ejecución de programas Java

El Kit de desarrollo de Java (JDK) contiene las herramientas y librerías necesarias para
crear y ejecutar applets y aplicaciones en Java.

2
A continuación se listas algunas de las utilidades que se pueden encontrar en el JDK:

javac. Es el compilador de Java. Se encarga de convertir el código fuente escrito en Java

a bytecode.

java. Es el intérprete de Java. Ejecuta el bytecode a partir de los archivos class.

appletviewer. Es un visor de applets. En la mayoría de las ocasiones puede utilizarse en

lugar de un Navegador Web.

javadoc. Se utiliza para crear documentación en formato HTML a partir de el código

fuente Java y los comentarios que contiene.

javap. Es un desensamblador de Java.

jar. Es una herramienta utilizada para trabajar con los archivos JAR.

Obtención del JDK

El JDK se puede obtener directamente de forma gratuita del sitio Web de JavaSoft,
http://java.sun.com/ . ·

Instalación y configuración del JDK (Windows 9x)

El JDK normalmente se distribuye en archivos de instalación auto-extraibles, por lo que al

momento de llevar a cabo la instalación, básicamente se tiene que indicar el directorio en
el cual se colocarán los archivos y directorios que se distribuyen en el JDK.

Una vez instalado el JDK se tiene que actualizar la variable de ambiente PATH y crear una
nueva variable llamada CLASSPATH.

Por ejemplo, si el JDK fue instalado en C:\jdkl.1.8, hacemos lo siguiente:

set PATH=C:\jdkl.1.8\bin;%PATH%
set CLASSPATH=C:\jdkl.1.8\lib\classes.zip;.

Por ejemplo, si se instaló una versión de Java 2 (JDK 1.2 o posterior), hacemos lo
siguiente:

set PATH=C:\jdk1.2.2\bin;%PATH%
set CLASSPATH=C:\jdkl.2.2\jre\lib;.

La variable de ambiente CLASSPATH le dice a la Máquina Virtual de Java y otras

aplicaciones de Java en donde buscar las clases que se necesitan para ejecutar un
programa, tal como el archivo classes.zip, que contiene una librería de clases que
conforma el API de Java. En Java 2 por lo general, no existe el archivo classes.zip por lo

3
 que sólo se hace referencia al directorio jre\lib.

Es necesario actualizar la variable PATH para que el sistema operativo sepa en donde
encontrar los programas que se ejecutan cuando se trabaja con Java ,básicamente el
compilador y el intérprete de Java, javac y java, respectivamente.

Uso del JDK para construir aplicaciones

Editor de texto

Código fvente Javadoc

NombreArchivo.jovo
Archivo de
Docurrentación
HTML
Compilador
---~--

Bytecode
NombreArchivo.closs

/
Intérprete
------ Java
Salida del
programa

Uso del JDK para construir applets

Ed 1tor de tex ID

Código fvente
NombreArchrvo.jovo
-- Javadoc

Archivo de
Docurrentación
HTML
Compilador

Intérprete
Bytecode Salida del
NombreArchivo.closs Navegador
Web programa

Archí\lo HTML en
Editor de texto donde se inclvye al
applet

4
Creación de aplicaciones con el JDK

A continuación se describe de manera gráfica cuales son los pasos a seguir para construir
una aplicación Java usando el JDK.

Editar el archivo con el código fuente

A AppHolaMundo.1ava
~ . . ·Bloc .de notas~ ''"
1 ,,
"I'¡.¡}•. "'h' .,,,.4 '
'"'~"::i;'

1
"
-=-
•.• Clll!!l~i

Todas las aplicaciones ,~..

class AppHolaMundo{ deben de tener el método maiií
"':liit
public static uoid main(String args[]){ f~
System.out .pdntln("'Hola Mundo");
}
}

Guardar el archivo
Guarda• como ~ · ,, ~, _"-::; • ' . ·;¡¡a

El nombre del archivo

debe de ser el mismo El nombre del archivo
que el de la clase debe de tener la
extensión java Debe de ser un
archivo de texto

5
Compilar y ejecutar el programa

C: \curso java \e lasses>d1 r

<D!R> 03108100 2:44a .
<D!R> 03/08/00 2: 44• ••
APPHOL"l JAV 133 03108/00 1:23a AppHolaHundo.ja'a
1 archi\los 133 bytes
2 director 1os 50 314,10 HB libros
C: \curso _ja1,1a\c lasses> j a1,1ac AppHo laHundo.J a1,1a El archivo (en bytecode)
C: \curso _,.1a1,1a\c lasses>d1 r generado después de la
compilación
<DIR> 03108/00 2: 44a .
<DIR> 03108/00 2:44a ..
APPHOL "1 JAV 133 03108100 1:23a AppHolaHundo.java
APPHOL "1 CLA 428 03108/00 2:58a AppHolaHundo.class
2 archivos 561 bytes
2 director 1os 5,314,69 HB libros
C: \curso _1a1,1a\c lasses>Java AppHolaHundo
Hola Hundo
C:\cursojava\classes>.

class AppHolaMundo{
protected String nombre;

void 1mpr1meMensaje(Str1ng var){

System.out.println("Clase padre "+var);

public static void main(String args[])\

try{
int var = Integer.parselnt(args[OJ);
System.out.println{"El valor es: "+ var);
AppHolaMundo obj = new AppHolaMundo();

catch(Exception e){
System.out.println("Ocurrio la sig excepcion: "+ e.toString() +"\n");
e.printStackTrace();

6
Creación de applets con el JDK.
A continuación se describe de forma gráfica cuales son los pasos básicos para crear
applets utilizando el JDK.

Editar el archivo con el código fuente del applet

4¡Apple1HolaMundo java· Bloc de notas 1 ; ,if~i ,\ kli;fl¡c]R~Ei

import jaua.applet.•;
import jaua.awt.*;
Los applets son subclases de .. D
la clase Applet [:$
public class AppletHolaMundo extends Applet {
public uoid paint(Graphics g)
g.drawString("Hola Mundo", so. 25);

Guardar el archivo

Guardar como • "' ~ , ;. • , ' .lilE3

:: G~a1dar e~ J E5I classes

El nombre del archivo

debe de ser el mismo El nombre del archivo
que el de la clase debe de tener la

~
exte.,':"º_.J>siónjava Debe de ser un
archivo de texto
A

'H~re de archivo: IAppletHolaMundo ¡ava .~~:='.] .;lriau"d". l

Guisrdar C.QffiO
_archivos de tipo·
'
:;. , ~,
:•11 · 11:•Can.ie1.,
. :: ••
J.
~~~~~~~~~~~~~~~~~~~~~~~"

e: \curso_J ª"ª\e lasses>d lf

<DIR> 113108100 2:44a •
<DIR> 113108/DD 2: 44a ..
APPHDL "1 JAY 133 ll3/(JS/DD 1:23a AppHolaHundo.Ja\la
APPHOL "1 CLA 428 03/08/00 2:58.a AppHolaHundo.class
APPLErl JAY 235 03/()8/(J(J 3:56.a AppletHolaHundo.Ja\la
3 archi\los 796 bytes
2 dLrectouos 5,3()6,67 HB libres
C: \cursoja11a\classes> Jd\lac ffppletHo laHundo.Ja11a
e: \curso _I a11a\e lasses>d l r El archivo (en bytecodel
<DIR> 03/08/00 2:44a • generado después de la
<DIR> 03/0B/DD 2:44a .. compilación
APPHOL"l JAY 133 03/08100 1:23a AppHolaHundo.ja\l<i
APPHDL"l CLA 428 03/08/00 2:58a AppHolaHundo.cl<iss A./}
APPLErl JAY 235 03/08/00 3:56a AppletHolaHundo.JaYa f.X"
APPLET'l CLA 381J 03/08/IJIJ 3:57a AppletHolaHundo.class
4 arch111os 1,176 bytes
2 dLrectouos 5,294,66 HB libres
C: \curso_1a11a\classes>

7
Editar el archivo HTML que incluirá el applet

.@l mi_primer_applet:hlml -"Bloc de rioías- :· : , ' 'l!!iiil~Eil

Archivo .Edición _auscar Ayyda -
l<HTML> '~
....,
<HEAD> Se utiliza la etiqueta «¡
<TITLE>Mi primer applet</TITLE> APPLET para incluir ' N
(/HEAD> un applet en una ""'
<BODY> página HTML
Aquí está la salida del programa
<BR> ._/,)
<APPLET CODE="AppletHolaMundo .class" f:X'
WIDTH=150 HEIGHT=~5>
<!APPLET>
(/BODY> ~

~~;;.-~~~~;:~~~~
Guardar el archivo HTML

Guardar como -- - - - ·" · :;"> ,. , .liJEi

El archivo que contiene

el applet puede tener
cualquier nombre con la
. ~-~ extensión html (ó htm),

;.:,M~~bie tje ar~biJq·';jmi_pr1mer_applet html , , 11 '§.uaídar~~J·

/2,~~:~~~ ~~~~~· ! :hs;3ü~~Ü~c:~·~~~: ,!;,,!h •. ~~~c.elar. :k

Abrir el archivo HTML con un navegador (Netscape)

*Miprimerapplel-Nelicape , ' , ",, 1

,: •; 'li!li~Eij

,,. . .,,,.,, .. '!,., .. _,.

Aquí está la sahda del p·r.,o~ama

. Hola Mundo .

'

8
Abrir el archivo HTML con un navegador (Explorer)

tll Mi primer applet ·Microsoft lnterÍ1et Explórer'pioPorCiil~ado··:.. ~Rlilfl3l

//AppletHolaMundo.java
import java.applet.*;
import java.awt.*;

public class AppletHolaMundo extends Applet

public void paint(Graphics g)' {

g.drawString("Hola Mundo", 50, 25);

<HTML>
<HEAD>
<TITLE>Mi primer applei</TITLE>
</HEAD>
<BODY>
Aqui está la salida del programa
<BR>
<APPLET CODE="AppletHolaMundo.class"
WIDTH=150 HEIGHT=45>
</APPLET>
</BODY>
</HTML>
mi_primer_applet.html

Sintaxis de Java
La sintaxis de un lenguaje define cómo se usarán las palabras claves, los operadores y las
variables para construir y evaluar expresiones. La sintaxis de Java especifica como se
escribirán los siguientes elementos:
Comentarios.
Identificadores.
Palabras clave.
Literales.
Expresiones y operadores.
Variables y tipos de datos.
Bloques y sentencias.

9
Comentarios

Java ofrece tres tipos de comentarios: dos para comentarios regulares en el código fuente
y uno para la documentación especial del sistema javadoc.
Comentarios de varias líneas.

Los comentarios de varias líneas se incluyen entre los símbolos/* y*/, como en C y C++.

/*
Este es un ejemplo de
un comentario de varias
líneas.
*/
Comentarios de una sola línea.

Para comentariar una sola línea se utiliza la doble diagonal //. El comentario se inicia
cuando se encuentra la doble diagonal y continua hasta el final de la línea.
// Este es un comentario de una sola linea
//Este es otro comentario

Comentarios para documentación.

Realmente este tipo de comentario es el mismo que el de varias líneas con la diferencia de
que la información que contenga será usada para un procesamiento especial que lleva a
cabo la herramienta javadoc.

Se distingue del comentario de varias líneas porque se agrega un asterisco adicional al

inicio del comentario.

/**
Este tipo de comentarios
los utiliza la
herramienta javadoc
*/
Identificadores

Un identificador es una secuencia de caracteres comenzando por una letra y conteniendo

letras y números. Los identificadores no se limitan a los caracteres ASCII, si el editor de
texto lo soporta, se pueden escribir identificadores utilizando caracteres Unicode.

Las letras Java incluyen los caracteres ASCII A-Z y a-z. Los digitos Java incluyen los digitos
ASCII 0-9. Para propósitos de construir identificadores, los caracteres ASCII $ y _ son
también considerados letras Java.
No hay un límite en lo concerniente al número de caracteres que pueden tener los
identificadores.

10
Estos son algunos ejemplos de identificadores válidos:
_varx $varl MAX_NUM var2

Palabras clave
La siguiente tabla muestra las palabras claves de Java, éstas son reservadas y no pueden
ser utilizadas como identificadores.

abstract default if private this

boolean do implements protected throw
break double import public throws
byte else instanceof return transient
case extends int short try
catch final interface static void
ch ar finally long strictfp** volatile
class float native super while
const* for new switch
continue goto* package synchronized

*"Son palabras claves de Java que no son usadas actualmente.

** Palabra clave agregada en Java 2

true, false, and null no son palabras claves pero son palabras reservadas, así que
tampoco pueden ser utilizadas como identificadores.
Literales
Una literal es un valor constante formado por una secuencia de caracteres. Cualquier
declaración en Java que defina un valor constante -un valor que no pueda ser cambiado,
durante la ejecución del programa- es una literal.

Son ejemplos de literales los números, los caracteres y las cadenas de caracteres.
Literales numéricas
Se pueden crear literales numéricas a partir de cualquier tipo de dato primitivo.
Ej.
123 //literal int
123.456 //literal double
123L //literal long
123.456F //literal float
Literales booleanas
Las literales boolenas consisten de las palabras reservadas true y false.
Literales de caracteres

11
Las literales de caracteres se expresan por un solo caracter entre comillas sencillas
10
Ej. 'a1, /o', '7'

Literales de cadena

Una cadena es una combinación de caracteres. Las cadenas en Java son instancias de la
clase String, por ello cuentan con métodos que permiten combinar, probar y modificar
cadenas con facilidad.
Las literales de cadena se representan por una secuencia de caracteres entre comillas
dobles.
Ej. "hola", "cadena123", "12345"

Expresiones y Operadores
Expresión
Una expresión es una combinación de variables, operadores y llamadas de métodos
construida de acuerdo a la sintaxis del lenguaje que devuelve un valor.

El tipo de dato del valor regresado por una expresión depende de los elementos usados en
la expresión.
Operadores
Los operadores son símbolos especiales que por lo común se utilizan en expresiones.
La tabla siguiente muestra los distintos tipos de operadores que utiliza Java.

Operador Significado Ejemplo

Operadores aritméticos

+ Suma a+b

Resta a-b

* Multiplicación a*b

/ División a/b

% Módulo a%b

Operadores de asignación

= Asignación a= b

+= Suma y asignación a+= b (a=a + b)

= Resta y asignación a-= b (a=a - b)

*= Multiplicación y asignación a*= b (a=a * b)

/= División y asignación a / b ( a=;a / b)

12
%= Módulo y asignación a% b (a=a % b)

Operadores relacionales

-- Igualdad a== b

!= Distinto a!= b

< Menor que a<b

> Mayor que a>b

<= Menor o igual que a<= b

>= Mayor o igual que a>= b

Operadores especiales

++ Incremento a++ (postincremento)

++a (preincremento)

Decremento a-- (postdecremento)

--a (predecremento)

(tipo)expr Cast a = (int) b

+ Concatenación de cadenas a = "cadl" + "cad2"

Acceso a variables y métodos a = obj.varl

() Agrupación de expresiones a = (a + b) *c

La tabla siguiente muestra la precedencia asignada a los operadores, éstos son listados en
orden de precedencia.

Los operadores en la misma fila tienen igual precedencia.

Operador Notas

. [] o Los corchetes se utilizan para los

arreglos

++ -- ! es el NOT lógico y ~ es el
complemento de bits

new (tipo )expr new se utiliza para crear instancias de

clases

13
* / % Multiplicativos

+- Aditivos

<< >> >>> Corrimiento de bits

< > <= >= Relacionales

-- != Igualdad

& AN D (entre bits)

/\
OR exclusivo (entre bits)

1 OR inclusivo (entre bits)

&& AND lógico

11 OR lógico

?: Condicional

= += -= *= /= %= &= "= 1= <<= Asignación

>>= >>>=

Todos los operadores binarios que tienen la misma prioridad (excepto los operadores de
asignación) son evaluados de izquierda a derecha.

Los operadores de asignación son evaluados de derecha a izquierda.

Variables y tipos de datos

Las variables son localidades de memoria en las que pueden almacenarse datos. Cada una
tiene un nombre, un tipo y valor. Java tiene tres tipos de variables: de instancia, de clase
y locales.

Variables de instancia.

Se utilizan para definir los atributos de un objeto.

Variables de clase.

Son similares a las variables de instancia, con la excepción de que sus valores son los
mismos para todas las instancias de la clase.

Variable locales.

Se declaran y se utilizan dentro de las definiciones de los métodos.

* A diferencia de otros lenguajes, Java no tiene variables globales, es decir , variables que

14
son vistas en cualquier parte del programa.

Java es un lenguaje "fuertemente tipeado o tipificado" por lo que es necesario especificar

el tipo de dato para cada una de las variables que se vayan a utilizar en un programa. El
nombre de la variable debe de ser un identificador válido, y se usa para referirse a los
datos que contiene una variable.

El tipo de una variable determina los valores que puede almacenar y las operaciones que
se pueden hacer sobre ella. Para dar a una variable un tipo y un nombre, se escribe una
declaración de una variable, que tiene la siguiente forma:
TipoDato nombreVariable;

String nombre; //variable de tipo String

int edad; / / variable de tipo int
Punto p; //variable del tipo Punto

Se pueden escribir varios nombres de variables del mismo tipo en una sola línea
int x, y, z;
String nombre, apellido;

También se puede asignar un valor inicial a las variables al momento de crearlas

String nombre, apell1do="M1Apell1do";
int edad "" 24;

Las variables en Java pueden ser uno de los siguientes tipos:

Tipo primitivo.
Una variable de tipo primitivo contiene un solo valor del tamaño y formato apropiado de
su tipo: un número, un carácter, o un valor booleano.

La tabla siguiente lista los tipos de datos primitivos soportados por Java.

Tipo Descripción Tamaño/Formato

Números enteros

byte Entero byte 8-bit 2's

short Entero corto 16-bit 2's

int Entero 32-bit 2's

long Entero largo 64-bit 2's

Números reales

float Punto flotante 32-bit IEEE 754

double Punto flotante de doble presición 64-bit IEEE 754

Otros tipos

15
char Un solo carácter 16-bit caracteres Unicode

boolean Un valor booleano true o false

En Java, cualquier numérico con punto flotante automáticamente se considera double.

Para que sea considerado float se agrega una letra "f' o "F" al final del valor.

double d = 10.50;
float f = 10 SOF;

Referencia.
Los arreglos, las clases y las interfaces son del tipo referencia. El valor de una variable del
tipo referencia es una dirección de un conjunto de valores representados por una variable.

Las referencias en Java no son como en C++, éstas son identificadores de instancias de
alguna clase en particular.

String cad; //referencia a un objeto de la clase String

Punto p; //referencia a un objeto de la clase Punto
int[] var_arreglo; //referencia a un arreglo de enteros

Bloques y sentencias

Sentencia

Una instrucción o sentencia representa la tarea más sencilla que sé puede realizar en un
programa.
Sentencias de expresión
Los siguientes tipos de expresiones pueden ser hechas dentro de una sentencia
terminando la expresión con punto y coma (;):

* Expresiones de asignación
* Cualquier uso de los operadores ++ y -
* Llamada de métodos
* Expresiones de creación de objetos
Esta clase de sentencias son llamadas sentencias de expresión.

valorA = 8 933. 2 34; 11 asignación

valorA++; // incremento
System.out.println(valorA}; //llamada a un método
Integer objint = new Integer(4); //creación de objetos

Sentencias de declaración de variables

Las sentencias de declaración de variables se utilizan para declarar variables.
int bValue;

16
 double avalue = 8933.234;
String varead;

Sentencias de control de flujo

Las sentencias de control de flujo determinan el orden en el cual serán ejecutadas otro
grupo de sentencias. Las sentencias if y for son ejemplos de sentencias de control de
flujo.

Bloque de sentencias

Un bloque es un grupo de cero o más sentencias encerradas entre llaves ( { y } ). Se

puede poner un bloque de sentencias en cualquier lugar en donde se pueda poner una
sentencia individual.·
Las sentencias de control de flujo se pueden utilizar para ejecutar sentencias
condicionalmente, para ejecutar de manera repetida un bloque de sentencias y en general
para cambiar la secuencia normal de un programa.
La sentencia if

La sentencia if permite llevar a cabo la ejecución condicional de sentencias.

if ( Expresion ){
sentencias;

Se ejecutan las sentencias si al evaluar la expresión se obtiene un valor

booleano true.
if ( Expresion l {
sentenciasA;
1
else{
sentenciasB;

Si al evaluar la expresión se obtiene un valor booleano true se ejecutarán las sentenciasA,

en caso contrario se ejecutarán las sentenciasB.
La sentencia switch

Cuando se requiere comparar una variable con una serie de valores diferentes, puede
utilizarse la sentencia switch, en la que se indican los posibles valores que puede tomar
'
la variable y las sentencias que se tienen que ejecutar sí es que la variable coincide con
alguno de dichos valores.

switch( variable){
case valorl:
sentencias;
break;
case valor2:
sentencias;
break;

case valorN:
sentencias;
break;

17
 default:
sentencias;

Cada case ejecutará las sentencias correspondientes, con base en el valor de la variable,
que deberá de evaluarse con valores de tipo byte, char, short o int.
Si el valor de la variable no coincide con ningún valor, entonces se ejecutan las sentencias
por default, sí es que las hay.

La sentencia break al final de cada case transfiere el control al final de la sentencia

switch; de esta manera, cada vez que se ejecuta un case todos los enunciados case
restantes son ignorados y termina la operación del switch.
El ciclo for
El ciclo for repite una sentencia, o un bloque de sentencias, mientras una condicion se
cumpla. Se utiliza la mayoría de las veces cuando se desea repetir una sentencia un
determinado número de veces.
La forma general de la sentencia for es la siguiente;

for(inicialización;condición;incremento) {
sentencias;
1
* En su forma más simple, la inicialización es una sentencia de asignación que se utiliza
para establecer una variable que controle el ciclo.
* La condición es una expresión que comprueba la variable que controla el ciclo y
determinar cuando salir del ciclo.
* El incremento define la manera en como cambia la variable que controla el ciclo.
Los ciclos while y do-while, al igual que los ciclos far repiten la ejecución de un bloque
de sentencias mientras se cumpla una condición específica.

La sentencia while

El formato de la sentencia while es la siguiente:

while (condición){
sentencias;

La condición es una condición booleana, que mientras tenga el valor true permite que se
ejecuten las sentencias correspondientes.

La sentencia do-while

Al contrario de los ciclos far y while que comprueban una condición en lo alto del cido, el
ciclo do-while la examina en la parte más baja del mismo. Esta característica provoca
que un ciclo do-while siempre se ejecute por lo menos una vez.

El formato de la sentenda do-while es el siguiente:

do)
sentencias;
}while (condición);

18
break

La sentencia break. tiene dos usos. El primer uso es terminar un case en la sentencia
switch. El segundo es forzar la terminación inmediata de un ciclo, saltando la prueba
condicional normal del ciclo.

continue

La sentencia continue es similar a la sentencia break. Sin embargo, en vez de forzar la

terminación del ciclo, continue forza la siguiente iteración y salta cualquier código entre
medias.

return

Se utiliza la sentencia return para provocar la salida del método actual; es decir, return
provocará que el programa vuelva al código que llamó al método.

La sentencia return puede regresar o no un valor. Para devolver un valor; se pone el valor
después de la palabra clave return.
return valor;

El tipo de dato del valor regresado debe ser el mismo que el que se especifica en la
declaración del método.

Cuando un método es declarado void, el método no regresa ningún valor.

return;

Arreglos (Arrays)

Declaración y acceso

Un array es una colección ordenada de elementos del mismo tipo, que son accesibles a
través de un índice. Un array puede contener datos primitivos o referencias a objetos.
Los arrays se declaran:
[modificadores] tipo_ variable []nombre;
Por ejemplo:
int [ ] a;
Punto [ ) p;

La declaración dice que a es un array de enteros y p un array de objetos de tipo Punto.

Más exactamente a es una referencia a una colección de enteros, aunque todavía no se
sabe cuantos elementos tiene el array. p es una referencia a una colección de referencias
que apuntarán objetos Punto.

19
Un array se crea como si se tratara de un objeto (de hecho las variables de tipo array son
referencias):

a= new int [5];

p = new Punto[3];

En el momento de la creación del array se dimensiona el mismo y se reserva la memoria

necesaria.

También puede crearse de forma explícita asignando valores a todos los elementos del
array en el momento de la declaración, de la siguiente forma:
int [ ] a = { 5 , 3 , 2 ) ;

El acceso a los elementos del array se realiza indicando entre corchetes el elemento del
array que se desea, teniendo en cuenta que siempre el primer elemento del array es el
índice O. Por ejemplo a [ l J • En este ejemplo los índices del array de tres elementos son
O, 1 y 2. Si se intenta usar un índice que está fuera del rango válido para ese array se
produce un error (en realidad una excepción. Las excepciones se tratan en un capítulo
posterior) de 'Indice fuera de rango'. En el ejemplo anterior se produce esta excepción si
el índice es menor que O o mayor que 2.
Se puede conocer el número de elementos de un array usando la variable length. En el
ejemplo a. length contiene el valor 3.
Un array, como cualquier otra referencia puede formar parte de la lista de parámetros o
constituir el valor de retorno de un método. En ambos casos se indica que se trata de un
array con los corchetes que siguen al tipo. Por ejemplo:

String [ ] metodoConArrays ( Punto [ ] ) { . . }

El método metodoConArrays recibe como parámetro un array de Puntos y devuelve un

array de Strings. El método podría invocarse de la siguiente forma:

Punto p [ ] = new Punto [3];

String [ J resultado= metodoConArrays(p);

Arreglos multidimensionales

Es posible declarar arrays de más de una dimensión. Los conceptos son los mismos que
para los arrays monodimensionales.

Por ejemplo:
int [ ) [ ] a = i { 1 , 2 } , \ 3 , 4 } , { 5 , 6 } };

int x = a[l] [O]; // contiene 3

int y"' a[2] [l]: // contiene 6

Se pueden recorrer los elementos de un array multidimensional, de la siguiente forma:

20
int [ ] [ ] a = new int [3] [2];

for ( int i = O ; i < a.length ; i++ )

for ( int J = O ; J < a[i) .length ; j++)
a[i][J]=i*J;

Obsérvese en el ejemplo la forma de acceder al tamaño de cada dimensión del array.

Conceptos de la Programación Orientada a Objetos (OOP).

Objeto

Un objeto es una encapsulación genérica de datos y de los procedimientos para

manipularlos.

Al igual que los objetos del mundo real, los objetos de software tienen un estado y un
comportamiento. El estado de los objetos se determina a partir de una o más variables y
el comportamiento con la implementación de métodos.

La siguiente figura muestra la representación cómun de los objetos de software

Vanables
Métodos (Estado)
(Comportamiento)

Como se observa en la figura, todos los objetos tienen una parte pública (su
comportamiento) y una parte privada (su estado). En este caso, hicimos una vista
transversal pero desde el mundo exterior, el objeto se observará como una esfera.

Clase.
Una clase está formada por los métodos y las variables que definen las características
cómunes a todos los -objetos de esa clase. Precisamente la clave de la OOP está en
abstraer los métodos y los datos comunes a un conjunto de objetos y almacenarlos en una
clase.

Una clase equivale a la generalización de un tipo específico de objetos. Una instancia es la

concreción de una clase.
Clase X

21
 M@
\U) . ObJetoA
Objeto B

En la figura anterior, .el objeto A y el objeto B son instancias de la clase X.

Cada uno de los objetos tiene su propia copia de las variables. definidas en la clase de la
cual son instanciados y comparten la misma implementación de los métodos.

Mensajes y métodos
El modelado de objetos no sólo tiene en consideración los objetos de un sistema, sino
también sus interrelaciones.
Mensaje
Los objetos interactúan enviándose mensajes unos a otros. Tras la recepción de un
mensaje el objeto actuará. La acción puede ser el envío de otros mensajes, el cambio de
su estado, o la ejecución de cualquier otra tarea que se requiera que haga el objeto.
Método
· Un método se implementa en una clase, y determina cómo tiene que actuar el objeto
cuando recibe un mensaje.
Cuando un objeto A necesita que el objeto B ejecute alguno de sus métodos, el objeto A
le manda un mensaje al objeto B.
MensaJe

Objeto A
Objeto B
Al recibir el mensaje del objeto A, el objeto B ejecutará el método adecuado para el
mensaje recibido.

Encapsulamiento

Como se puede observar de los diagramas, las variables del objeto se localizan en el
centro o núcleo del objeto. Los métodos rodean y esconden el núcleo del objeto de otros
objetos en el programa. Al empaquetamiento de las variables de un objeto con la
protección de sus métodos se le llama encapsulamiento. Típicamente, el encapsulamiento
es utilizado para esconder detalles de la puesta en práctica no importantes de otros
objetos. Entonces, los detalles de la puesta en práctica pueden cambiar en cualquier
tiempo sin afectar otras partes del programa.
El encapsulamiento de variables y métodos en un componente de software ordenado es,

22
todavía, una simple idea poderosa que provee dos principales beneficios a los
desarrolladores de software:
Modularidad, esto es, el código fuente de un objeto puede ser escrito, así como darle
mantenimiento, independientemente del código fuente de otros objetos. Así mismo, un
objeto puede ser transferido alrededor del sistema sin alterar su estado y conducta.
Ocultamiento de la información, es decir, un objeto tiene una "interfaz publica" que otros
objetos pueden utilizar para comunicarse con él. Pero el objeto puede mantener
información y métodos privados que pueden ser cambiados en cualquier tiempo sin
afectar a Jos otros objetos que dependan de ello.
Los objetos proveen el beneficio de Ja modularidad y el ocultamiento de la información.
Las clases proveen el beneficio de Ja reutilización. Los programadores de software utilizan
la misma clase, y por lo tanto el mismo código, una y otra vez para crear muchos objetos.
En las implantaciones orientadas a objetos se percibe un objeto como un paquete de
datos y procedimientos que se pueden llevar a cabo con estos datos. Esto encapsula los
datos y Jos procedimientos. La realidad es diferente: Jos atributos se relacionan al objeto o
instancia y Jos métodos a Ja clase. lPor qué se hace así? Los atributos son variables
comunes en cada objeto de una clase y cada uno de ellos puede tener un valor asociado,
para cada variable, diferente al que tienen para esa misma variable Jos demás objetos. Los
métodos, por su parte, pertenecen a Ja clase y no se almacenan en cada objeto, puesto
que sería un desperdicio almacenar el mismo procedimiento varias veces y ello va contra
el principio de reutilización de código.

Herencia
La herencia es un mecanismo que permite Ja definición de una clase a partir de Ja
definición de otra ya existente. La herencia permite compartir automáticamente métodos y
datos entre clases, subclases y objetos.
La herencia está fuertemente lig'ada a Ja reutilización del código en Ja OOP. Esto es, el
código de cualquiera de las clases puede ser utilizado sin más que crear una clase
derivada de ella, o bien una subclase.
Hay dos tipos de herencia: Herencia Simple y Herencia Múltiple. La primera indica que se
pueden definir nuevas clases solamente a partir de una clase inicial mientras que la
segunda indica que se pueden definir nuevas clases a partir de dos o más clases iniciales.

Java sólo permite herencia simple.

Superclase y Subclases
El concepto de herencia conduce a una estructura jerárquica de clases o estructura de
árbol, Jo cual significa que en Ja OOP todas las relaciones entre clases deben ajustarse a
dicha · estructura.

En esta estructura jerárquica, cada clase tiene sólo una clase padre. La clase padre de
cualquier clase es conocida como su superclase. La clase hija de una superclase es
llamada una subclase.

* Una superclase puede tener cualquier número de subclases.

* Una subclase puede tener sólo una superclase.

23
 Clase A

A es la superclase de B, C y D.
D es la superclase de E.
B, C y D son subclases de A.
Clase B Clase C
E es una subclase de D.

Clase E
Polimorfismo
Otro concepto de la OOP es el polimorfismo. Un objeto solamente tiene una forma (la que
se le asigna cuando se construye ese objeto) pero la referencia a objeto es polimórfica
porque puede referirse a objetos de diferentes clases (es decir, la referencia toma
múltiples formas). Para que esto sea posible debe haber una relación de herencia
entre esas clases.

Por ejemplo, considerando la figura anterior de herencia se tiene que:

Una referencia a un objeto de la clase B también puede ser una referencia a un objeto de
la clase A.
Una referencia a un objeto de la clase C también puede ser una referencia a un objeto de
la clase A.
Una referencia a un objeto de la clase D también puede ser una referencia a un objeto de
la clase A.
Una referencia a un objeto de la clase E también puede ser una referencia a un objeto de
la clase D.
Una referencia a un objeto de la clase E también puede ser una referencia a un objeto de
la clase A.

Abstracción

Volviendo a la figura anterior de la relación de herencia entre clases, se puede pensar en

una jerarquía de clase como la definición de conceptos demasiado abstractos en lo alto de
la jerarquía y esas ideas se convierten en algo más concreto conforme se desciende por la
cadena de la superclase.
Sin embargo, las clases hijas no están limitadas al estado y conducta provistos por sus
superclases; pueden agregar variables y métodos además de los que ya heredan de sus
clases padres. Las clases hijas pueden, también, sobreescribir los métodos que heredan
por implementaciones especializadas para esos métodos. De igual manera, no hay
limitación a un sólo nivel de herencia por lo que se tiene un árbol de herencia en el que se
puede heredar varios niveles hacia abajo y mientras más niveles descienda una clase, más
especializada será su conducta.

La herencia presenta los siguientes beneficios:

• Las subclases proveen conductas especializadas sobre la base de elementos

24
 comunes provistos· por la superclase. A través del uso de herencia, los
programadores pueden reutilizar el código de la superclase muchas veces.

• Los programadores pueden implementar superclases llamadas clases abstractas

que definen conductas "genéricas". Las superclases abstractas definen, y pueden
implementar parcialmente, la conducta pero gran parte de la clase no está definida
ni implementada. Otros programadores concluirán esos detalles con subclases
especializadas.

Trabajando con clases y objetos en Java

Definición de clases

La definición de una clase especifica cómo serán los objetos de dicha clase, esto es, de
que variables y de que métodos constarán.
La siguiente es la definición más simple de una clase:
class nombreClase /* Declaración de la clase */
{

/* Aquí va la definición de variables y métodos */

Como se puede observar, la definición de una clase consta de dos partes fundamentales:

* La declaración de la clase
Indica el nombre de la clase precedido por la palabra clave class.

* El cuerpo de la clase
El cuerpo de la clase sigue a la declaración de la clase y está contenido entre la pareja de
llaves ( { y }). El cuerpo de la clase contiene las declaraciones de las variables de la clase,
y también la declaración y la implementación de los métodos que operan sobre dichas
variables.

Declaración de variables de instancia

El estado de un objeto está representado por sus variables (variables de instancia). Las
variables de instancia se declaran dentro del cuerpo de la clase. Típicamente, las variables
de instancia se declaran antes de · la declaración de los métodos, pero esto no es
necesariamente requerido.

Implementación de métodos

Los métodos de una clase determinan los mensajes que un objeto puede recibir.

Las partes fundamentales de un método son el valor de retorno, el nombre, los

25
argumentos (opcionales) y su cuerpo. Además, un método puede llevar otros
modificadores opcionales que van al inicio de la declaración del método y que se
analizarán más adelante. La sintaxis de un método es la siguiente:

<otrosModificadores> valorRetorno nombreMetodo( <lista de argumentos> )

/* Cuerpo del método */

sentencias;

Los signos <> indican que no son obligatorios.

Los métodos en Java pueden ser creados únicamente como parte de una clase. Cuando se
llama a un método de un objeto se dice comúnmente que se envia un mensaje al objeto.

/* Usuario.Java */

class Usuario

String nombre;
int edad;
String direccion;

void setNombre(String n)
{
nombre = n,.

String getNombre()
{
return nombre;

vo1d setEdad{int e)
{
edad = e;

int getEdad {)
{
return edad;

void setDireccion(String d)
{
direccion = d;

String getDireccion{)
1
return direccion;

Constructores y creación de objetos.

Una vez que se tiene definida la clase a partir de la cual se crearán los objetos se está en
la posibilidad de instanciar los objetos requeridos.
Para la clase Usuario del ejemplo anterior podemos crear un objeto de la siguiente
manera:

26
 Usuario usrl; //usrl es una variable del tipo Usuario

usrl = new Usuario();

La primera línea corresponde a la declaración del objeto, es decir, se declara una variable
del tipo de objeto deseado.

La segunda línea corresponde a la iniciación del objeto.

El operador new

El operador new crea una instancia de una clase asignando la cantidad de memoria
necesaria de acuerdo al tipo de objeto. El operador new se utiliza en conjunto con un
constructor. El operador new regresa una referencia a un nuevo objeto.
Constructores
Un constructor es un tipo específico de método que siempre tiene el mismo nombre que la
clase, y que se utiliza cuando se desean crear objetos de dicha clase, es decir, se utiliza al
crear e iniciar un objeto de una clase.
Constructores múltiples
Cuando se declara una clase en Java, se pueden declarar uno o más constructores
(constructores múltiples) opcionales que realizan la iniciación cuando se instancia un
objeto de dicha clase.
Para la clase Usuario del ejemplo anterior no se especificó ningún constructor, sin
embargo, Java proporciona un constructor por omisión que inicia las variables del objeto a
sus valores predeterminados.
/* ProgUsuario.java */

class ProgUsuario
{
public static void main(String args[])
{
Usuario usrl, usr2; /* Se declaran dos objetos de la clase Usuario */
boolean si_no;

usrl = new Usuario(); /* Se utiliza el constructor por omisión */

si_no = usrl instanceof Usuario;

if(si no== true)

System.out.println("\nEl ob]eto usrl SI es instancia de Usuario.");
el se
System.out.println{"\nEl objeto usrl NO es instancia de Usuario.");

usr2 = usrl; /* usrl y usr2 son el mismo objeto */

si_no = usr2 instanceof Usuario;

if(si no== true)

System. out .println ("\nEl ob)eto usr2 SI es instancia de Usuario.");
el se
System.out.println("\nEl obJeto usr2 NO es instancia de Usuario.");

27
Escribir un Método finalize()

Antes de que un objeto sea recolectado por el recolector de basura, el sistema llama al
método finalize(). La intención de este método es liberar los recursos del sistema, como
Archivos o conexiones abiertas antes de empezar la recolección.

Una clase puede proporcionar esta finalización simplemente definiendo e implementando

un método llamado finalize(). El método finalize() debe declararse de la siguiente
forma.

protected void finalize () throws throwable

Esta clase abre un archivo cuando se construye.

class AbrirUnArchivo {
FileinputStream unArchivo = null;
AbrirUnArchivo (String nombreArchivo) {
try {
unArchivo = new FileinputStream(nombreArchivo);
) catch {java.10.FileNotFoundException e) {
System.err.println("No se pudo abrir el archivo " + nombreArchivo);
1

Para un buen comportamiento, la clase AbrirUnArchivo debería cerrar el archivo cuando

haya finalizado. Aquí tienes el método finalize() para la clase AbrirUnArchivo .

protected void finalize () throws throwable {

if (unArchivo != null) (
unArchivo.close();
unArchivo = null;

El método finalize() está declarado en la clase java.lang.Object. Así cuando escribas un

método finalize() para tus clases estás sobre escribiendo el de su superclase.

Si la superclase tiene un método finalize(), probablemente este método deberá llamar al

método finalize() de su superclase después de haber terminado sus tareas de limpieza.
Esto limpiará cualquier recurso obtenido sin saberlo a través de los métodos heredados
desde la superclase.

protected void finalize() throws Throwable {

11 aquí va el código de limpieza de esta clase

super.finalize(};

28
Acceso a variables y métodos
Una vez que se ha creado un objeto, seguramente se querrá hacer algo con él. Tal vez se
requiera 'obtener información de éste, se quiera cambiar su estado, o se necesite que
realice alguna tarea.

Los objetos tienen dos formas de hacer esto:

Manipular sus variables directamente ..

Para accesar a las variables de un objeto se utiliza el operador punto ( • ). La sintaxis es la

siguiente:
nombreObjeto.nombreVariable;

Llamar a sus métodos.

Para llamar a los métodos de un objeto, se utiliza también el operador punto ( . ). La

sintaxis es la siguiente:
nombreObjeto.nombreMetodo( <lista de argumentos opcionales> );

/* Usuario2.java */

class Usuario2

String nombre;
int edad;
String direccion;

Usuario2 ( ) /* Equivale al contructor por omisión */

l
nombre = nUll;
edad = O:
direccion = null;

Usuario2{String nombre, int edad, String d1recc1on)

l
this.nombre =nombre;
this.edad =edad;
this.d1recc1on = d1recc1on;

Usuario2(Usuario2 usr)
l
nombre= usr.getNombre();
edad= usr.getEdad();
d1recc1on = usr.getDireccion();

void setNornbre(String n)
l
nombre = n;

Str1ng getNombre()
l
return nombre;

29
 void setEdad(int e)
{
edad = e;

int getEdad ()
{
return edad;

void setDireccion(String d)
{
direccion = d;

String getDireccion()
{
return direccion;

/* Progüsuario2.java */

class ProgUsuario2

void imprimeUsuario(Usuario2 usr)

{
// usr.nombre equivale en este caso a usr.getNombre{)
System.out.println("\nNombre: " + usr.nombre ) ;
System.out.println("Edad: " + usr.getEdad{) ) :
System. out .println ( "Direccion: " + usr. getDireccion () +" \n");

public static void main{String args[])

{
ProgUsuario2 prog = new ProgUsuario2( );
Usuario2 usrl,usr2; /* Se declaran dos obJetos de la clase Usuario2 */

/* Se utiliza el constructor por omisión */

usrl = new Usuario2{ );
prog.imprimeUsuario(usrl);

/* Se utiliza el segundo constructor de Usuario2 */

usr2 = new Usuario2 ("Eduardo" ,24, "Mi direccion"J;
prog.imprimeUsuario(usr2);

/* Se utiliza el tercer constructor de Usuario2 */

usrl = new Usuario2(usr2);

/* En este caso usrl.setDireccion{"nuevoValor"}; equivale

a usrl. direccion = "nuevovalor"; *I
usrl. setDireccion ("Otra direccion");

prog.imprimeUsuario{usrl);
prog.imprimeUsuario{usr2);

30
Variables y métodos de clase
Variables de clase

Las variables de clase son variables cuyos valores son los mismos para la clase y para
todas sus instancias.
Para indicar que una variable es una variable de clase se utiliza la palabra clave static en
la declaración de la variables:
static tipoVariable nombreVariable;

Métodos de clase

Los métodos de clase al igual que las variables de clase, se aplican a la clase como un
todo y no a sus instancias.

Se utiliza de igual manera la palabra clave static para indicar que un método es un
método de clase:

static valorRetorno nombreMetodo( <lista argumentos opcionales> )

1
/* cuerpo del método */

Para acceder. a las variables o métodos de clase se utiliza el mismo operador punto ( • ).

Aunque se puede acceder a las variables y métodos de clase a través de un objeto, está
permitido y se recomienda utilizar mejor el nombre de la clase.

/* Utilizar esto */
nombreClase.nombreVarClase;
nornbreClase.nombreMetodoClase();

/* en lugar de esto */
nombreObjeto.nombreVarClase;
nombreObJeto.nombreMetodoClase();

/* Usuario3.java */

class Usuario3
1
static char MAS = 'm';
static char FEM = 'f';

String nombre;
int edad;
String direccion;
char sexo;

Usuario3 ( )
1
nombre = null;
edad = O;
direccion = null;
sexo='\0';

31
 Usuario3(String nombre, int edad, String direccion,char sexo)
1
this.nombre =nombre;
this.edad =edad;
this.direccion = direccion;
this.sexo =sexo;

Usuario3(Usuario3 usr)
{
nombre= usr.getNornbre();
edad = usr.getEdad{);
direccion = usr.getDireccion();
sexo= usr.getSexo(};

void setNombre(String n)
{
nombre = n;

String getNornbre(
1
return nombre;

void setEdad(int e)
1
edad = e;

int getEdad {)
1
return edad;

void setDireccion{String d)
1
direccion = d;

String getDireccion(
1
return direccion;

void setSexo(char s)
1
sexo = s;

char getSexo ( )
1
return sexo;

public String toString()

1
return nombre;

/* ProgUsuario3.Java */

32
class ProgUsuario3
{
static int NUM USUARIOS = O;
static java.util.Vector usuarios new java.util.Vector();

String nombreObj null;

ProgUsuario3(String nombre)
{
this.nombreObj =nombre;

static int getNumUsuarios()

{
return NUM_USUARIOS;

static void imprimeUsuario(Usuario3 usr)

{
System.out.println("\nNombre: " + usr.nombre l;
Systern.out.println("Edad: " + usr.getEdad(J ) ;
System.out.println("Sexo: " + usr.getSexo() ) ;
System.out.println("Direccion: " + usr.getDireccion() );

void addUsuario(Usuario3 usr)

{
usuarios.addElement(usr);
System.out.print(usr.toString( )+"agregado por el"+ this.toString() +",");
NUM_USUARIOS ++;

void de1Usuario(Usuario3 usr)

{
boolean b = usuarios.removeElement{usr);
if( b ==true )
{
NUM_USUARIOS--;
Systern. out. print (usr. toString ( ) + " eliminado por el "+ this. toString () +", ");

else System.out.println("No se pudo eliminar al usuario.");

public String toString()

{
return nombreObj;

public static void rnain(String args[])

{
ProgUsuario3 objl new ProgUsuario3 ("objetol");
ProgUsuario3 obj2 new ProgUsuario3("objeto2");

Usuario3 usrl,usr2,usr3,usr4;

usrl new Usuario3( );

usr2 new Usuario3 ("Usuario B", 24, "La direccion A", Usuario3. FEM);
usrl new Usuario3(usr2);
usrl. setNornbre ("Usuario A"l;
usr3 new Usuario3 ("Usuario C", 35, "La direccion C", Usuario3.MAS);
usr4 = new Usuario3 ("Usuario D", 15, "La direccion D", Usuario3.MAS);

objl.addUsuario(usrl);
System. out. println ( "\t Total: " +ProgUsuario3. getNumUsuarios () );

33
 obj2.addUsuario(usr2);
System.out .println ( "\t Total: " +obj 1. getNumUsuarios {) l;
objl.addUsuario(usr3);
System.out.println( "\t Total: " +ProgUsuario3.NUM_USUARIOS ) ;
ObJ2.addUsuario(usr4);
System.out.println( "\t Total· " +getNumUsuarios () +"\n");

obj2.de1Usuario(usr4);
System.out.println( "\t Total: " +ProgUsuario3.getNumUsuarios () );
ObJl.delUsuario(usr3);
System.out.println( "\t Total: "+objl.getNumUsuarios(} );
obj2.de1Usuario(usr2);
System.out.println( "\t Total: "+ProgUsuario3.NUM_USUARIOS );
ObJl.delUsuario(usrl);
System.out.println( "\t Total: "+getNumUsuarios() +"\n");

Heredando clases en Java

El concepto de herencia conduce a una estructura jerárquica de clases o estructura de
árbol, lo cual significa que en la OOP todas las relaciones entre clases deben ajustarse a
dicha estructura.

En esta estructura jerárquica, cada clase tiene sólo una clase padre. La clase padre de
cualquier clase es conocida como su superclase. La clase hija de una superclase es
llamada una subclase.

De manera automática, una subclase hereda las variables y métodos de su superclase

(más adelante se explica que pueden existir variables y métodos de la superclase que la
subclase no puede heredar. Véase Modificadores de Acceso). Además, una subclase puede
agregar nueva funcionalidad (variables y métodos) que la superclase no tenía.

* Los constructores no son heredados por las subclases.

Para crear una subclase, se incluye la palabra clave extends en la declaración de la clase.

class nombreSubclase extends nombreSuperclaset

En Java, la clase padre de todas las clases es la clase Object y cuando una clase no tiene
una superclase explícita, su superclase es Object.

Sobrecarga de métodos y de constructores

La firma de un método es la combinación del tipo de dato que regresa, su nombre y su
lista de argumentos.

La sobrecarga de métodos es la creación de varios métodos con el mismo nombre pero

con diferentes firmas y definiciones. Java utiliza el número y tipo de. argumentos para
seleccionar cuál definición de método ejecutar.

Java diferencia los métodos sobrecargados con base en el número y tipo de argumentos

34
que tiene el método y no por el tipo que devuelve.

Tambien existe la sobrecarga de constructores: Cuando en una clase existen constructores

múltiples, se dice que hay sobrecarga de constructores.

/* Métodos sobrecargados */
int calculaSuma{int x, int y, int z) {

int calculaSuma(double x, double y, double z) {

/* Error: estos métodos no están sobrecargados */

int calculaSuma(int x, int y, int z){

double calculaSurna(int x, int y, int z) {

/* Usuario4.java */

class Usuario4
1
String nombre;
int edad;
String direccion;

/* El constructor de la clase Usuar104 esta sobrecargado */

Usuario4 ( )
1
nombre null;
edad = O;
direccion = null;

Usuario4(String nombre, int edad, String direccion)

1
this.nombre = nombre;
this.edad =edad;
this.direccion direccion;

Usuario4(Usuario4 usr)
1
nombre= usr.getNombre();
edad= usr.getEdad{);
direccion = usr.getDireccion();

void setNombre(String n)
1
nombre = n;

String getNombre()
1
return nombre;

/* El metodo setEdad() está sobrecargado ~¡

void setEdad{int e)
1

35
 edad e;

void setEdad(float e)
{
edad = (int)e;

int getEdad ()
{
return edad;

void setDireccion(String d)
{
direccion = d;

String getDireccion()
{
return direccion;

/* ProgUsuario4.java */

class ProgUsuario4
{
void imprimeUsuar1o(Usuar104 usr)

// usr.nombre equivale en este caso a usr.getNombre{)

System.out.println("\nNombre: " + usr.nombre ) ;
System.out.println("Edad: " + usr.getEdad() ) ;
System. out .println ( "Direccion: " + usr. getDireccion () +"\n" l ;

public static void main(String args[]}

{
ProgUsuario4 prog = new ProgUsuario4( };
/* Se declaran dos objetos de la clase Usuario4 */
Usuario4 usrl,usr2;

/* Se utiliza el constructor por omisión */

usrl = new Usuario4( );
prog.imprimeUsuario(usrl);

/* Se utiliza el segundo constructor de Usuario4 */

usr2 = new usuario4("Eduardo",24,"Mi direccion");
prog.imprimeUsuario(usr2);

/* Se utiliza el tercer constructor de Usuario4 */

usrl = new usuario4(usr2);

usrl.setEdad(50);
usr2.setEdad(30.45f);

prog.imprimeUsuario(usrl);
prog.imprimeUsuario(usr2);

Sobre escritura de métodos

36
Una subclase hereda todos los métodos de su superclase que son accesibles a dicha
subclase a menos que la subclase sobreescriba los métodos.

Una subclase sobreescribe un método de su superclase cuando define un método con las
mismas características ( nombre, número y tipo de argumentos) que el método de la
superclase.

Las subclases emplean la sobreescritura de métodos la mayoría de las veces para agregar
o modificar la funcionalidad del método heredado de la clase padre.

class ClaseA
1
void miMetodo(int varl, int var2)
1 ... 1

String miOtroMetodo( )
1 ... 1

class Clases extends ClaseA

1
/* Estos métodos sobreescriben a los métodos
de la clase padre */

void miMetodo (int varl ,int var2)

1 1

String miOtroMetodo( J
1 .•. 1

La referencia this

En ocasiones es conveniente disponer de una referencia que apunte al propio objeto que
se está manipulando. Esto se consigue con la palabra reservada this. this es una
referencia implícita que tienen todos los objetos y que apunta a si.mismo. Por ejemplo:
class Circulo {

Punto centro;

int radio;

Circulo elMayor (Circulo e) {

if (radio> e.radio) return this;
el se return e:

El método elMayor devuelve una referencia al círculo que tiene mayor radio, comparando
los radios del Circulo c que se recibe como argumento y el propio. En caso de que el
propio resulte mayor el método debe devolver una referencia a si mismo. Esto se consigue
con la expresión return this .

La referencia null

37
Para asignar a una referencia el valor nulo se utiliza la constante null. El ejemplo del caso
anterior se podría completar con:·
class Circulo
Punto centro;
int radio;

Circulo elMayor(Circulo e) {
if (radio > e.radio) return this;
else if (e.radio> radio) return e;
else return null;

Clases abstractas
Una clase que declara la existencia de métodos pero no la implementación de dichos
métodos (o sea, las llaves { } y las sentencias entre ellas), se considera una clase
abstracta.

Una clase abstracta puede contener métodos no-abstractos pero al menos uno de los
métodos debe ser declarado abstracto.

Para declarar una clase o un metodo como abstractos, se utiliza la palabra reservada
abstract.
abstract class Drawing
1
abstract void miMetodo(int varl, int var2);
String miOtroMetodo( ){ ... }

Una clase abstracta no se puede instanciar pero si se puede heredar y las clases hijas
serán las encargadas de agregar la funcionalidad a los métodos abstractos. Si no lo hacen
así, las clases hijas deben ser también abstractas.

Interfaces
Una interface es una variante de una clase abstracta con la condición de que todos sus
métodos deben ser asbtractos. Si la interface va a tener atributos, éstos deben llevar las
palabras reservadas static final y con un valor inicial ya que funcionan como constantes
por lo que, por convención, su nombre va en mayúsculas.
interface Nomina
1
public static final String EMPRESA= "Patito, S. A.";
public void detalleDeEmpleado(Nomina obJ);
1

Una clase implementa una o más interfaces (separadas con comas ",") con la palabra
reservada implements. Con el uso de interfaces se puede "simular" la herencia múltiple
que Java no soporta.

class Empleado irnplements Nomina

38
En este ejemplo, la clase Empleado tiene una clase padre llamada Object (implícitamente)
e implementa a la interface Nomina, quedando el diagrama de clases de la siguiente
manera:

ObJect Nomina
(clase) (interface)

1 1
1
Empleado
(clase)

La clase que implementa una interface tiene dos opciones:

1) Implementar todos los métodos de la interface.

2) Implementar sólo algunos de los métodos de la interface pero esa clase debe ser una
clase abstracta (debe declararse con la palabra abstract).

Paquetes y Modificadores de acceso

Paquetes

Para hacer que una clase sea más fácil de localizar y utilizar así como evitar conflictos de
nombres y controlar el acceso a los miembros de una clase, las clases se agrupan en
paquetes.
Paquete

Un paquete es un conjunto de clases e interfaces relacionadas.

La forma general de la declaración package es la siguiente:

package nombrePaquete;

donde nombrePaquete puede constar de una sola palabra o de una lista de nombres de
paquetes separados por puntos.

package miPaquete;

class Miclase
(

package nornbrel.nombre2.rniPaquete;

39
 class TuClase
{

Los nombres de los paquetes se corresponden con nombre de directorios en el sistema de

archivos.

De esta manera, cuando se requiera hacer uso de estas clases se tendrán que importar de
la siguiente manera.

import miPaquete.MiClase;
import nombrel.nombre2.miPaquete.TuClase;

class OtraClase
{
/* Aqui se hace uso de la clase 'Miclase' y de la
clase 'TuClase' */

Para importar todas las clases que están en un paquete, se utiliza el asterisco ( * ).

import miPaquete.*;

Si no se utiliza la sentencia package para indicar a que paquete pertenece una clase, ésta
terminará en el package por default, el cual es un paquete que no tiene nombre.

/* Usuarios.java */

package paquete!;

class Usuarios
{
static char MAS 'm';
static char FEM = 'f';

String nombre;
int edad;
String direccion;
char sexo;

Usuarios ( )
{
nombre = null;
edad = O;
direccion = null;
sexo= '\0';

UsuarioS(String nombre, int edad, String direccion,char sexo)

{
this.nombre = nombre;
this.edad =edad;
this.direccion = direccion;
this.sexo =sexo;

UsuarioS(UsuarioS usr)

40
 nombre= usr.getNombre();
edad= usr.getEdad();
direccion = usr.getD1recc1on();
sexo= usr.getSexo();

void setNombre(String n)
1
nombre = n;

String getNombre()
1
return nombre;

void setEdad(int e)
1
edad = e;

int getEdad ()
1
return edad;

void setDireccion(String d)
1
direccion = d;

String getDireccion()
1
return direccion;

void setSexo(char s)
{
sexo = s;

char getSexo (}
1
return sexo;

public String toString()

1
return nombre;

/* ProgUsuarioS.Java */

package paquete!;

import Java.util.Vector;

class ProgUsuarioS
1
static int NUM_USUARIOS O;

41
 static Vector usuarios= new Vector();
/* La siguiente linea seria obligatoria si
se ami tiera la linea import java. util. Vector; * /
// static Java.util.Vector usuarios= new Java.util.Vector(};

String nombreObj = null;

ProgUsuarioS(String nombre)
1
this.nombreObj =nombre;

static int getNumUsuarios()

return NUM_USUARIOS;

static void imprimeUsuario(UsuarioS usr)

1
System.out.println("\nNombre: "+ usr.nornbre );
System.out.println("Edad: " + usr.getEdad() ) ;
System.out.println("Sexo: "+ usr.getSexo() );
System.out.println("Direccion: " + usr.getDireccion() l;

void addUsuario(UsuarioS usr)

1
usuarios.addElement{usr);
System.out.print(usr.toString( }+ " agregado por el "+ this.toString() +", ");
NUM USUARIOS ++;

void delUsuario{UsuarioS usr}

1
boolean b = usuarios.removeElement(usr);
if( b == true )
1
NUM_USUARIOS--;
System. out. print (usr. toString ( ) + " elimJ.nado por el "+ this. toString () +", ") :

else System.out.println("No se pudo eliminar al usuario.");

public String toString()

1
return nombreObj;

public static void main(String args(})

1 .

ProgUsuarioS ob]l new ProgUsuarioS("objetol");

ProgUsuarioS obJ2 new ProgUsuarioS ("ob]eto2");

Usuarios usrl,usr2,usr3,usr4;

usrl new UsuarioS( );

usr2 new Usuarios ("Usuario B", 24, "La direccion A", Usuarios. FEM);
usrl new UsuarioS(usr2);
usrl.setNombre("Usuario A");
usr3 new usuarios ("Usuario C", 3S, "La direccion C", UsuarioS.MAS);

usr4 new UsuarioS{"Usuario D",lS,"La direccion D",UsuarioS.MAS);

obJl.addUsuario(usrl);
System.out.println( "\t Total: +ProgUsuarioS. getNumUsuarios () );
obj2.addUsuario(usr2);
System.out.println( "\t Total: +objl.getNumUsuarios{) );

42
 obJl.addUsuario(usr3);
System.out.println( "\t Total: " +ProgUsuarioS.NUM_USUARIOS ) ;

obJ2.addUsuario{usr4);
System.out.println( "\t Total: "+getNumUsuarios() +"\n");

obJ2.delUsuario(usr4);
System.out.println( "\t Total: "+ProgUsuario5.getNumUsuarios() );
objl.de1Usuario(usr3);
System.out.println( "\t Total: " +objl.getNumUsuarios() );
obj2.de1Usuario(usr2);
System.out.println( "\t Total: "+ProgUsuario5.NUM_USUARIOS );
obJl.delUsuario(usrl);
System. out .println ( "\t Total: " +getNumUsuarios () +"\n");

Control de acceso a miembros de una clase

Los modificadores más importantes desde el punto de vista del diseño de clases y objetos,
son los que permiten controlar la visibilidad y acceso a los métodos y variables que están
dentro de una clase.

Uno de los beneficios de las clases, es que pueden proteger a sus variables y métodos
(tanto de instancia como de clase) del acceso desde otras clases.

Java soporta cuatro niveles de acceso a variables y métodos. En orden, del más público al
menos público son: público (public), protegido (protected), sin modificador (también
conocido como package) y privado (private).

La siguiente tabla muestra el nivel de acceso permitido por cada modificador:

- 1 public 11 protected 11 (sin modificador) !I private

iCl~se _ 11 SI J SI JI SI Ji_ sI
1 Sub~lase
i el mismo paquete
enjl;IJI SI
1 :;,i J
11 SI NO
'------------------ :======-~!;=====-=·=--~-=-=--=-·='::=====!
! No-Subclase en ~1 SI li! SI NO I,!

¡ el mismo paquete 1 :::>i 1 ,!

i!-~~~~!~~:-~::·:·:~e---~nll[ ~I·-----.--.-~s--~-;~--~-----¡~-)---------;·1'-~-0----------------------------------·-····!1··~-~------1
1 ' ' : ' ''' i

~,;;;:~'~
·· (Universo)
,.,,: 1 IEJo NO '111 1 NO
~~-----··

(*) Los miembros (variables y metodos) de clase (static) si son visibles. Los miembros de
instancia no son visibles.

Como se observa de la tabla anterior, una clase se ve a ella misma todo tipo de variables y
métodos (desde los public hasta los private); las ciernas clases del mismo paquete (ya

43
sean subclases o no) tienen acceso a los miembros desde los public hasta los sin-
modificador. Las subclases de otros paquetes pueden ver los miembros public y a los
miembros protected, éstos últimos siempre que sean static ya de no ser así no serán
visibles en la subclase (Esto se explica en la siguiente página). El resto del universo de
clases (que no sean ni del mismo paquete ni subclases) pueden ver sólo los miembros
public.

Excepciones

Las excepciones son la manera que ofrece Java de manejar los errores en tiempo de
ejecución. Muchos lenguajes imperativos, cuando tenían un error de esta clase lo que
hacían era detener la ejecución del programa. Las excepciones nos permiten escribir
código que nos permita manejar ese error y continuar (si lo estimamos conveniente) con
la ejecución del programa.

El error en ejecución más clásico en Java es el de desbordamiento. Es decir, el intento de

acceso a una posición de un vector que no existe. Por ejemplo:

public class Desbordamiento {

static String mensajes[] ={"Primero", "Segundo", "Tercero" };
public static void main (String [) args) {
far (int i=O; i<=3; 1++)
System.out.println(mensajes[i]);
System.out.println("Ha finalizado la ejecución");

Este programa tendrá un serio problema cuando intente acceder a mensaJesl3J, pues no
existe dicho valor. Al ejecutarlo nos dirá lo siguiente (o algo parecido):

Primero
Segundo
Tercero
Exception in thread "main" Java.lang.ArrayindexOutOfBoundsException
at Desbordamiento.main(Desbordamiento.java, Compiled Code}

Nos da un error de ejecución (en esta terminología se diría que se lanzó una excepción) al
intentar acceder a dicho valor inexistente. Vemos que, por ahora, el comportamiento de
nuestro código es el mismo que en los lenguajes imperativos. Cuando encuentra el error,
se para la ejecución. Ahora veremos como evitar esto.

try ... catch .. .finally

Existe una estructura que nos permitirá capturar excepciones, es decir, reaccionar a un
error de ejecución. De este modo podremos imprimir mensajes de error "a la medida" y
continuar con la ejecución del programa si consideramos que el error no es demasiado
grave. Para ver como funcionan vamos a modificar el ejemplo anterior, pero
asegurandonos ahora de que capturamos las excepciones:

public class NuestroPrirnerCatch {

static String mensa]es[] ={"Primero", "Segundo", "Tercero" );
public static void main(String(] args) {
try {
far (int i=O; i&lt;=3; i++)

44
 System.out.println(rnensajes[i]);

catch ( ArrayindexOutOfBoundsException e ) {
System.out.println("El asunto se nos ha desbordado");

finally {
Systern.out.println("Ha finalizado la ejecución");

Dentro del bloque que sigue a try colocamos el código a ejecutar. Es como si dijeramos
que vamos a intentar ejecutar dicho código a ver qué pasa. Después de try deberemos
colocar al menos un bloque catch o un bloque finally, pudiendo tener ambos e incluso
más de un bloque catch.

En el bloque finally ponemos el código que se ejecutará siempre, tanto si se lanza la

excepción como si no. Su utilidad no es mucha, ya que si se permite continuar con la
ejecución del programa basta con poner el código después del bloque try ...catch. En
nuestro ejemplo podríamos haber puesto lo siguiente:

try {
for (int i=O; i<=3; i++)
System.out.println(rnensajes[i]);

catch ( ArrayindexOutOfBoundsException e ) {
Systern.out.println("El asunto se nos ha desbordado");

System.out.println("Ha finalizado la ejecución");

Y habría funcionado exactamente igual. La miga está en los bloques catch.

Clase Exception

Cuando se lanza una excepción, en nuestro mundo orientado objetos lo que se hace es
lanzar una instancia de Exception o de una clase derivada de él. Normalmente las clases
derivadas no añaden mucha funcionalidad (muchas veces ninguna en absoluto), pero al
ser distintas nos permiten distinguir entre los distintos tipos de excepciones.
En el programa anterior, por ejemplo, en el bloque catch capturábamos una excepción
del tipo ArrayindexOutOfBoundsException, ignorando cualquier otro tipo de
excepción.

Esta clase tiene como cositas interesantes dos constructores y dos métodos (tiene más
métodos pero sólo vamos a ver éstos):

Exception e= new Exception()

Crea una excepción si ningún mensaje específico.

Exception e = new Exception ( String }

Crea una excepción con un mensaje que detalla el tipo de excepción.

String e.getMessage()
Devuelve el mensaje detallado si existe o null en caso contrario.

void e.printStackTrace()
Escribe por la salida de error estándar una traza que nos permitirá localizar donde se generó
el error. Es muy útil para depurar, pero no es conveniente que lo usuarios finales vean estas cosas.

45
Capturar excepciones

Ahora sabemos lo suficiente como para entender cómo funcionan los catch. Entre
paréntesis, cual parámetro se pone la declaración de una excepción, es decir, el nombre
de una clase derivada de Exception (o la misma Exception) seguido por el nombre de la
variable. Si se lanza una excepción que es la que deseamos capturar o una derivada de la
misma se ejecutará el código que contiene el bloque. Así, por ejemplo:

catch (Exception e) {

Se ejecutará siempre que se produzca una excepción del tipo que sea, ya que todas las
excepciones se derivan de Exception. No es recomendable utilizar algo así ya que
estamos capturando cualquier tipo de excepciones sin saber si eso afectará a la ejecución
del programa o no.

Se pueden colocar varios bloques catch. En ese caso, se comprobará en orden si la

excepción lanzada es la que deseamos capturar y si no pasa a comprobar la siguiente. Eso
sí, sólo se ejecuta un bloque catch. En cuanto captura la excepción deja de comprobar los
demás bloques. Por eso, lo siguiente:

catch (Exception e) {

)
catch (DerivadaDeException e) {

Daría error, ya que el segundo bloque no podría ejecutarse nunca.

Jerarquía de las excepciones

Las excepciones en Java son objetos reales, y tienen su propía jerarquía. La clase raíz de
ellas es Throwable, una subclase de Object. Los métodos que se definen dentro de ella
serán los encargados de los mensajes de error que estén relacionados con cada una de las
excepciones.

46
 Object

Error Exception

ClassNot Foun dException

Ru ntimeExce ptio n

lndexOutOffioundsException

Todos los errores y excepciones son subclases de Throwable, por lo que podrán acceder a
sus métodos. Los métodos más utilizados son los siguientes:
getMessage{ ) Se usa para obtener un mensaje de error asociado con una excepción.
printStackTrace{ ) Se utiliza para imprimir el registro del stack donde se ha iniciado la
excepción.
toString{ ) Se utiliza para mostrar el nombre de una excepción junto con el mensaje que
devuelve getMessage().

47