FI Apuntes 2015

FUNDAMENTOS
DE PROGRAMACIN
EN JAVA
Teresa Sastre Toral

Madrid-Las Tablas
Alberto Ruiz Cristina

Madrid Sur-Pinto
(Revisin 2014)
Fundamentos de Programacin en Java

1
ELEMENTOS BSICOS DEL LENGUAJE JAVA .................................................................. 1

1.1
1.2
ESTRUCTURA DE UN PROGRAMA EN JAVA ................................................................................... 1

ELEMENTOS BSICOS PARA EMPEZAR A PROGRAMAR .................................................................. 2
ESTRUCTURAS DE CONTROL DE FLUJO ........................................................................... 4

2.1 OBJETIVOS ................................................................................................................................ 4
2.2 ESTRUCTURAS DE SELECCIN .................................................................................................... 4
2.2.1
if...................................................................................................................................... 4
2.2.2
if-else .............................................................................................................................. 5
2.2.3
Operador condicional ...................................................................................................... 5
2.2.4
switch .............................................................................................................................. 5
2.3 ESTRUCTURAS DE REPETICIN ................................................................................................... 6
2.3.1
while ............................................................................................................................... 6
2.3.2
do-while .......................................................................................................................... 7
2.3.3
for ................................................................................................................................... 7
2.3.4
Ruptura del flujo .............................................................................................................. 8
2.3.5
Manejo de excepciones .................................................................................................... 8
2.4 PROGRAMAS DE EJEMPLO ........................................................................................................... 9
2.4.1
Programa 1 ..................................................................................................................... 9
2.4.2
Programa 2 ................................................................................................................... 14
CLASES Y OBJETOS .............................................................................................................. 15

3.1 OBJETIVOS .............................................................................................................................. 15
3.2 CLASE ..................................................................................................................................... 15
3.2.1
Atributos........................................................................................................................ 16
3.2.2
Mtodos......................................................................................................................... 16
3.2.3
Autorefencia this............................................................................................................ 17
3.2.4
Mtodo constructor........................................................................................................ 18
3.2.5
Sobrecarga .................................................................................................................... 19
3.3 OBJETOS ................................................................................................................................. 19
3.3.1
Referencias compartidas: alias ...................................................................................... 20
3.4 EJEMPLO DE CDIGO ................................................................................................................ 20
3.5 ELEMENTOS DE CLASE ............................................................................................................. 22
3.6 CLASES PREDEFINIDAS ............................................................................................................. 22
3.7 MBITOS................................................................................................................................. 22
3.8 PAQUETES ............................................................................................................................... 23
3.9 DERECHOS DE ACCESO ............................................................................................................. 25
3.10
PROGRAMAS DE EJEMPLO .................................................................................................... 26
3.11
ENUMERADOS ..................................................................................................................... 29
ESTRUCTURAS DE ALMACENAMIENTO .......................................................................... 30

4.1
4.2
4.3
4.4
4.5
4.6
OBJETIVOS .............................................................................................................................. 30
COMPARACIN ENTRE UN ARRAY Y UN ARRAYLIST .................................................................. 30
ARRAY.................................................................................................................................... 30
ARRAYLIST ............................................................................................................................. 31
RECORRIDO DE ESTRUCTURAS .................................................................................................. 32
CDIGO DE EJEMPLO ................................................................................................................ 34
DOCUMENTACIN DE LAS CLASES .................................................................................. 35

5.1
5.2
5.3
ANTES DE LA CLASE: ............................................................................................................... 35

ANTES DE UN MTODO: ............................................................................................................ 35
GENERAR LA DOCUMENTACIN................................................................................................ 36
COMPOSICIN, HERENCIA Y POLIMORFISMO ............................................................. 37

6.1 OBJETIVOS .............................................................................................................................. 37
6.2 COMPOSICIN ......................................................................................................................... 37
6.3 HERENCIA ............................................................................................................................... 38
6.3.1
Compatibilidad de tipos ................................................................................................. 40
6.3.2
mbitos y visibilidad...................................................................................................... 40
6.3.3
Reescritura .................................................................................................................... 40
6.3.4
Los constructores........................................................................................................... 40
6.4 TABLA DE COMPATIBILIDAD..................................................................................................... 41
6.5 COMPATIBILIDAD DE TIPOS ...................................................................................................... 41
6.6 REESCRITURA Y LIGADURA DINMICA ...................................................................................... 42
6.7 POLIMORFISMO ....................................................................................................................... 42
6.8 CLASES ABSTRACTAS .............................................................................................................. 43
EJEMPLOS DE PROGRAMAS ............................................................................................... 44

7.1
7.2
7.3
7.4
7.5
7.6
7.7
7.8
7.9
7.10
PROGRAMAS SENCILLOS SOBRE ESTRUCTURAS DE CONTROL ...................................................... 44

EJERCICIO SOBRE CONSTRUCTORES .......................................................................................... 47
EJERCICIOS SOBRE ESTRUCTURAS DE ALMACENAMIENTO ......................................................... 51
EJERCICIO SENCILLO CON ORIENTACIN A OBJETOS .................................................................. 53
GESTOR DE CUADRADOS .......................................................................................................... 55
PROGRAMA SOBRE COMPOSICIN Y HERENCIA .......................................................................... 59
PROGRAMA SOBRE COMPOSICIN Y HERENCIA II ....................................................................... 61
PROGRAMA SOBRE COMPOSICIN Y HERENCIA III ..................................................................... 64
GESTOR DE ANIMALES ............................................................................................................. 66
GESTOR DE ANIMALES AADIENDO HERENCIA ...................................................................... 69
Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina
1 Elementos bsicos del lenguaje Java

1.1 Estructura de un programa en Java
En Java se llama programa a un conjunto de clases. Una clase es un archivo de extensin
.java que normalmente describe un concepto, como Triangulo o Alumno. De
momento no entramos en el concepto de clase, que se abordar ms adelante.
Una de las clases (archivos) del programa debe tener un mtodo llamado main. Un
mtodo describe una accin que realiza la clase. Por ejemplo, calcularArea podra ser un
mtodo de la clase Triangulo, mientras que obtenerDni podra ser un mtodo de la clase
Persona. De nuevo nos remitimos a captulos posteriores para ahondar en el concepto de
mtodo.
De momento nos quedamos, por tanto, con que el programa ms sencillo que podamos
escribir estar compuesto por una sola clase, que tendr un mtodo llamado main
(principal en ingls) por donde el programa empezar a ejecutar. A continuacin se escribe
el programa ms sencillo que se puede escribir en Java, y que ira escrito en un archivo
llamado Ejemplo.java:
1 public class Ejemplo
2 {
3
public static void main(String[] args)
4
{
5
System.out.println("Hola");
6
}
7 }
Los nmeros se han incluido para poder referirnos a cada lnea, pero en el programa no se
escribiran. Sugerimos al alumno que adquiera una visin general de este programa pero
que an no se preocupe por no comprender los detalles. Los elementos fundamentales que
vemos en este programa son:
Lnea 1: formalizamos la clase (class) Ejemplo (el nombre debe coincidir con el
del archivo, incluidas las maysculas y minsculas).
Lnea 3: declaramos el mtodo main.
Lnea 5: aqu vendran las acciones del programa. En este caso slo tenemos una
accin, que imprime en pantalla el mensaje Hola.
Obsrvese que en Java se utilizan las llaves para delimitar los distintos elementos. As, las
llaves de las lneas 2 y 7 delimitan la clase Ejemplo, mientras que las llaves ms internas
de las lneas 4 y 6 delimitan el mtodo main.
Es una buena costumbre utilizar los tabuladores para que el programa se lea de forma ms
sencilla y agradable. As, cada vez que se abra una llave, conviene escribir las lneas
siguientes con una tabulacin ms que la anterior.
El resto del captulo tratar de introducir de forma eminentemente prctica los conceptos
fundamentales para poder empezar a programar. Recomendamos al alumno que, una vez
estudie este captulo, acuda al anexo para aprender a poner en marcha el entorno de
trabajo en su ordenador y trate de reproducir en su mquina los programas de ejemplo que
se irn mostrando a continuacin.
1.2 Elementos bsicos para empezar a programar

Ya hemos visto cmo dar forma a un programa de prueba, y cmo imprimir en pantalla un
texto. Tambin es posible escribir en pantalla operaciones numricas:
System.out.println((15 -2 + 7)/2);
Sin embargo, la programacin no sera muy til si siempre fuese necesario utilizar valores
numricos sobre la marcha: lo que nos interesa es poder almacenarlos y volver a ellos
cuando lo necesitemos, bien sea para consultarlos o bien para recuperarlos. Es lo que
hacemos, de forma muy bsica, al pulsar la tecla Memoria de nuestra calculadora
tradicional.
Surge as el concepto de variable. Al igual que en Matemticas, las variables son
representaciones simblicas de un valor numrico que puede variar a lo largo de la
ejecucin del programa.
Sin embargo, en Java vamos un paso ms all y establecemos que las variables no slo
pueden ser nmeros, sino que tambin pueden contener, por ejemplo, cadenas de texto.
Surge as el concepto de tipo de datos. En Matemticas, cuando decimos x = 6, se
asume que x es un nmero. En Java hay que hacerlo explcito:
int x;
x = 6;
En la primera lnea declaramos la variable, que significa que comunicamos a Java que
queremos poder referenciar el nombre x y que con l nos referimos a un valor de tipo
entero (int viene de Integer). Existe una serie de tipos predefinidos como int y double,
y otros adicionales como String, que representa las cadenas de texto. As, podemos definir
variables de otros tipos:
double area = 3.56;
String texto = "Este es un texto";
Obsrvese que en la propia lnea de declaracin tambin podemos darle valores iniciales
con el operador =. A eso se le llama asignacin. Ms adelante se ver que puede haber
variables de muchos ms tipos.
Tambin podemos definir constantes, indicando mediante la palabra final que el valor no
puede ser modificado:
final double PI = 3.1416;
Es importante respetar una serie de convenciones de nombres. Es fcil acostumbrarse a

hacerlo y redunda en unos programas ms sencillos y fciles de leer. Las reglas bsicas son:
Los tipos predefinidos, variables y mtodos se escriben en minscula, como int,

area y main.
Las constantes se escriben en maysculas, como PI.
Las clases se escriben con la inicial en mayscula, como Ejemplo.
Otro elemento interesante son los comentarios. Se trata de texto que Java no interpretar,
y que slo sirve para que nosotros escribamos informacin sobre el programa que
consideremos interesante. Por ejemplo:
/* Ejemplos de comentarios: */
double area; // representa el area de la figura
final double PI = 3.1416; // esta constante es el numero PI
Existen dos tipos de comentarios. El primero se llama comentario de bloque y est

delimitado por /* y */. Este tipo de comentario puede abarcar varias lneas.
El segundo tipo se llama comentario de lnea y slo afecta al texto que va detrs de los
smbolos // hasta terminar la lnea.
Es posible asignar a una variable el valor de otra variable de distinto tipo? La respuesta es
s, pero con precaucin. En caso de que no haya prdida de informacin, se puede hacer
sin problemas:
int i = 6;
double d = i;
As, la variable de tipo double puede almacenar sin problemas el valor 6. No ocurre lo
mismo al contrario:
double d2 = 4.56;
int i2 = d2; // ERROR
En este caso existe prdida de informacin, ya que la variable entera podr almacenar
nicamente el valor 4, perdiendo los decimales. Por ello Java exige que le indiquemos
que queremos proceder a pesar del riesgo. Para ello se utiliza la conversin forzada de tipo:
double d2 = 4.56;
int i2 = (int) d2; // correcto
Ahora nos atrevemos a hacer un pequeo programa:

double base;
double altura;
double areaRectangulo;
base = 5.4 ;
altura = 2.3;
areaRectangulo = base * altura ;
System.out.println("El rea del rectngulo es: " +
areaRectangulo) ;
Obsrvese que al escribir por pantalla podemos concatenar valores de texto con valores
numricos o variables, a travs del operador +. El alumno puede comprobar que al
escribir texto entrecomillado, se escribe el texto literalmente, mientras que al escribir el
nombre de una variable, se escribe su contenido.
Finalizamos el captulo de introduccin destacando que tanto 2+4*7 como base*altura
son expresiones numricas. Existe otro tipo de expresiones, llamadas lgicas, cuyo
resultado no es un valor numrico sino un valor lgico: cierto (true) o falso (false). La
utilidad de este tipo de expresiones se ver en el prximo captulo: de momento basta con
aprender a escribirlas. Para ello se utilizan operadores lgicos como > (mayor), <=
(menor o igual), == (igual, obsrvese que es distinto del operador de asignacin, =), o
!= (distinto). Tambin se usan los operadores AND (Y, representado por &&) y OR
(O, representado por ||). Por ejemplo, la expresin:
(x>=0)&&(x<5)
slo ser cierta si x es mayor o igual que 0 y adems x es menor que 5. Es decir, deben
cumplirse ambas condiciones para que la expresin sea cierta. Sin embargo, la expresin
(x<0)||(x>1000)
ser cierta si x es negativo o bien si x es mayor que 1000. Es decir, basta que se cumpla una
de las condiciones para que el resultado de la expresin sea cierto.
2 Estructuras de control de flujo

2.1 Objetivos
En este captulo se intentar que el alumno aprenda la utilidad de las sentencias de control
de flujo, fundamentales en todo programa. Su misin es impedir que cada vez que
ejecutemos un programa se haga exactamente lo mismo, es decir, queremos poder hacer
unas cosas u otras distintas en funcin de determinadas condiciones. Dichas condiciones
vendrn expresadas mediante expresiones lgicas.
Existen dos tipos de estructuras de control de flujo:
Las estructuras de seleccin permiten ejecutar una u otra porcin de cdigo

segn una determinada condicin.
Las estructuras de repeticin permiten ejecutar una misma porcin de cdigo

repetidas veces, hasta que se cumpla una determinada condicin.
2.2 Estructuras de seleccin

Este tipo de estructuras permite ramificar el flujo de ejecucin temporalmente segn se
cumpla o no se cumpla una condicin lgica. Hay diferentes modalidades, que se estudian a
continuacin. En todas ellas, tras las posibles ramificaciones, el flujo se vuleve a reunir.
2.2.1 if
Si se cumple una condicin, se ejecuta una serie de sentencias. Si no se cumplen, el
programa las salta y contina.
Sintaxis en java:
if (condicin)
{
sentencias;
}
condicin
false
true
sentencias
2.2.2 if-else
Si se cumple una condicin, se ejecuta una serie de sentencias. Si no se cumplen, se ejecuta
otro conjunto de sentencias.
Sintaxis en java:
if (condicin)
{
sentencias;
}
else
{
sentencias;
}
false
sentencias 1
condicin
true
sentencias 2
2.2.3 Operador condicional

Se trata de una reescritura resumida del if-else. No se usa habitualmente.
Sintaxis en java:
expresin booleana ? expresin1 : expresin2
2.2.4 switch
Es una estructura que puede parecer compleja en un principio, pero es realmente sencilla.
Est indicada para casos en que no hay una o dos alternativas, sino ms. Funciona de la
siguiente manera: se parte de un nmero entero y, segn su valor, se salta a una u otra
rama. Existe una ltima rama especial (su aparicin es opcional) llamada default, que se
ejecuta si el nmero no coincide con ninguno de los valores previstos por el programador.
Es fcil caer en la tentacin de pensar que si el valor de la expresin entera es 2 y
tenemos una rama etiquetada como case 2:, slo se ejecutar dicha rama, y el flujo
continuar despus tras la sentencia switch. Sin embargo, esto slo es as si incluimos la
sentencia break; despus de cada rama. De lo contrario, despus de la rama
correspondiente al 2, se ejecutar la del 3, y despus todas las siguientes, incluida la rama
default, que es la ltima. De lo anterior se deduce que despus de la rama default no es
necesario poner break, puesto que ya no hay nada despus.
Esto parece bastante incmodo, pero se ha planteado as porque a veces resulta interesante
(ver programa de ejemplo).
Sintaxis en java:
switch (expresin)
{
case valor1:
sentencias;
break;
case valor2:
sentencias; // cuidado con el break!
case valor3:
sentencias;
break;
default:
sentencias;
}
2.3 Estructuras de repeticin

Este tipo de estructuras se usa cuando queremos que una sentencia o conjunto de
sentencias se ejecuten varias veces. Todas se basan en el cumplimiento de una condicin,
de forma que existe el peligro de caer en ciclos infinitos si el programador no se asegura de
que la condicin deje de cumplirse en algn momento. Existen diferentes tipos:
2.3.1 while
Ejecuta las sentencias mientras se cumpla la condicin. Si la condicin no se cumple, nunca
se ejecutarn las sentencias.
Sintaxis en java:
while (condicin)
{
sentencias;
}
condicin
false
true
sentencias
2.3.2 do-while
Similar al anterior, pero en este caso las sentencias se ejecutan antes de comprobar la
condicin, de forma que necesariamente habr al menos una ejecucin de las sentencias.
Sintaxis en java:
do
{
sentencias;
} while (condicin);
sentencias
condicin
true
false
2.3.3 for
Esta estructura est pensada para ejecutar las sentencias un nmero determinado y
conocido de veces. Resulta especialmente til, como se ver en clases posteriores, para
recorrer estructuras de almacenamiento.
Se utiliza una variable como contador, que se inicializa en la propia sentencia for: es ms,
habitualmente la variable de contador se suele declarar en dicha sentencia. Tambin en la
sentencia se indica la condicin de parada y el cdigo de actualizacin, que suele consistir
simplemente en incrementar en una unidad la variable contador. Por ejemplo:
for (int i=0; i<5; i++)
Esta cabecera indica que en la primera ejecucin el contador i valdr 0, que en cada
ejecucin el contador se incrementar en 1, y que las sentencias se ejecutarn mientras el
contador sea menor que 5.
Sintaxis en java:
for (inicializacin; condicin de salida; actualizacin)
{
sentencias;
}
La relacin entre while y for es muy estrecha y se muestra en la siguiente tabla:

for (inicializacin;
condicin;
actualizacin)
{
sentencias;
}
inicializacin;
while (condicin)
{
sentencias;
actualizacin;
}
Cmo elegir la estructura de repeticin adecuada?
Si es posible que el bucle no se ejecute, usar while.
Si queremos que al menos se ejecute una vez, usar do-while.
Si sabemos cuntas veces queremos ejecutarlo, usar for.
Si queremos recorrer todos los elementos de un vector, usar for.
2.3.4 Ruptura del flujo

Las instrucciones break y continue nos permiten abandonar en un momento
determinado la ejecucin de un bucle. Se trata de un recurso poco elegante y que rompe la
estructura de los programas: por tanto, deber evitarse siempre que sea posible.
La diferencia entre ambas instrucciones es que break salta al punto de salida del bucle,
continuando con la ejecucin de programa sin volver a comprobar la condicin de entrada
al bucle. Por el contrario, continue salta hacia el punto donde se evala la condicin,
permitiendo volver a entrar en el bucle si la condicin se cumple.
En resumen: continue abandona la ejecucin actual de las sentencias del bucle, mientras
que break abandona el bucle definitivamente.
2.3.5 Manejo de excepciones

Algunas operaciones pueden provocar fallos que el ordenador no puede manejar y que el
programador debe detectar mientras escribe un programa. Estos fallos suelen tener que ver
con eventualidades que en el momento de programar no se conocen: por ejemplo, que un
usuario escriba un texto cuando se le pide un nmero, que se intente abrir un archivo que
no se encuentra
Las excepciones son la forma en que el programador previene dichos fallos y avisa al
ordenador de cmo comportarse cuando stos se produzcan.
El funcionamiento es el siguiente: cuando se vaya a ejecutar una operacin de riesgo, las
sentencias implicadas se envuelven en un bloque try. Dicho bloque debe ir seguido de un
bloque catch que recoge el cdigo que queremos que se ejecute cuando el fallo ocurra. La
idea es intentar (try) hacer algo y capturar al vuelo (catch) el posible error antes de que
provoque que el programa se cuelgue o d resultados inesperados.
Opcionalmente se puede incluir un bloque finally que se ejecutar tanto si el error ha
aparecido como si no. Tambin es posible lanzar manualmente una excepcin con throw
Exception e.
Sintaxis en java:
try
{
sentencias de riesgo;
}
catch (TipoDeExcepcion e)
{
cdigo a ejecutar si ocurre el fallo;
}
finally // opcional
{
cdigo a ejecutar tanto si hay error como si no
}
2.4 Programas de ejemplo

2.4.1 Programa 1
1 import java.util.InputMismatchException;
2 import java.util.Scanner;
3
4 public class SegundaClase {
5
6
public static void main()
7
{
8
/* COMENTARIOS
9
Ya conocemos los comentarios de bloque,
10
que pueden ocupar varias lneas */
11
// Y tambin los comentarios de lnea
12
13
/* DECLARACIN DE VARIABLES
14
* Para declarar una variable se indica su tipo y su nombre.
15
* Es posible dar un valor inicial a la variable en el momento
16
* de su declaracin. */
17
int entero1;
18
double doblePrecision1 = 3.54;
19
String miCadenaDeCaracteres1 = "Valor inicial de la variable";
20
/* Podemos declarar ms de una variable separndolas mediante
21
* "," siempre que sean del mismo tipo. Sin embargo, como es
22
* conveniente describir la variable con un comentario,
23
* resulta ms claro declarar cada variable en una lnea
24
* y describirla con un comentario de lnea.*/
25
double baseTriangulo; // base del tringulo
26
double alturaTriangulo; // altura del tringulo
27
int temp1, temp2, temp3;
28
29
/* SALIDA POR PANTALLA */
30
/* Consideraremos nicamente los mtodos print y println.
31
* La diferencia es que println escribe el texto y cambia
32
* despus a la lnea siguiente. Obsrvese tambin que para
33
* representar las comillas en una cadena es necesario
34
* usar el carcter de escape "\". */
35
System.out.print("Esto ");
36
System.out.print("se escribir en ");
37
System.out.println("una sola lnea, porque usamos print");
38
System.out.print("Este texto ser la segunda lnea, ya que " +
39
"el \"println\" anterior produjo un cambio de lnea.");
40
/* Podemos concatenar elementos con el smbolo "+". Tambin
41
* podemos escribir el contenido de una variable y, en
42
* general, de cualquier expresin. */
43
System.out.println(" El valor de " + " la variable es: " +
44
doblePrecision1);
45
46
/* EXPRESIONES NUMRICAS
47
* Podemos construirlas mediante los diferentes operadores: */
48
entero1 = (3 + 5 - 7) * 10 / 2; // operaciones bsicas
49
entero1 = -1 - 1; /* los smbolos "+" y "-" tambin se usan
50
* como operadores unarios para representar los signos */
51
/* Operadores de incremento y decremento: pueden situarse
52
* antes o despus de la variable, segn se quiera realizar
53
* antes o despus de su uso. */
54
temp1 = 1;
55
temp1--;
10
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

++temp1; // temp1 vuelve a valer 1
System.out.println("Se escribir 0: " + --temp1);
temp1 = 1;
System.out.println("Se escribir 1: " + temp1--);
/* Otros operadores de asignacin */
temp1=10;
temp1+=20; // temp1 valdr ahora 30
/* ESTRUCTURAS DE SELECCION: IF */
boolean flag=true;
if ((flag!=true) || (7<(1+7)))
{
System.out.println("Se cumple la condicin.");
}
/* ESTRUCTURAS DE SELECCION: IF-ELSE */
if (flag!=true)
{
System.out.println("Se cumple la condicin.");
}
else
{ // no hacen falta las llaves si slo hay una sentencia
System.out.println("No se cumple la condicin.");
}
/* Se puede declarar variables en cualquier punto del
* programa, aunque no es recomendable hacerlo */
int x=1, y=2, z=3;
if (z<4)
{
if (6>x)
{
if (8>y)
{
System.out.println("Estructuras de control anidadas");
}
}
}
int dia=2;
if (dia==1)
{
System.out.println("Lunes");
}
else if (dia==2)
{
System.out.println("Martes");
}
else if (dia==3)
{
System.out.println("Mircoles");
}
else if (dia==4)
{
System.out.println("Jueves");
}
else if (dia==5)
{
System.out.println("Viernes");

117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
}
/* ESTRUCTURAS DE SELECCIN: SWITCH */
switch(dia)
{
case 1:
System.out.println("Lunes");
break;
case 2:
System.out.println("Martes");
break;
case 3:
System.out.println("Mircoles");
break;
case 4:
System.out.println("Jueves");
break;
case 5:
System.out.println("Viernes");
default:
System.out.println("Ninguno de los anteriores");
}
switch(dia)
{
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("Da Laborable");
break;
case 6:
case 7:
System.out.println("Fin de Semana");
break;
default:
System.out.println("Error. No es un da de la semana");
}
/* ESTRUCTURAS DE SELECCIN: OPERADOR CONDICIONAL */
System.out.print("El mayor es ");
System.out.println(x>y ? x: y);
/* ESTRUCTURAS DE REPETICIN: WHILE */
int i = 5;
while (i>0)
{
System.out.println("Paso por el bucle while 5 veces.");
i--;
}
i = 5;
while (i-->0)
{
System.out.println("Paso por el 2do bucle while 5 veces.");
}
i = 4;
while (--i>0)
{
System.out.println("Paso por el 3er bucle while 3 veces.");
}
11
12
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
/* ESTRUCTURAS DE REPETICIN: DO-WHILE */

i=4;
do
{
System.out.println("Paso por el bucle do-while 5 veces.");
}
while (i-->0);
do
{
System.out.println("El do-while ejecuta al menos 1 vez.");
}
while (10>100);
/* ESTRUCTURAS DE REPETICIN: FOR */
for (int k=1; k<6; k++)
{
System.out.println("Esta es la ejecucin nmero " + k +
" del primer bucle for.");
}
/* ROMPER EL FLUJO: break (evitarlo siempre que se pueda) */
int miNumero = 1853;
i=0;
do
{
if (i==miNumero)
{
System.out.println("Tu nmero era el " + i);
break; // se rompe el flujo.
}
i++;
}
while(true);
/* ROMPER EL FLUJO: continue(evitarlo siempre que se pueda) */
for (int k=1;k<11;k++)
{
if (k%2!=0)
{
continue;
}
else
{
System.out.println("El nmero " + k + " es par.");
}
}
13
227
/* MANEJO DE EXCEPCIONES */
228
int numero = 0, intentos = 0;
229
Scanner teclado = new Scanner(System.in);
230
do {
231
try {
232
System.out.println("Introduce un nmero entre 0 y 10: ");
233
numero = teclado.nextInt();
234
}
235
catch(InputMismatchException e)
236
{
237
System.out.println("Error en la lectura.");
238
}
239
finally
240
{
241
intentos++;
242
}
243
}
244
while (numero<0 || numero>10);
245
System.out.println("Ha habido " + intentos + " intentos.");
246
247
/* CONVERSIN DE TIPOS */
248
float base;
249
//base = 3.4; // esto sera un error
250
base = 3.4f; // indica que 3.4 es un valor de simple precisin
251
base = (float) 3.4; // conversin forzada de tipo, "casting"
252
int baseEntera;
253
// baseEntera = base; // esto sera un error
254
baseEntera = (int) base; // conversin forzada de tipo
255
//(puede haber prdida de informacin)
256
double baseDoblePrecision=base;//conversin automtica de tipo
257
//(no hay riesgo de prdida de informacin)
258
// Cmo pasar de cadena de texto a un nmero entero?
259
int enteroConvertido = Integer.parseInt("356");
260
double realConvertido = Double.parseDouble("43.32");
261
System.out.println("Nmeros convertidos: " + enteroConvertido
262
+ " y " + realConvertido);
263
} // main
264 } // SegundaClase
14
2.4.2 Programa 2
5 public class Ejemplo {
6
7
public static void main (String [] args)
8
{
9
final double PI = 3.1416; //declaramos la pi como constante */
10
double base, altura, areaTriangulo;
11
12
// rea de un tringulo, suponemos cantidades reales
13
base = 10.5;
14
altura = 12.3;
15
16
areaTriangulo = base * altura / 2;
17
18
System.out.println("El rea de un tringulo cuya base es " +
19
base + " y cuya altura es " + altura + " es " +
20
areaTriangulo);
21
22
/* permetro de la circunferencia, suponemos cantidades reales
23
double radio, perimetroCircunferencia;
24
25
radio = 3.4;
26
27
perimetroCircunferencia = 2*PI*radio;
28
29
System.out.println("El permetro de la circunferencia de radio"
30
+ radio + " es " + perimetroCircunferencia);
31
32
// rea de una circunferencia, suponemos cantidades reales
33
double area_circunferencia;
34
35
radio = 2.5;
36
37
area_circunferencia = PI*radio*radio;
38
39
System.out.println("El rea de una circunferencia de radio "
40
+ radio + " es " + area_circunferencia);
41
}
42 }
15
3 Clases y Objetos
3.1 Objetivos
Durante este captulo se intentar que el alumno aprenda conceptos tericos esenciales
para poder programar con un lenguaje orientado a objetos como es Java. En concreto en
esta clase se estudiar el concepto de clase, su estructura (atributos, mtodos y mtodos
constructores), y la forma de crear objetos.
3.2 Clase
En el ejemplo anterior, para definir un tringulo necesitbamos distribuir el concepto de
tringulo en dos variables (base y altura) y algunas funciones como el clculo del rea. Nos
gustara disponer de un tipo Tringulo que incluyese esas dos variables y fuese adems
capaz de realizar operaciones sobre s mismo como calcular su rea y su permetro, o
imprimirse en pantalla. Esa es la idea de las clases, que son tipos de datos ms complejos y
evolucionados que los tipos primitivos que hemos manejado hasta el momento.
Se puede definir una clase como una descripcin de un tipo de objeto. Tambin podemos
definir una clase como un molde que permite crear objetos. Igual que declaramos variables
de un determinado tipo, podemos declarar objetos de una determinada clase. Obsrvese la
analoga entre tipo y clase, y entre variable y objeto:
variable objeto
tipo clase
Por ejemplo:
int x; declaro la variable x del tipo entero
Cliente c; declaro el objeto c de la clase Cliente
Las clases nos permiten definir nuestros propios tipos, ms elaborados y con ms
funcionalidades.
La clase est formada por las caractersticas que la definen, tambin llamadas atributos, y las
acciones que puede llevar a cabo, que pasaremos a llamar mtodos.
La estructura que tiene una clase se muestra en el siguiente ejemplo:
tipoAcceso class NombreClase
{
tipoAcceso TipoAtributo nombreAtributo;
tipoAcceso TipoDevuelto nombreMtodo (TipoParametro1
nombreParametro1, TipoParametroN nombreParametroN)
{
Tipo nombreVariableLocal;
sentencias;
/* Si el tipo de retorno es distinto del void tendr que tener
la palabra reservada return */
}
}
16
Las clases se crean cuando:
Hay un concepto nuevo de un problema a solucionar.

Cuando hay un tipo de datos nuevo.
A veces se puede crear una clase slo para contener el mtodo main del
programa, sin responder a ningn concepto o tipo de datos.
3.2.1 Atributos
Como se pudo ver en la estructura de la clase los atributos son variables, y se declaran de la
misma forma que stas. Su estructura es:
tipoAcceso tipoAtributo nombreAtributo;
Por ejemplo:
private int baseTriangulo;
El tipo de acceso puede ser de varios tipos: public, protected o private. Si no se pone
nada, se interpreta que es tipo paquete (se explicar en la siguiente clase).
Si declaramos un atributo con tipo de acceso public se puede acceder libremente al
atributo cuando se declare un objeto.
Si declaramos un atributo con tipo de acceso private slo se puede acceder a dicho
atributo desde dentro de la clase que define dicho atributo.
Si no se pone nada se puede acceder libremente al atributo cuando se declare un objeto,
pero siempre desde el mismo paquete (esto se ver ms adelante).
El tipo de acceso protected se explicar cuando se estudie el tema de la herencia.
Adems los atributos se pueden inicializar directamente en la declaracin o a travs de los
mtodos. Si se hiciera en la declaracin se hara de la siguiente manera:
tipoAcceso tipoAtributo nombreAtributo = valorInicial;
Por ejemplo:
public int contador = 0;
Si no se inicializan los atributos ni de la anterior forma ni mediante mtodos, se inicializan

por defecto, esto quiere decir que los atributos que sean numricos se iniciarn a 0, el
booleano false y los otros a null, siendo null lo equivalente a un valor nulo.
3.2.2 Mtodos
Los mtodos determinan el comportamiento de los objetos. Se declaran como se vio en la
estructura de clase. Los objetos creados de una clase tendrn disponibles los mtodos
declarados en ella. Los mtodos se pueden clasificar en tres tipos:
Mtodos de consulta, que sirven para extraer informacin (de los atributos) de los
objetos. Son los llamados mtodos get.
Mtodos de modificacin, que sirven para modificar uno o varios atributos de de
los objetos. Son los llamados mtodos set.
Mtodos de comportamiento, que realizan operaciones relacionadas con los
objetos.
En cuanto a la estructura de mtodo, se declara dentro de la estructura de clase:
17
tipoAcceso TipoDevuelto nombreMtodo (TipoParametro1

nombreParametro1, TipoParametroN nombreParametroN)
{
Tipo nombreVariableLocal;
sentencias;
/* Si el tipo de retorno es distinto del void tendr que tener
la palabra reservada return */
}
Por ejemplo:
public int suma (int sumando1, int sumando2, int sumando3)
{
int resultado; // variable local
resultado = sumando1 + sumando2 + sumando3;
return resultado;
}
El tipo de acceso en los mtodos es idntico al de los atributos. Se recomienda a los

alumnos que utilice los mtodos con el tipo de acceso pblico, a no ser que quieran realizar
una accin que slo sea necesaria dentro de la clase. En este caso cuando se cree un objeto
no se podr hacer la llamada al mtodo que sea creado como acceso privado.
El TipoMetodo puede ser void, que significa que el mtodo no devuelve ningn valor, o
cualquier otro tipo o clase (int, String, Persona, etc.). Si se pone esto es necesario que
dentro del mtodo se defina una sentencia de esta forma:
return valorADevolver;
La variable valorADevolver tiene que ser del mismo tipo que el tipo que devuelve el
mtodo.
Dentro de un mtodo se pueden pasar valores mediante los parmetros (comportndose
como variables). Si los valores que se introducen son de tipo primitivo (int, float, double,
etc) se pasan los parmetros por valor, mientras que si los parmetros son objetos
(Persona) se pasan por referencia.
Paso por valor quiere decir que lo que se pasa es una copia de la variable, de forma que la
modificacin de dicho parmetro en el mtodo no afectar a la variable original.
Paso por referencia quiere decir que lo que se pasa es la referencia a la posicin de
memoria donde est almacenada la variable, de forma que cualquier modificacin que se
haga al valor del parmetro se estar haciendo en realidad en la variable original.
Las variables locales son variables que se declaran dentro de la estructura del mtodo y
slo se usan dentro de ste.
3.2.3 Autorefencia this

Es una referencia especial para que se pueda nombrar a los elementos de la propia clase
dentro de ella. Aunque puede usarse siempre, es slo obligatorio usarla cuando surjan
problemas de ambigedad. Por ejemplo, supongamos que el atributo de una clase y un
parmetro se denominan de igual forma. Cmo se puede saber dentro del mtodo que
tiene ese parmetro si estamos hablando del parmetro o del atributo? Ejemplo:
18
...
private int edad; // atributo edad
...
public void setEdad(int edad)
{
this.edad = edad;
// distinguimos el atributo de la clase, edad, del parmetro
}
Cuando un mtodo llama a otro mtodo de la misma clase hablamos de llamada a mtodo
interno.
3.2.4 Mtodo constructor

Son mtodos que realizan la construccin del objeto. Cuando declaramos una variable
entera, por ejemplo:
int x;
El compilador de Java reserva memoria para dicha variable y x pasa a ser una referencia
(apuntador) a ese espacio de memoria. Por tanto la variable ya puede comenzar a usarse,
por ejemplo dndole valores:
x = 5;
Sin embargo, con los objetos no ocurre lo mismo, y no podemos escribir lo siguiente:
Persona juan;
juan.setEdad(34);
juan.setNombre(Juan Rodrguez);
Esto es as porque lo que estamos declarando es una referencia a un objeto de la clase

Persona (un apuntador), pero no hemos reservado el espacio en memoria para este objeto.
Para reservar este espacio debemos utilizar el constructor de la clase. El constructor es un
mtodo especial que se llama igual que la clase en cuestin y que no tiene tipo de retorno.
Aparte de reservar espacio en memoria, se suele aprovechar el mtodo constructor para dar
valores iniciales a los atributos del objeto, y por tanto particularizarlo. Por ejemplo:
public Persona(String nombre, int edad, long dni)
{
this.nombre = nombre;
this.edad = edad;
this.dni = dni;
}
Si no nos interesa dar valores iniciales, escribiramos:

public Persona()
{
}
Sin embargo este constructor es tan sencillo que Java no exige que lo escribamos, sino que
lo utilizar automticamente en caso de que no aportemos ningn otro constructor (como
el del ejemplo anterior). Con este constructor por defecto se asignarn a los atributos de
19
estos los valores por defecto explicados anteriormente (null, 0, false, etc.). Es importante
destacar que este constructor por defecto que nos ofrece Java sin necesidad de escribirlo no
estar disponible en caso de que nosotros escribamos nuestro propio constructor. Nota: Si
dentro del constructor se produce una excepcin el objeto no se crea.
3.2.5 Sobrecarga
Hay sobrecarga cuando existen varios mtodos que se llaman igual pero que pueden usar
parmetros distintos y/o devuelven resultados distintos.
3.3 Objetos
Los objetos son elementos que se forman a partir de las clases. Van a tener todos los
atributos o cualidades que se definieron en las clases de forma particularizada y van a
poder realizar las acciones definidas en las clases.
Para crear objetos es necesario ejecutar est sentencia, llamando al mtodo constructor:
TipoClase nombreObjeto = new TipoClase();
Por ejemplo:
Persona juan = new Persona(Juan Jimnez, 54,
2535434);
Esta sentencia lo que hara es declarar una variable (juan) del tipo de la clase (Persona). Para
que se cree un objeto hay que llamar al constructor. En el ejemplo de arriba se llama al
constructor por defecto ya que no se incluyen los parmetros. Si no se escribiera la parte
correspondiente al new TipoClase() no se creara el objeto y por tanto dara un error de
compilacin al utilizarlo.
Una vez creado el objeto para poder acceder a sus atributos se podra realizar de dos
maneras:
Si los atributos se han declarado public o no se ha puesto nada en el tipo de

acceso, se podr acceder al valor del atributo de esta forma:
nombreObjeto.atributo
Si el atributo se ha declarado con el tipo de acceso private no se puede acceder al

atributo directamente desde el objeto. Entonces es necesario crear mtodos set y
get que permitan acceder al atributo (tanto para modificarlo como para leer su
valor). Por ejemplo, si creamos el siguiente mtodo:
int getEdad()
{
return edad;
}
Entonces podremos acceder al valor del atributo de esta forma:

int edad = juan.getEdad();
20
Como norma de encapsulacin se suelen declarar los atributos como private y se accede
a la informacin de stos a travs de los mtodos set y get.
3.3.1 Referencias compartidas: alias

Es posible que dos variables del TipoClase referencien (apunten) a un nico objeto. Por
ejemplo si declaramos una variable:
Persona juan = new Persona();
Y a continuacin declaramos otra variable y le asignamos el valor de la primera:

Persona raul = juan;
En este caso no tenemos dos objetos juan y raul, sino dos referencias al mismo objeto, ya
que como se explic antes, slo se crea el objeto en memoria cuando se ejecuta el
constructor Persona().
Por tanto puede haber muchas referencias distintas que apunten a un solo objeto.
3.4 Ejemplo de cdigo

Retomamos el ejemplo de las figuras, ahora con orientacin a objetos.
Un programa orientado a objetos es ms sencillo y fcil de leer, ya que se limita a crear
instancias de objetos y pedirles que hagan cosas:
1 public class Test {
2
3
public static void main(String [] args)
4
{
5
// TRINGULO
6
Triangulo t = new Triangulo();
7
t.setAltura(4.34);
8
t.setBase(3);
9
double areaTriangulo = t.getArea();
10
System.out.println("El rea del tringulo de lado " +
t.getBase() + " y altura " +
11
+ t.getAltura() + " es " + areaTriangulo);
12
// CIRCUNFERENCIA
13
Circunferencia c = new Circunferencia(2.34);
14
System.out.println("El permetro de la circunferencia de radio"
+ c.getRadio() + " es " +
15
c.getPerimetro() + " y su rea es " + c.getArea());
16
}
17 }
Lgicamente el trabajo no est en esta clase Test, sino en programar previamente las clases
Triangulo y Circunferencia. Por tanto en programacin a objetos primero se crean clases
para representar los tipos de datos complejos que se utilizarn, y posteriormente se crea
una clase general (que solemos llamar Principal, Test o nombres similares) en la que se
utilizan esas clases.
Clase Triangulo:
1 public class Triangulo {
2
3
private double base;
4
private double altura;
5
6
public double getAltura()
7
{
8
return altura;
9
}
10
public void setAltura(double altura)
11
{
12
this.altura = altura;
13
}
14
public double getBase()
15
{
16
return base;
17
}
18
public void setBase(double base)
19
{
20
this.base = base;
21
}
22
23
public double getArea()
24
{
25
return ((this.base * this.altura) / 2);
26
}
27 }
Clase Circunferencia:
1 public class Circunferencia {
2
3
private double radio;
4
private double area;
5
private double perimetro;
6
private final double PI = 3.1416;
7
8
public Circunferencia(double radio) {
9
super(); // no es necesario
10
this.radio = radio;
11
this.area = this.PI * this.radio * this.radio;
12
this.perimetro = 2 * this.PI * this.radio;
13
}
14
15
public double getRadio() {
16
return radio;
17
}
18
19
public double getArea() {
20
return area;
21
}
22
23
public double getPerimetro() {
24
return perimetro;
25
}
26 }
21
22
3.5 Elementos de clase

Existen elementos de una clase (entendiendo por elementos tanto mtodos como
atributos) que estn disponibles cuando creamos un objeto de una determinada clase:
miObjeto.atributo
Pero tambin existen elementos que estn disponibles acudiendo directamente a la clase, y
no al objeto (que puede no existir), por ejemplo el mtodo main, o:
System.out.println(hola);
Cmo es posible esto? Porque llevan el modificador static, lo que significa que son
elementos de clase. Estos elementos son compartidos por todas las instancias de las clases, por
tanto su particularidad es que no existe un elemento por cada objeto, sino un nico
elemento para toda la clase.
3.6 Clases predefinidas

Java aporta muchas clases predefinidas, que no necesitan ser importadas y que estn
siempre disponibles para el programador.
Las primeras que vamos a estudiar son las clases envoltorio (wrappers), que
corresponden a cada tipo primitivo y que aportan interesantes mtodos de clase,
habitualmente relacionados con la conversin de datos a dicho tipo. Ya vimos algn
ejemplo en las primeras clases, como cuando convertamos una cadena de texto leda por el
usuario a un nmero entero:
Integer.parseInt("345");
El otro tipo de clases predefinidas no tiene que ver con tipos primitivos, sino que
simplemente ofrece funcionalidades que nos sern de inters, por ejemplo la de elementos
matemticos (Math). As, en lugar de describir nosotros mismos la constante PI, podemos
tomarla de la clase predefinida Math:
double perimetro = 2 * Math.PI * radio;
3.7 mbitos
Los bloques, delimitados en Java por los smbolos { y }, definen mbitos de
declaracin. Esto significa que en cada bloque tendremos acceso a un determinado
conjunto de elementos (ya sean clases, atributos, mtodos, variables locales). Trabajemos
con un ejemplo:
1 class c1
2 {
3
int x , y ;
4
public void m1
5
{
6
x = y;
7
this.m2 (y)
8
} //m1
9
public void m2
10
{
11
int z;
12
x = y;
13
this.m1 ( )
14
} //m2
15 } //c1
( )
;
( int y )
23
Las llaves de las lneas 2 y 14 delimitan el mbito ms general: el de la clase c1. Toda clase
determina, pues, un mbito de declaracin. Dentro de esta clase estarn accesibles los
smbolos c1, x, y, m1 y m2.
El mtodo m1 define un nuevo mbito, que abarca las lneas 4 8. En este mbito estn
accesibles los identificadores anteriores. El mtodo m2, por su parte, abarca las lneas 9
13, y en l estn disponibles los mismos smbolos anteriores, pero con dos particularidades:
por un lado, este mbito incluye la variable z. Por otra parte (y esto es muy importante) est
disponible el parmetro y, que en este caso sobreescribe al atributo de clase. Es decir,
ante la coincidencia de nombres se interpreta que cualquier referencia a y se referir al
smbolo ms cercano, en este caso el parmetro. Sin embargo, obsrvese que el atributo de
la clase seguira en este caso accesible mediante el uso de this.y.
Obsrvese que en Java no podemos referenciar una variable si no se ha declarado antes,
pero en el caso de atributos y mtodos es diferente y puedo, por ejemplo, llamar a un
mtodo cuya especificacin se hace ms adelante en el cdigo (lnea 7). Tambin
podramos, si quisiramos, poner la lnea 3 al final, entre las lneas 14 y 15; sin embargo la
lectura de una clase se hace ms fcil si declaramos los atributos primero y los mtodos
despus.
3.8 Paquetes
Los paquetes son una forma de agrupacin de clases, y contribuyen a conseguir la
encapsulacin, uno de los principios fundamentales de la programacin orientada a objetos.
El primer nivel de encapsulacin es la clase, que agrupa datos y funciones (atributos y
mtodos). El paquete constituye un segundo nivel, permitiendo la agrupacin de clases y
tambin de otros paquetes (llamados subpaquetes).
El uso de paquetes facilita la reutilizacin de ciertos componentes que ya han sido escritos,
y mejora tambin la organizacin y estructura de nuestro cdigo. Al igual que otros
lenguajes, esta organizacin se realiza mediante libreras o, si hablamos de Java, "packages".
Los paquetes no son slo una agrupacin conceptual, sino que se corresponden con una
agrupacin fsica. En concreto, en la mayora de entornos de programacin cada paquete se
corresponde con un directorio, y las clases incluidas en el paquete se encuentran
almacenadas en dicho directorio. De igual forma, un subpaquete se correspondera con un
subdirectorio.
Para indicar que una clase pertenece a un paquete se incluye una primera lnea en el archivo
de clase indicando package y el nombre del paquete.
En el ejemplo de las reas y permetros podramos crear un paquete llamado figuras: para
ello insertaramos la siguiente lnea en la cabeza de los archivos Triangulo.java y
Circulo.java:
package figuras;
El nombre del paquete debe tener algn sentido segn las clases que agrupa, de forma que
un programador pueda hacerse una idea de lo que encontrar al importarlo.
Y cmo se importa un paquete, independientemente de si lo hemos programado nosotros
o no? Para ello estn las sentencias de importacin, que se incluyen tambin en la cabecera
(conviene ponerlas despus de la sentencia package, para que lo primero que se vea
siempre es el paquete al que pertenece la clase que estamos programando). Hay diferentes
formas de importacin:
24
1. Importar un solo elemento: slo estar disponible la clase indicada.

import figuras.Triangulo;
...
Triangulo t1 = new Triangulo();
// Circulo c1 = new Circulo();
error!!
...
2. Importar el paquete: hay que identificar cada elemento importado.

import figuras;
...
figuras.Triangulo t1 = new Triangulo();
figuras.Circulo c1 = new Circulo();
...
3. Importar todos los elementos del paquete.
import figuras.*;
...
Triangulo t1 = new Triangulo();
Circulo c1 = new Circulo();
...
Slo se admite una lnea package, por tanto una clase no puede pertenecer
simultnteamente a dos paquetes. Si por algn motivo quisiramos incluir la clase Triangulo
en otro paquete habra que hacer una copia del archivo y cambiar la instruccin package.
Sin embargo la solucin natural ser dejar Triangulo en el paquete figuras y, en caso de
necesitar dicha clase en otro programa, importar el paquete figuras al completo.
Hay muchas empresas y programadores desarrollando paquetes, por lo que se hizo
necesario gestionar su organizacin para que los nombres no coincidieran, y tambin para
conocer el origen del paquete. En este sentido Java hereda las convenciones del mundo de
Internet, en el que se garantiza que cada dominio es nico, representando cada paquete por
el dominio web de la empresa que lo ha desarrollado. Para ello se utiliza el delimitador .,
que nos sirve tambin para navegar por paquetes y subpaquetes. El dominio web, para
localizarse ms fcilmente, se pone al revs.
Algunos ejemplos:
package com.empresa.mi.figuras;
import com.sun.eng.*;
import com.apple.quicktime.v2;
25
3.9 Derechos de acceso

Los modificadores de visibilidad ya se vieron en clases anteriores, y se resumen en la
siguiente tabla:
Modificador
Sintaxis
Visibilidad
Privada
private int x;
Slo dentro de la clase
Por defecto
int x;
Clases dentro del paquete
Protegida
protected int x;
Clases dentro del paquete y subclases

dentro o fuera del paquete
Pblica
public int x;
Todas las clases
Ahora podemos entender los privilegios relacionados con los paquetes, pero an no
hemos visto el concepto de subclases, que se reserva para la siguiente clase.
26
3.10 Programas de ejemplo

Creacin de la clase alumno:
1 public class Alumno
2 {
3
/*A continuacin se observan las cualidades
4
o atributos que tienen los alumnos*/
5
6
private String nombre;
7
private String apellidos;
8
private int aoDeNacimiento;
9
private int numeroPersonal; // identificativo nico
10
/*Cuando se cree el objeto se inicializarn
11
por defecto los siguientes atributos*/
12
private String grupo = "OTROS";
13
private char horario = 'T'; // 'M' maana 'T' tarde
14
15
/* se crean los mtodos constructores si es necesario,
16
si no cuando se cree un
17
bjeto se utilizara el constructor por defecto.
18
Nota: si declaramos aqu un constructor el constructor
19
por defecto dejara de funcionar */
20
21
public Alumno (String nombre, String apellidos,
22
int parAoDeNacimiento,int parNumeroPersonal)
23
{
24
25
this.apellidos = apellidos;
26
aoDeNacimiento = parAoDeNacimiento ;
27
numeroPersonal = parNumeroPersonal;
28
29
}
30
31
/* En la estructura de la clase se declara
32
a continuacin las acciones o
33
mtodos que pueden llevar a cabo */
34
35
// Estos son los mtodos modificadores
36
public void setNombre(String nombre)
37
{
38
/* Se utiliza la autorefencia this para
39
discernir entre el atributo y el parmetro */
40
41
}
42
43
public void setApellidos(String apellidos)
44
{
45
this.apellidos = parApellidos;
46
}
47
48
public void setAoDeNacimiento(int parAoDeNacimiento)
49
{
50
aoDeNacimiento = parAoDeNacimiento;
51
}
52
53
public void setNumeroPersonal(int parNumeroPersonal)
54
{
55
numeroPersonal = parNumeroPersonal;
56
}
57

58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
public void setGrupo(String parGrupo)

{
grupo = parGrupo;
}
public void setHorario(char parHorario)
{
horario = parHorario;
}
public void ponCurso (String parGrupo, char parHorario)
{
grupo = parGrupo;
if (numeroPersonal > 35 )
{
horario = 'T';_
}
else
{
horario = parHorario;
}
}
/* Este mtodo est sobrecargado ya que
se crea dos veces con distintos parametros */
public void ponCurso (String parGrupo)
{
grupo = parGrupo;
if (numeroPersonal > 70 )
{
horario = 'M';
}
}
// Estos son los mtodos de consulta
public String getNombre()
{
return this.nombre;
}
public String getApellidos()
{
return apellidos;
}
public int getAoDeNacimiento()
{
return aoDeNacimiento;
}
public int getNumeroPersonal()
{
return numeroPersonal;
}
public String getGrupo()
{
return grupo;
27
28
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139 }

}
public char getHorario()
{
return horario;
}
// mtodos de comportamiento
public void imprime ()
{
System.out.println("Nombre: " + nombre +
+ " Apellidos: " + apellidos);
System.out.println("Ao de nacimiento: " + aoDeNacimiento);
System.out.println("Nmero personal: " + numeroPersonal);
/* Se puede acceder desde la clase
al atributo o llamando al mtodo*/
System.out.println("Grupo: " + grupo + " horario: "
+ getHorario());
System.out.println();
}
// fin de la clase Alumno
Una vez creada la clase Alumno ya podemos crear objetos de dicha clase para poder
trabajar con alumnos concretos, para ello vamos a crearnos otra clase llamada TerceraClase
que tendr un mtodo main. Esta clase se almacenar en la misma carpeta que la clase
Alumno porque de lo contrario no funcionara con lo estudiado hasta ahora. Esta clase
crear alumnos y realizar varias acciones con ellos. Si se hubiera querido se hubiera podido
crear el mtodo main en la misma clase Alumno, pero para ver la utilidad de la reutilizacin
de clases hemos decidido no realizar el mtodo main en dicha clase.
1 public class Test
2 {
3
4
public static void main (String []args)
5
{
6
/* Declaramos un objeto de tipo Alumno y lo creamos,
7
observar que no podriamos utilizar el constructor
8
por defecto Alumno() ya que en la clase Alumno ya hemos
9
definido un constructor nuevo con parametros */
10
Alumno guille = new Alumno("Guillermo","Puertas",1955,36);
11
guille.ponCurso("FUND_INF",'M');
12
guille.imprime();
13
/*Al declarar una nueva referencia al objeto y asignarle
14
el antiguo objeto no se crea un objeto nuevo sino que las
15
dos referencias guille y alumno1 apuntan al mismo
16
objeto. Se puede observar al imprimir el alumno1*/
17
18
Alumno alumno1 = guille;
19
alumno1.imprime();
20
/* Si queremos que el alumno1 tenga unos datos distintos
21
tendremos que crear otro objeto distinto al de guille,
22
de la siguiente forma */
23
24
alumno1 = new Alumno("Linus","Torvalds",1969,22);
25
guille.ponCurso("FUND_INF",'M');
26
alumno1.imprime();
27
}
28 }
29
3.11 Enumerados
Existe un tipo de clase un poco especial, que define tipos de datos enumerados.
Supongamos que queremos describir en un atributo un da de la semana, o el turno en que
un alumno de un curso est matriculado. Para facilitar esta tarea existen los tipos
enumerados, que slo admiten un rango determinado de valores.
Estos tipos constituyen clases. Para definir los tipos correspondientes a los ejemplos
anteriores crearamos dos clases: Turno y DiasSemana. Su contenido sera distinto al de las
clases que hemos visto hasta ahora:
Contenido del archivo Turno.java:
public enum Turno {MAANA, TARDE, NOCHE}
Contenido del archivo DiasSemana.java:

public enum DiasSemana {LUNES, MARTES, MIERCOLES, JUEVES, VIERNES}
A propsito del ejemplo del turno, obsrvese la siguiente clase de ejemplo y el uso de los
tipos enumerados: el atributo turno se declara como un objeto de la clase Turno que
acabamos de definir.
public class Alumno
{
private String apellido;
private Turno turno;
public Alumno(String nom,String ape, Turno tur)
{
nombre = nom;
apellido = ape;
turno = tur;
}
public static void main (String[] args)
{
Alumno al = new Alumno("Sergio","Lpez",Turno.MAANA);
}
}
30
4 Estructuras de almacenamiento
4.1 Objetivos
Una variable u objeto puede representar un nmero, una cadena de caracteres, un
alumno Qu pasa cuando queremos representar un vector, una matriz o, en general, un
conjunto de valores y no un nico valor? El objetivo de este captulo es dar a conocer
diferentes estructuras de almacenamiento. En concreto, vamos a estudiar los arrays y los
ArrayList.
4.2 Comparacin entre un array y un ArrayList

La diferencia fundamental entre ambas estructuras es que el array es una coleccin de
tamao fijo, mientras que el ArrayList es una coleccin de tamao dinmico. Es decir, al
declarar un array tenemos que conocer de antemano el tamao que queremos que tenga la
coleccin, mientras que en el caso del ArrayList no hace falta que le indiquemos el tamao,
sino que ser l quien automticamente vaya adaptando su tamao al nmero de elementos.
Por lo dems en ambos casos se trata de objetos, por tanto ambos deben inicializarse
mediante el operador new, slo que los arrays son un tipo predefinido y los ArrayList hay
que importarlos del paquete java.util.
Nota: de la Fsica heredamos el nombre del vector para los array de tamao fijo con valores
numricos; sin embargo no recomendamos utilizar este trmino en ningn caso ya que Java
implementa una clase Vector (no estudiada en la asignatura) que se parece mucho a
ArrayList y por tanto es de tamao dinmico. El uso de la palabra vector en programacin,
por tanto, no est claro y conviene evitar dicho trmino para evitar confusiones.
4.3 Array
Cuando se trabaja con varios elementos del mismo tipo podemos declarar un array de dos
formas :
int [ ] arrayEnteros;
String diasSemana[ ];
Todos los elementos del array tendrn que ser del mismo tipo. Observa que el array es un
objeto y debe inicializarse:
arrayEnteros = new int[20];
diasSemana = new String [100];
El nmero entre los corchetes indica el tamao que tendr el array, es decir, el nmero
mximo de elementos que podr contener.
Existe una forma de juntar en una sola sentencia la inicializacin y el relleno del array:
int [] arrayEnteros = {1, 2, 3, 4, 5};
String [] diasSemana = {Lunes, Martes,
Viernes};
Mircoles,
Jueves,
Con estas sentencias fijamos tambin el tamao del vector; este sistema slo es
recomendable si el tamao del array va a ser reducido.
Ahora si queremos acceder e imprimir, segn el ejemplo anterior al martes, tendramos que
hacer lo siguiente:
System.out.println(El da es: + diasSemana[1]);
31
Obsrvese que pedimos la posicin 1: esto es debido a que los elementos de los arrays
empiezan a contar desde 0 y terminan, por tanto, en (nmero de elementos 1).
Para asignar un valor a un elemento de un array slo es necesario decir en que posicin se
encuentra el elemento al que se le quiere asignar el valor.
arrayEnteros[2] = 5;
Esto indica que en la tercera posicin del array arrayEnteros se ha introducido el valor 5.
Adems de los arrays de una dimensin puede haber arrays de dos, tres, cuatro n
dimensiones. Por ejemplo, un array de dos dimensiones y valores numricos representa lo
que conocemos como matriz. Este tipo de arrays se declararan, por ejemplo, de la
siguiente forma:
int [ ][ ] tabla;
y se iniciaran de la siguiente manera:

tabla = new int [5][7];
4.4 ArrayList
A diferencia de los arrays, cuyo tamao es fijo, las colecciones en Java (de las que ArrayList
es un ejemplo) son estructuras de almacenamiento que crecen dinmicamente. Esto quiere
decir que no tienen un tamao determinado: se les puede asignar un tamao de inicio, pero
ste variar automticamente si se introducen ms elementos a la estructura.
Otra diferencia de los arrays con las colecciones, como ya avanzamos antes, es que estas
ltimas deben importarse del paquete java.util. Dentro de las posibles colecciones a
estudiar vamos a centrarnos en la clase ArrayList, que se declara as:
ArrayList<Integer> arrayEnteros = new ArrayList<Integer>();
ArrayList<Alumno> alumnos = new ArrayList<Alumno>();
Observa que tanto al crear como al inicializar un ArrayList hay que indicar su tipo entre
smbolos de menor y mayor.
En ArrayList no hay forma de inicializar valores como hacamos con los arrays, pero sin
embargo tenemos la opcin de crear un ArrayList copiando en l todos los elementos de
otro. Ejemplo:
ArrayList<Integer> miNuevoArray = new ArrayList<Integer>(otroArray);
A continuacin se resumen algunos de los mtodos ms interesantes que nos ofrece la clase
ArrayList:
boolean add(Object o) Este mtodo aade un nuevo elemento al final de la
lista.
boolean remove(Object o) Este mtodo borra el objeto que se pasa como
parmetro si ste est presente dentro de la lista. Si no est el mtodo devuelve

false.
boolean remove(int i) Este mtodo borra el objeto que se encuentra en la
posicin i de la lista. Si no est el mtodo devuelve false.
int size() Este mtodo es similar al atributo length del array y devuelve el
tamao del ArrayList.
32
boolean contains(Object elem) Devuelve true si el ArrayList contiene el
elemento especificado.
int indexOf(Object elem) Como el anterior, pero devuelve la posicin en
que se encuentra el elemento. Si no est devuelve -1.
boolean isEmpty() Este mtodo comprueba si hay elementos en el ArrayList.
void clear() Borra todos los elementos del ArrayList.
Object get(int index) Devuelve el elemento especificado en la posicin del
ArrayList.
El resto de los mtodos pueden encontrarse en la documentacin que aporta la web de

Java:
http://java.sun.com/j2se/1.5.0/docs/api/java/util/ArrayList.html
4.5 Recorrido de estructuras

Al trabajar con estructuras es inevitable que surja el problema de cmo recorrer sus
elementos y hacer algo con ellos. Para ello utilizamos la estructura de control de flujo
iterativa for; sin embargo, para establecer los ndices del bucle for necesitamos conocer el
tamao de la estructura. Para ello:
En arrays tenemos disponible el atributo length
En ArrayList tenemos el mtodo size()
Recuerda la diferencia porque uno es atributo y el otro es mtodo, aunque representen

exactamente lo mismo (el tamao de la estructura). Tiene sentido que en el caso de los
arrays sea un atributo, puesto que no se va a modificar nunca y es por tanto una propiedad
de los mismos. En el caso del ArrayList, puesto que modificar con el tiempo su tamao, es
ms razonable obtenerlo preguntndolo en cada momento con un mtodo.
Existen tres formas de recorrer una estructura:
Primera: un for normal
Ejemplo con arrays:
for (int i=0; i < diasSemana.length; i++)
{
System.out.println(El da + i + es + diaSemana[i]);
}
Ejemplo con ArrayList:
for (int i=0; i < diasSemana.size(); i++)
{
System.out.println(El da + i + es + diaSemana.get(i));
for(int i=0; i<cuadrados.size(); i++)

{
Cuadrado c = cuadrados.get(i);
c.imprimir();
}
33
Segunda: el iterador, una clase especial de Java para recorrer estructuras, cuya nica
ventaja es que sirve para todo tipo de estructuras (no slo para listas), por tanto es una
ventaja que nosotros no vamos a apreciar en este curso, ya que slo veremos listas.
import java.util.Iterator;
Iterator<Cuadrado> it = cuadrados.iterator();
while (it.hasNext())
{
Cuadrado c = it.next();
c.imprimir();
}
Tercera: Puesto que recorrer una estructura con un for es una accin tan frecuente, Java
ofrece una alternativa ms cmoda. Est disponible tanto para arrays como para ArrayList.
Ejemplo:
for (Integer dia: diasSemana)
{
System.out.println(El da es + dia);
}
for(Cuadrado cuadrado:cuadrados)
{
cuadrado.imprimir();
}
Esta sentencia se entiende como: Sea dia cada uno de los elementos de tipo entero de la
estructura diasSemana. Para cada uno de ellos ejecuta el cdigo contenido en el bucle o
sea cuadrado cada uno de los cuadrados de la coleccin cuadrados: imprime cada uno de
ellos.
Observa que estas variables no son exactamente ndices sino que contienen el valor de cada
elemento de la estructura.Esta alternativa suele ser ms cmoda en todos los casos, pero es
posible que prefiramos la opcin clsica, por ejemplo si necesitamos conocer en cada
momento el ndice i.
Obsrvese que a la hora de recorrer colecciones multidimensionales tenemos que manejar
dos, tres o n ndices. Veamos como ejemplo la inicializadin a 0 de los valores de una
matriz:
int matrizEnteros = new int [3][4];
for (int i =0; i < matrizEnteros.length;i++)
{
for (int j=0;j < matrizEnteros[i].length;j++)
{
matrizEnteros[i][j] = 0;
}
}
34
4.6 Cdigo de ejemplo

// ejemplo de uso de arrays
Circunferencia cir1 = new Circunferencia(10);cir2 = new
Circunferencia(20);
Circunferencia cir3 = new Circunferencia(30);
Circunferencia [] circunferencias;
circunferencias = new Circunferencia[3];
circunferencias[0] = cir1;
// recorrido tradicional de estructuras
for (int i = 0; i < circunferencias.length; i++)
{
System.out.println("El radio de la circunferencia " + i + " es: " +
circunferencias[i].getRadio());
}
ArrayList<Cuadrado> cuadrados = new ArrayList<Cuadrado>();
Cuadrado c1 = new Cuadrado(10);
Cuadrado c2 = new Cuadrado(20);
cuadrados.add(c1);
cuadrados.add(c2);
cuadrados.add(new Cuadrado(30));
// recorrido abreviado de estructuras
for (Cuadrado i_cuadrado: cuadrados)
{
System.out.println("Lado del cuadrado: " + i_cuadrado.getLado());
}
// siempre podemos usar nmeros como elementos:
ArrayList<Integer> arrayEnteros = new ArrayList<Integer>();
arrayEnteros.add(5);
arrayEnteros.add(7);
// recorrido abreviado
for (Integer numero: arrayEnteros)
{
System.out.println(numero);
}
// recorrido tradicional
for (int i=0; i<arrayEnteros.size(); i++)
{
System.out.println(arrayEnteros.get(i));
}
// uso de los mtodos que ofrece la clase ArrayList
// get: recuperar un elemento dado su ndice
Cuadrado cua = cuadrados.get(2);
35
// contains: indica si el elemento est contenido

if (cuadrados.contains(c2))
{
System.out.println("S est contenido");
}
// indexOf: indica si el elemento est contenido, y en qu posicin
System.out.println("Posicin: " + cuadrados.indexOf(c2));
// isEmpty: indica si la coleccin est vaca
if (cuadrados.isEmpty())
{
System.out.println("La coleccin est vaca");
}
else
{
System.out.println("La coleccin no est vaca");
}
// remove: eliminar un elemento dado
cuadrados.remove(c2);
// remove: eliminar el elemento en la posicin dada
cuadrados.remove(0);
// clear: borra todos los elementos
cuadrados.clear();
5 Documentacin de las clases

Las clases de Java se documentan siguiendo un formato estndar en el que se indican y
explican los mtodos disponibles, los parmetros que requieren, el tipo que devuelven
Utilizando comentarios especiales, que se inician con /** en lugar de /*, podemos incluir la
informacin necesaria para que BlueJ (o cualquier otro entorno de desarrollo) genere
automticamente la documentacin del proyecto con la herramienta JavaDoc.
Estos comentarios deben incluirse al inicio de la clase y antes de cada mtodo.
Tras una descripcin inicial, se utilizan cdigos precedidos del smbolo arroba para explicar
nuestro programa. Los cdigos ms bsicos son:
5.1 Antes de la clase:

@author: para indicar el autor de una clase
@version: para indicar la versin de la clase, ya que segn avanza el desarrollo de un
programa se suelen crear diferentes versiones, por ejemplo 1.0, 1.1, 2.0
5.2 Antes de un mtodo:

@param: explicacin de cada parmetro. En este caso, como puede haber varios
parmetros, se incluye el nombre del parmetro concreto (por ejemplo @param x)
@returns: explicacin de lo que devuelve el mtodo
@throws: indica si devuelve alguna excepcin, y en qu caso
36
5.3 Generar la documentacin

Para ver la documentacin con BlueJ puedes utilizar la pestaa situada arriba a la derecha
en el editor de cada clase.
Antes de entregar la prctica debes generar la documentacin de todo el proyecto, para ello
accede al men Herramientas o Tools, y escoge Documentacin de proyecto o
Project documentation.
Ejemplo de documentacin:
37
6 Composicin, herencia y polimorfismo

6.1 Objetivos
El objetivo de este captulo es poder presentar dos mecanismos bsicos para construir
nuevas clases a partir de las ya existentes: la composicin y la extensin.
Para extender clases se hace uso de dos conceptos fundamentales de la programacin
orientada a objetos que son: la herencia y el polimorfismo.
6.2 Composicin
La composicin es la creacin de una clase nueva agrupando objetos de clases
preexistentes. Se encuentra la composicin cuando en una clase se tienen atributos que no
son de tipos primitivos sino que son a su vez instancias de otra clase.
Por ejemplo, supongamos que se quiere crear una clase denominada Billete: esta clase tiene
como atributos el nmero de billete, la fecha de salida y hora, el asiento ocupado, la
localidad de salida y la de llegada y, por ltimo, los datos del viajero. En este caso uno de
los atributos del billete ser el Cliente que lo compr, que es un objeto de la clase Cliente.
La clase tendra la siguiente forma:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.Calendar;
public class Billete
{
private long numBillete;
private Calendar fechaHora;
private int numAsiento;
private String locSalida;
private String locLlegada;
private Cliente cliente;
private int precio;
public Billete (long numBillete, Calendar fechaHora,
int numAsiento,String locSalida, String locLlegada,
Cliente cliente, int precio)
{
this.numBillete = numBillete;
this. fechaHora = fechaHora;
this.numAsiento = numAsiento;
this.locSalida = locSalida;
this.locLlegada = locLlegada;
this.cliente = cliente;
this.precio = precio;
}
}
Ejemplo 1
38
Grficamente la composicin se representara de esta forma:
Billete
Cliente

Private int precio;
private long dni;

public Cliente (long dni,, String
nombre, String apellido)
public Billete (long numBillete,

Calendar fechaHora, int numAsiento,
String locSalida, String locLlegada,
Para reconocer la composicin podemos preguntarnos si, por ejemplo, el billete tiene-un
cliente (en este caso el billete tiene los datos del cliente). Si esto se corresponde entonces
puede que necesitemos composicin cuando desarrollemos aplicaciones.
6.3 Herencia
Una de los pilares de la programacin orientada a objetos es la herencia. Esta se define
como la capacidad de una clase de heredar tanto los mtodos como los atributos de otra
clase. Para que una clase herede de otra la sintaxis que se debe usar en el cdigo es la
siguiente:
public class ClaseHijo extends ClasePadre
{
tipoAcceso TipoAtributo nombreAtributo;
tipoAcceso TipoDevuelto nombreMetodo (TipoParametro1 nombrePar1)
{
TipoVarLocal nombreVarLocal;
sentencias;
}
}
Ejemplo 2
La clase ClaseHijo est formada, adems de los atributos y mtodos que se declaran, de los
que se heredan de la ClasePadre. Es, por tanto, la herencia una relacin de jerarqua.
39
Ejemplo:
La clase Billete Tren tiene los mismos atributos y mtodos que la clase Billete. La diferencia
es que el billete del tren tiene un atributo adicional: la categora. Por eso la clase BilleteTren
sera de la siguiente forma:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.Calendar;
public class BilleteTren extends Billete
{
private String categoria;
public BilleteTren (long numBillete, Calendar fechaHora,
int numAsiento, String locSalida, String locLlegada,
Cliente cliente, int precio, String categoria)
{
super(numBillete,fechaHora,numAsiento,
locSalida,locLlegada,cliente,precio);
}
}
Ejemplo 3
En el anterior ejemplo todos los billetes de tren son tambin billetes, pero no ocurre lo
mismo al revs: no todos los billetes son billetes de tren.
Para reconocer la herencia podemos preguntarnos si, por ejemplo, el billete de tren es-un
billete. Si esto se corresponde entonces puede que necesitemos herencia cuando
desarrollemos aplicaciones.
Un ejemplo grfico de cmo quedara la herencia (incluyendo la composicin anterior)
sera:
Billete
Cliente

Private int precio;
private long dni;

public Cliente (long dni,, String
nombre, String apellido)
public Billete (long numBillete,

BilleteTren
private String categoria;
public BilleteTren (long numBillete,
Cliente cliente, int precio, String
Categoria)
Figura 1
40
6.3.1 Compatibilidad de tipos

Cuando se crea un objeto de una clase hija, se puede hacer una asignacin directa a un
referencia de la clase padre debido a que la clase hija hereda tanto los atributos como los
mtodos de la clase padre. Al revs esto necesita de un casting, ya que la clase derivada
podra no ser compatible debido a que la clase padre no tiene por qu tener todos los
atributos que tiene la hija ni todos sus mtodos.
Ejemplo
Asignacin directa
Billete billete = billeteTren;
Realizacin de casting
BilleteTren billeteTren = (BilleteTren) billete;

Ejemplo 4
Todas las clases heredan de una clase preexistente en el entorno java y denominada Object.
Esto es as siempre, de forma que no es necesario tenerlo en cuenta ni especificarlo en el
cdigo.
6.3.2 mbitos y visibilidad

La clase que hereda puede utilizar de forma normal los atributos de la clase base a no ser
que estos tengan el acceso de tipo private. Recordemos la tabla:
Modificador
Sintaxis
Visibilidad
Privada
private int x;
Slo dentro de la clase
Por defecto
int x;
Clases dentro del paquete
Protegida
protected int x;
Clases dentro del paquete y subclases

dentro o fuera del paquete
Pblica
public int x;
Todas las clases
6.3.3 Reescritura
Supongamos que se tiene una clase base con ciertos atributos y mtodos. Cuando se crea
una clase hija esta puede tener un mtodo con el mismo nombre que la clase base. Este
mtodo se puede reescribir si, por ejemplo, queremos realizar un comportamiento especial
si se trata de la clase hija (como al imprimir los datos en pantalla).
6.3.4 Los constructores

Como se vio en el ejemplo 3 para crear objetos de clases hijas se puede (adems de asignar
como siempre los atributos a sus valores) llamar al constructor de la clase padre mediante la
palabra reserva super. Esto se tendra que realizar en la primera lnea del cdigo del
constructor. Adems si los atributos de la clase base tienen un acceso no private se puede
hacer las llamadas a sus atributos tambin poniendo la sentencia super.
super.numAsiento;
41
6.4 Tabla de compatibilidad

Esta tabla aclara cundo podemos utilizar los conceptos de composicin y herencia:
Composicin
Clase contendora
<<tiene-un>>
Clase contenida
Herencia
Clase hijo
<<es-un>>
Clase base o padre
Composicin
Aula
<<tiene-un>>
Profesor
Herencia
Profesor
<<es-una>>
Persona
Ejemplos:
6.5 Compatibilidad de tipos

Retomemos la propiedad es-un: un Alumno es una Persona. A la hora de considerar la
compatibilidad de tipos se sigue la misma poltica, existiendo compatibilidad hacia arriba, pero
no hacia abajo. Qu significa esto? Un alumno es una persona, pero una persona no es
siempre un alumno.
Esto es interesante porque en Java podemos asignar un mismo objeto a referencias de
distintas clases, segn cmo nos interese ver ese objeto. Ejemplo:
Alumno al = new Alumno();
Persona p = al;
Persona p2 = new Alumno();
La referencia al, de la clase Alumno, alude a un objeto de la clase Alumno.

La referencia p, de la clase Persona, alude a un objeto de la clase Alumno. Esto es
posible por lo que acabamos de comentar: un alumno es tambin (se puede ver como) una
persona.
La referencia p2, de la clase Persona, alude a un objeto de la clase Alumno (misma
explicacin). Tiene esto sentido? S, si imaginamos por ejemplo que yo quiero unificar las
distintas personas para, por ejemplo, hacer una lista con ellas. Qu pasar con las
caractersticas propias del alumno en este caso? Podremos acceder a ellas ms adelante? Es
decir, podremos ver el objeto apuntado por p2 como un alumno?
La respuesta es s, pero con reservas. Hemos dicho que no toda persona es un alumno, por
tanto no podremos decir directamente:
Alumno al2 = p2; // error
Para ello hay que hacer la conversin forzada o casting, que ya conocemos:
Alumno al2 = (Alumno) p2;
Esto funcionar slo si el objeto apuntado por p2 es realmente un alumno. En este caso
es cierto, pero si queremos hacer un cdigo seguro que nos permita cerciorarnos de que la
conversin se har correctamente podemos utilizar este sencillo mtodo:
if (p2 instanceof Alumno)
{
Alumno al2 = (Alumno) p2;
}
else
{
System.out.println(ERROR: no es un alumno);
}
42
6.6 Reescritura y ligadura dinmica

Recordemos que la reescritura consiste en que podemos implementar un mtodo llamado
imprimir en la clase Persona, y reescribir el mismo mtodo en la clase Alumno con la
misma cabecera pero una implementacin distinta. As, el mtodo imprimir de la clase
alumno escribir, adems de los datos personales, el nmero de expediente del alumno.
La reescritura es posible porque Java utiliza ligadura dinmica. En casi todos los lenguajes
existe ligadura esttica, que asocia el nombre de un mtodo (por ejemplo imprimir) de
forma definitiva a un trozo de cdigo. Por el contrario, Java permite que existan varias
implementaciones asociadas a un mismo mtodo, y que se decida en tiempo de ejecucin
cul utilizar. Cmo sabr Java cul debe ejecutarse?
Alumno al = new Alumno();
al.imprimir(); // se usa el mtodo imprimir de la clase Alumno
Persona p = new Persona();
p.imprimir(); // se usa el mtodo imprimir de la clase Persona
p = al; //conversin ascendente, permitida
p.imprimir(); // se usa el mtodo imprimir de la clase Alumno
La respuesta es la siguiente: la ligadura dinmica en Java escoge el mtodo de la clase a la

que pertenezca el objeto, independientemente de su referencia. As, aunque en el ltimo
caso trabajamos con una referencia de la clase Persona, lo cierto es que el objeto al que
apunta dicha referencia es un alumno.
Una ltima cosa sobre reescritura: a la hora de programar el mtodo imprimir de la clase
Alumno, quiz nos interese reutilizar el mtodo imprimir de la clase Persona, puesto que
los datos personales deben imprimirse igualmente. Para ahorrarnos trabajo y no repetir las
sentencias que ya hemos programado, podemos hacer lo siguiente:
class Alumno
{
. . .
void imprimir()
{
super.imprimir();
System.out.println(El nmero de expediente es + nexp);
}
. . .
}
Es decir, mediante super llamamos al mtodo imprimir de la clase padre y luego

completamos el trabajo con la parte especfica que queremos imprimir para un alumno.
6.7 Polimorfismo
La combinacin de herencia y ligadura dinmica se denomina polimorfismo. El
polimorfismo permite que un objeto sea visto de distintas formas (con distintas referencias,
aunque hemos visto que su comportamiento ir determinado por el objeto), y permite que
se puedan defimir e invocar mtodos idnticos en su signatura (nombre y parmetros) pero
diferentes en su implementacin. La relacin con la herencia es evidente, ya que Java slo
permite definir mtodos idnticos en el caso de existir relacin padre-hijo.
43
6.8 Clases abstractas

Si consideramos una clase Mamfero que agrupe las clases Perro, Gato, etc, es posible que
no queramos que un usuario pueda instanciar un objeto de la clase Mamfero, es decir, que
queramos obligarle a instanciar objetos nicamente de las clases hijas. Es eso posible? S,
declarando la clase mamfero como abstracta:
public abstract class Mamfero
{
. . .
}
A esto se le llama herencia forzada, puesto que estamos forzando la herencia al no dar opcin
a crear objetos de la clase padre.
Esto puede extenderse a los mtodos: queremos que todas las clases implementen un
mtodo que sea numeroDePatas que no reciba ningn parmetro y devuelva un nmero
entero. Cmo lo har?
public abstract class Mamfero
{
. . .
public abstract int numeroDePatas();
. . .
}
Es decir, pongo nicamente la cabecera (tipo devuelto, nombre, parmetros, punto y coma)
y obligo as a que todas las clases hijas tengan que implementar dicho mtodo, encontrando
de lo contrario un error de compilacin:
public class Perro
{
. . .
public int numeroDePatas()
{
return 4;
}
. . .
}
44
7 Ejemplos de programas
7.1 Programas sencillos sobre estructuras de control
Ejercicio 1
Reescribir los ejemplos de ruptura de flujo con continue y break incluidos en el
programa inicial de muestra para que no necesiten utilizar estos mecanismos.
Ejercicio 2
Resolver estos tres ejercicios justificando la eleccin de la estructura o estructuras de
control utilizadas en cada uno:
Dado un mes (representado por un nmero del 1 al 12) escribir su nmero de das
contando con una variable booleana bisiesto, previamente declarada e
inicializada, que indica si el ao en curso es bisiesto.
Pedir al usuario cinco cadenas de texto y generar una sola cadena unindolas todas.
Escribir esa cadena por pantalla.
Ir pidiendo por teclado una serie de nmeros enteros e irlos sumando. Se deja de
pedir nmeros al usuario cuando la cantidad supera el valor 50. Escribir por
pantalla la suma de todos los nmeros introducidos.
Pedir al usuario dos nmeros a y b entre el 1 y el 10. Mientras uno de ellos sea
menor que el otro, escribir un smbolo * en la pantalla e incrementar en una
unidad el nmero menor.
Ejercicio 3
Pedir al usuario un nmero entero y calcular el factorial de dicho nmero usando la
estructura do-while. Repetir el ejercicio usando la estructura while, y repetirlo una vez
ms usando la estructura for.
Solucin
3 public class Soluciones
4 {
5 public static void main(String [] args)
6 {
7
Scanner teclado = new Scanner(System.in);
8
9
// Ejercicio 1:
10
11 // Eliminar el continue:
12 for (int k=1; k<11; k++)
13 {
14
if (k%2==0)
15
{
16
17
}
18 }
19
20
// Eliminar el break (solucin 1):
21
int miNumero = 1853;
22
int temp1=0;
23
while (temp1!=miNumero)
24
{
25
temp1++;
26
}
27
System.out.println("Tu nmero era el " + temp1);
28
29
// Eliminar el break (solucin 2):
30
miNumero = 1853;
31
int temp2=0;
32
boolean encontrado = false;
33
while (!encontrado)
34
{
35
if (miNumero == temp2)
36
{
37
System.out.println("Tu nmero era el " + temp2);
38
encontrado = true;
39
}
40
else
41
{
42
temp2++;
43
}
44
}
45
46
// Ejercicio 2:
47
48
// Averiguar el nmero de das de cada mes
49
int mes = 6;
50
boolean bisiesto = false;
51
switch (mes)
52
{
53
case 1:
54
case 3:
55
case 5:
56
case 7:
57
case 8:
58
case 10:
59
case 12:
60
System.out.println("El mes "+mes+" tiene 31 das.");
61
break;
62
case 2:
63
if (bisiesto)
64
{
65
System.out.println("El mes 2 tiene 29 das.");
66
}
67
else
68
{
69
System.out.println("El mes 2 tiene 28 das.");
70
}
71
break;
72
default:
73
System.out.println("El mes "+mes+" tiene 30 das.");
74
} // switch
75
76
// Pedir cadenas de texto y concatenarlas
77
String cadena="";
78
for (int i=0;i<5;i++)
79
{
80
System.out.println("Introduce un texto: ");
81
cadena+= teclado.next();
82
}
83
System.out.println("La cadena completa es: " + cadena);
84
85 //Ir sumando nmeros hasta llegar a 50
45
46
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
int suma=0;
do
{
System.out.println("Introduce un nmero: ");
suma+=teclado.nextInt();
} while(suma<=50);
System.out.println("La suma es " + suma);
//Pedir nmeros entre 1 y 10
int a, b, mayor, menor;
System.out.println("Introduce un nmero entre 1 y 10: ");
a = teclado.nextInt();
System.out.println("Introduce otro nmero entre 1 y 10: ");
b = teclado.nextInt();
if (a>b)
{
mayor = a;
menor = b;
}
else
{
mayor = b;
menor = a;
}
while (menor<mayor)
{
System.out.println("*");
menor++;
}
// Ejercicio 3:
System.out.println("Introduce un nmero: ");
int numero = teclado.nextInt();
int factorial; // Resultado
// Factorial con "for"
factorial = 1;
for(int i=numero; i>0; i--)
{
factorial*=i;
}
System.out.println("El factorial de " + numero +
" calculado con \"for\" da: " + factorial);
// Factorial con "while" (opcin 1)
factorial = 1;
int i = 0;
while(i<numero)
{
i++;
factorial*=i;
}
System.out.println("El factorial de " + numero +
" calculado con \"while\" da: " + factorial);
// Factorial con "while" (opcin 2)
factorial = 1;
int copiaNumero = numero;
while(copiaNumero>0)
{
factorial*=copiaNumero;
47
147
copiaNumero--;
148 }
149 System.out.println("El factorial de " + numero +
150 " calculado con \"while\" da: " + factorial);
151
152 // Factorial con "do-while"
153 factorial = 1;
154 copiaNumero = numero;
155 do
156 {
157
factorial *= copiaNumero;
158
copiaNumero --;
159 } while (copiaNumero>0);
160 System.out.println("El factorial de " + numero +
161 " calculado con \"do-while\" da: " + factorial);
162
163 } // main
164 } // Soluciones
Obsrvese que haba un error en el programa de ejemplo de la clase anterior. El cdigo

correspondiente a la ruptura de flujo con continue sera:
/* ROMPER EL FLUJO: continue(evitarlo siempre que se pueda) */
for (int k=1; k<11; k++)
{
if (k%2!=0)
{
continue;
}
}
7.2 Ejercicio sobre constructores

Parte 1
Desarrollar una clase "Director" dentro de un paquete llamado "ejercicios". La clase tendr
tres atributos privados que representan el nombre, el pas de origen y el ao de nacimiento
de un director. Aadir un constructor con tres argumentos correspondientes a sus tres
atributos. Aadir un mtodo pblico llamado "imprimir", que escriba en pantalla los datos
del director.
Parte 2
Desarrollar una clase "Pelicula" dentro del mismo paquete "ejercicios".La clase tendr tres
atributos privados que representan el ttulo, el ao de produccin y el director de una
pelcula. Aadir tres constructores: uno que reciba nicamente el ttulo, otro que reciba
nicamente el director, y uno que no reciba argumentos. Aadir un mtodo pblico
llamado "imprimir", que escriba en pantalla los datos de la pelcula incluyendo los datos del
director.
Parte 3
Aadir a la clase "Pelcula" los mtodos pblicos getTitulo, setTitulo, getAo, setAo,
getDirector y setDirector. Los mtodos "get" permitirn obtener el valor del atributo en
cuestin, por lo que el tipo de retorno coincidir con el del atributo. Los mtodos "set"
permitirn actualizar el valor del atributo, para lo que recibirn un argumento cuyo tipo
coincidir con el del atributo. Aadir un mtodo "main" a la clase "Pelicula" y realizar los
siguientes experimentos:
48
Experimento1
- Crear un objeto director para Woody Allen, nacido en Francia en 1935.
- Crear un objeto pelcula con el constructor vaco para "Manhattan".
- Aadir al objeto los datos de su ttulo, ao de produccin (1979) y director
(Woody Allen).
- Imprimir los datos de la pelcula por pantalla.
Experimento2
- Crear un objeto director para Peter Jackson, nacido en Nueva Zelanda en 1961.
- Crear un objeto pelcula sabiendo nicamente que se titula "El Seor de los
Anillos".
- Completar el objeto actualizando el ao de produccin (2001) y director (Peter
Jackson).
Experimento3
- Crear un objeto pelcula sabiendo nicamente que ser del director Woody Allen.
- Completar los datos de ttulo ("Das de Radio") y ao de produccin (1987).
Experimento4
- Actualizar el siguiente dato exactamente de la siguiente forma: "el lugar de
nacimiento del director de "Das de Radio" es Estados Unidos".
- Imprimir de nuevo en pantalla los datos de las tres pelculas y observar los
resultados.
Objetivos de los ejercicios
* Practicar con conceptos bsicos de una clase: paquete, atributos, constructor y mtodos.
* Practicar con diferentes constructores.
* Aclarar que los atributos de clase pueden ser objetos de otras clases.
* Practicar con el concepto de sobrecarga al presentar mtodos con el mismo nmero de
argumentos pero distinto tipo.
* Demostrar la utilidad de los mtodos get y set para consultar y actualizar atributos
privados.
Solucin
1 package ejercicios;
2
3 public class Director {
4
5 private String nombre;
6 private String paisOrigen;
7 private int aoNacimiento;
8
9
10 public Director(String nombre, String pais, int ao) {
11
12
this.paisOrigen = pais;
13
this.aoNacimiento = ao;
14 }
15
16 public int getAoNacimiento() {
17
return aoNacimiento;
18 }
19
20 public void setAoNacimiento(int aoNacimiento) {
21
this.aoNacimiento = aoNacimiento;
22 }
23
24 public String getNombre() {
25
return nombre;
26 }
27
28 public void setNombre(String nombre) {
29
30 }
31
32 public String getPaisOrigen() {
33
return paisOrigen;
34 }
35
36 public void setPaisOrigen(String paisOrigen) {
37
this.paisOrigen = paisOrigen;
38 }
39
40 public void imprimir() {
41
System.out.println(this.nombre + ", nacido en " +
42
this.paisOrigen + " en " + this.aoNacimiento + ".");
43 }
44 }
49
50
1 package ejercicios;
2
3 public class Pelicula {
4
5 private String titulo;
6 private int ao;
7 private Director director;
8
9 public Pelicula() {
10 }
11
12 public Pelicula(String titulo) {
13
this.titulo = titulo;
14 }
15
16 public Pelicula(Director director) {
17
this.director = director;
18 }
19
20 public int getAo() {
21
return ao;
22 }
23
24 public void setAo(int ao) {
25
this.ao = ao;
26 }
27
28 public Director getDirector() {
29
return director;
30 }
31
32 public void setDirector(Director director) {
33
this.director = director;
34 }
35
36 public String getTitulo() {
37
return titulo;
38 }
39
40 public void setTitulo(String titulo) {
41
this.titulo = titulo;
42 }
43
44 public void imprimir() {
45
System.out.print("La pelcula \"" + this.titulo + "\" fue
realizada en " +
46 this.ao + " por el director ");
47 this.director.imprimir();
48 }
49
50 public static void main(String[] args) {
51
52 // Experimento 1__
53 Director woodyAllen = new Director ("Woody Allen", "Francia",
1935);
54
55
Pelicula manhattan = new Pelicula();
56
manhattan.setTitulo("Manhattan");
57
manhattan.setAo(1979);
58
manhattan.setDirector(woodyAllen);
59
51
60
manhattan.imprimir() ;
61
62 // Experimento 2
63
Director peterJackson = new Director ("Peter Jackson", "Nueva
Zelanda", 1961);
64
65
Pelicula seorAnillos = new Pelicula("El Seor de los Anillos");
66
seorAnillos.setAo(2001);
67
seorAnillos.setDirector(peterJackson);
68
69
seorAnillos.imprimir();
70
71
//Experimento 3
72
Pelicula diasDeRadio = new Pelicula(woodyAllen);
73
diasDeRadio.setTitulo( "Das de Radio");
74
diasDeRadio.setAo(1987);
75
76
diasDeRadio.imprimir() ;
77
78
//Experimento 4
79
diasDeRadio.getDirector().setPaisOrigen("Estados Unidos");
80
81
manhattan.imprimir();
82
seorAnillos.imprimir();
83
diasDeRadio.imprimir() ;
84 }
85 }
7.3 Ejercicios sobre estructuras de almacenamiento

Escribir un programa que calcule la diagonal de una matriz cuadrada de lado n.
Puedes darle valores fijos o pedirlos al usuario por teclado.
Solucin
1 public class Diagonal
2 {
3 public static void main (String[] args)
4 {
5 // En la solucin a este ejercicio nosotros proponemos dar valores
a la matriz
6 // mediante un pequeo algoritmo para no tener que insertar uno a
uno los valores
7 // en la siguiente matriz que nos creamos de tamao N = 3.
8 // La matriz siguiente quedara de la siguiente forma 1 2 3
9 //
2 4 6
10 //
3 6 9
12
final int N = 3;
14
int [][] matriz = new int [N][N];
15
for (int i= 0 ; i < matriz.length ; i++)
16
for (int j = 0; j < matriz[i].length; j++)
17
matriz[i][j] = (i+ 1)*(j + 1);
18
19 // calculo de la diagonal multiplicando todos
20 // los elementos de la diagonal de la matriz
22
int resDiagonal = 1;
23
for (int i= 0 ; i < matriz.length ; i++) {
24
resDiagonal = resDiagonal * matriz[i][i]; }
26
System.out.println(resDiagonal);
27
}
29 }
52
Escribir un programa que pida al usuario por teclado nmeros que introducir en una
estructura de almacenamiento hasta que el usuario introduzca un 0. Sumar todos los
nmeros que se han almacenado en dicha estructura de control y mostrar el resultado
por pantalla.
Solucin
2 import java.util.ArrayList;
3 public class SumaEstructura
4 {
5 public static void main (String[] args)
6 {
7 // Al no saber a priori el nmero de elementos
8 // que se van a recibir del alumno la estructura
9 // de almacenamiento a utilizar tiene que poder
10 // ser dinamica. Nosotros proponemos el uso del
11 // ArrayList para resolver este ejercicio.
12
13 ArrayList <Integer> almacenNum = new ArrayList <Integer> ();
14
15 Scanner teclado = new Scanner (System.in);
16
17 // incializo el num a un valor que no sea 0 para que si
18 // el usuario no introduce un nmero sino por ejemplo un
19 // caracter pueda seguir pidiendole nmero y no salirse
20 // asi del bucle.
21 int num = -1;
22 do {
23
try
24
{
25
System.out.println ("Introduce un nmero por teclado: ");
26
num = teclado.nextInt();
27
almacenNum.add(num);
28
}
29
catch (Exception e)
30
{
31
System.out.println("Se necesita introducir un nmero para poder
realizar la suma.");
32
teclado.nextLine(); // con esta sentencia hace que no se vuelva a
leer de teclado el mismo valor que no es numrico
33
}
34 }
35 while (num != 0);
36
37 int suma = 0;
38 for (Integer a_num :almacenNum)
39
suma += a_num;
40
41
System.out.println("El resultado de todos los nmeros insertados
es: " + suma );
42
43
}
44 }
Se elige una estructura ArrayList puesto que a priori no se sabe la cantidad de nmeros
que va a introducir el usuario. Si lo hiciramos con un Array necesitaramos saber antes
de insertar los nmeros que cantidad va a insertar el usuario y parar la peticin de
entrada de nmeros cuando se haya llenado el Array.
53
7.4 Ejercicio sencillo con orientacin a objetos

Calcular el rea y el permetro de la siguiente figura:
Para resolverlo, programa las clases Circunferencia, Cuadrado y Triangulo si no las tenas ya
de pruebas anteriores. Despus, en la clase Test, crea los objetos que necesites para resolver
el problema, llama a los mtodos adecuados e imprime por pantalla un mensaje como este:
El rea de la figura completa es 119.13258497228719. El permetro de la figura completa es
62.14822820780803
Pistas necesarias:
Los valores correctos al solucionar el ejercicio son los indicados en el mensaje
En Java, existe una clase llamada Math que permite acceder a la constante Pi, para
ello escribe simplemente Math.PI. No es necesario importar la clase Math, est
disponible siempre.
Necesitars utilizar el teorema de Pitgoras: en un tringulo recto como el de la
figura, la suma de los catetos al cuadrado es igual al cuadrado de la hipotenusa. En
java, la raz cuadrada se hace llamando al mtodo sqrt de la clase Math, al igual que
hacemos Math.PI, hacemos Math.sqrt(9). Ejemplo:
double hipotenusa = sqrt(cateto1*cateto1 + cateto2*cateto2);
54
Solucin:
Observa cmo hay dos formas de ofrecer un valor de resultado:

En el caso del rea, escribimos el clculo directamente en pantalla.
En el caso del permetro, almacenamos el valor del clculo en una variable local
perimetroTotal y despus escribimos por pantalla su valor.
Ambas soluciones son igual de correctas: escoge la que te resulte ms intuitiva. En general,
si ms adelante vamos a usar el valor del clculo para otras cosas preferiremos almacenarlo
en una variable, pero si slo queremos escribirlo por pantalla no es necesario.
55
7.5 Gestor de cuadrados

En las prcticas de la asignatura es habitual tener que hacer gestores, que no es ms que
un nombre que damos a las clases que se encargan de almacenar, aadir, eliminar, buscar,
etc elementos en una estructura. Este ejemplo ofrece una base para abordar este tipo de
ejercicios.
En los gestores utilizaremos habitualmente la estructura ArrayList, puesto que
normalmente no sabemos cuntos elementos tendremos.
Aprovechamos este ejemplo para incluir en el gestor los comentarios adecuados para
generar despus la documentacin con JavaDoc.
Clase Cuadrado
56
Clase GestorCuadrados
Aadiendo nuevos cuadrados:
57
Observa que esto son slo sugerencias de cmo hacerlo: no es obligatorio ni mucho menos
que los mtodos de aadir o borrar devuelvan algn valor, pero resulta cmodo que lo
hagan por dos motivos:
Nos permite abandonar el for directamente con un return cuando ya hemos
terminado.
Al llamar a este mtodo (ya sea desde main o desde otro mtodo de la misma clase),
el mtodo llamante podra obtener como resultado true o false y averiguar si la
operacin sali bien.
58
En ocasiones en un problema de examen se pide algo como esto: Implementa un mtodo que
devuelva los cuadrados de lado menor a uno que se dar como parmetro. En estos casos surge una
confusin: debe devolverlo por pantalla (es decir, imprimirlo) o bien debe devolverlo
mediante return?
Habitualmente la respuesta esperada es la primera, aunque si tomamos el enunciado
literalmente deberamos hacer la segunda. Esta segunda es algo ms compleja ya que para
devolver la lista de cuadrados debemos crear primero una lista vaca, ir llenndola con los
cuadrados que cumplan la condicin, y por ltimo devolverla con return.
59
7.6 Programa sobre composicin y herencia

Se desea disear un programa que tendr que ser capaz de gestionar obras
cinematogrficas, literarias y musicales, permitiendo la creacin, modificacin y acceso de
las diferentes obras y sus autores, as como la impresin por pantalla de sus datos ms
caractersticos. De todas las obras necesitamos saber su ttulo, su autor y ao de edicin.
Adems, en concreto, de los libros nos interesa su editorial y su nmero de pginas; de los
discos queremos saber la discogrfica que lo edita y el nmero de canciones; y de las
pelculas interesan los intrpretes y la productora. Todos los autores de una obra, as como
los intrpretes de una pelcula, se consideran artistas. De cada artista queremos saber su
nombre y su ao de nacimiento. Por ltimo, se desea poder imprimir en pantalla todos los
datos de cada obra..
Se pide:
1. Dibujar un esquema con las clases necesarias para este programa, indicando los
atributos y mtodos que tiene cada una (slo indicarlos, sin escribir su cdigo). El
esquema debe reflejar grficamente la herencia de clases en caso de que la haya.
2. Codificar la clase correspondiente a las pelculas.
Supongamos a partir de ahora que estamos programando el mtodo main, y que hemos
creado los siguientes objetos:
Clase
Nombre objeto
Datos
Artista
gonzaloSuarez
Nombre: Gonzalo Surez; Ao de nacimiento: 1954
Artista
carmeloGomez
Nombre: Carmelo Gmez; Ao de nacimiento: 1962
Artista
maribelVerdu
Nombre: Maribel Verd; Ao de nacimiento: 1970
Libro
ciudadanoSade
Ttulo: Ciudadano Sade; Autor: gonzaloSuarez; Ao de

produccin: 1999; Editorial: Plaza&Jans; Nmero de pginas:
256
3. Escribir el cdigo necesario para crear el objeto correspondiente a la pelcula "El

portero" (Gonzalo Surez, 2000, Lola Films, interpretada por Carmelo Gmez y
Maribel Verd).
4. Codificar en una sola lnea exactamente la siguiente modificacin: "la fecha de
nacimiento del autor de la pelcula 'El Portero' es 1934". Si a continuacin
imprimimos por pantalla los datos del libro "Ciudadano Sade", qu fecha de
nacimiento se imprimir en pantalla para el autor?
Solucin al apartado 1:
60
public class Pelicula extends Obra {
private Artista[] interpretes;
private String productora;
public Pelicula(String titulo, Artista autor, int ao,
String productora, Artista[] interpretes) {
this.setTitulo(titulo);
this.setAutor(autor);
this.setAoProduccin(ao);
this.productora = productora;
this.interpretes = interpretes;
}
public void imprimir() {
System.out.print("OBRA: " + this.getTitulo() + "; AUTOR: " +
this.getAutor() + "; AO DE PRODUCCIN:" +
this.getAoProduccin()
+ "; PRODUCTORA: " + this.productora + "; INTRPRETES:");
int i;
for (i=0; i<this.interpretes.length; i++ ) {
System.out.print(interpretes[i].toString());
}
System.out.println();
}
}
61
Esta solucin es posible porque no hemos definido ningn constructor para la clase Obra,
por lo que sigue disponible su constructor por defecto. En otro caso habra que programar
el constructor de la siguiente forma:
public Pelicula(String titulo, Artista autor, int ao,
String productora, Artista[] interpretes) {
super(titulo, autor, ao);
this.productora = productora;
this.interpretes = interpretes;
}
Artista[] interpretes_portero = new Artista[2];
interpretes_portero[0] = carmeloGomez;
interpretes_portero[1] = maribelVerdu;
Pelicula elPortero = new Pelicula("El portero", gonzaloSuarez ,
2000, "Lola Films", interpretes_portero);
Si se han declarado los atributos private y se han definido para ellos mtodos get y
set (opcin ms correcta):
elPortero.getAutor().setAoNacimiento(1934);
En caso contrario:
elPortero.autor.aoNacimiento=1934;
Al imprimir datos del libro, la fecha de nacimiento del autor sera 1934, ya que la
modificacin hecha con la lnea anterior afecta permanentemente al objeto
gonzaloSuarez.
7.7 Programa sobre composicin y herencia II

Se desea realizar un programa para gestionar ordenadores. De todo ordenador
necesitamos saber su tipo de procesador, su velocidad en GHz, y su memoria RAM.
Existen dos tipos de ordenadores: porttiles y sobremesa. De los porttiles queremos
saber tambin su peso en Kg y sus horas de autonoma. De los de sobremesa
necesitamos saber qu tipo de monitor tienen. Cada ordenador tiene un mtodo llamado
imprimir que permite escribir sus datos por pantalla.
Parte 1
Realizar un esquema de clases indicando grficamente la herencia. Por cada clase,
indicar sus atributos y mtodos (incluyendo constructores).
Parte 2
Supongamos que no definimos ningn constructor para la clase padre y que los atributos
de clase son privados: codificar el constructor de la clase que representa a los
ordenadores porttiles.
Escribir tambin el cdigo necesario para que desde el mtodo main introduzcamos
este ordenador porttil:
Procesador: Pentium IV
Velocidad: 2.1 GHz
Memoria RAM: 512 MB
Peso: 2.7 Kg
Horas de autonoma: 2
62
Solucin
Parte 1
Ordenador
String procesador
double velocidad
int memoria
Ordenador(String, double)
int getMemoria()
void setMemoria(int)
String getProcesador()
void setProcesador(String)
double getVelocidad()
void setVelocidad(double)
Portatil
double peso
int horasAutonomia
Portatil(String, double, int, double, int)
int getHorasAutonomia()
void setHorasAutonomia(int)
double getPeso()
void setPeso(double)
Sobremesa
String tipoMonitor;
public Sobremesa(String, double, int, String)
String getTipoMonitor()
void setTipoMonitor(String)
Parte 2
1 package parte2;
2 public class Ordenador {
3
4 private String procesador;
5 private double velocidad;
6 private int memoria;
7
8 public int getMemoria() {
9
return memoria;
10 }
11 public void setMemoria(int memoria) {
12
this.memoria = memoria;
13 }
14 public String getProcesador() {
15
return procesador;
16 }
17 public void setProcesador(String procesador) {
18
this.procesador = procesador;
19 }
20 public double getVelocidad() {
21
return velocidad;
22 }
23 public void setVelocidad(double velocidad) {
24
this.velocidad = velocidad;
25 }
26
27 public static void main(String[] args) {
28
29
Portatil miPortatil = new Portatil("Pentium IV", 2.1, 512, 2.7,
2);
30
31
// Probamos que se ha creado bien:
32
System.out.println("Procesador: " + miPortatil.getProcesador());
33
System.out.println("Velocidad: " + miPortatil.getVelocidad());
34
System.out.println("Memoria: " + miPortatil.getProcesador());
63
35
System.out.println("Peso: " + miPortatil.getProcesador());
36
System.out.println("Horas de autonoma: " +
miPortatil.getHorasAutonomia());
37
38 }
39 }
1 package parte2;
2 public class Portatil extends Ordenador {_
3 double peso;
4 int horasAutonomia;
5
6 public Portatil(String procesador, double velocidad, int memoria,
double peso, int horasAutonomia) {
7
super();
8
//super.setProcesador(procesador);
9
this.setVelocidad(velocidad);
10
this.setMemoria(memoria);
11
this.peso = peso;
12
this.horasAutonomia = horasAutonomia;
13 }
14
15 // En este caso, implcitamente lo primero que se hace es llamar
al constructor de la clase padre,
16 // super();
17 // (Ver ahora el comentario en la clase Sobremesa)
18
19 public int getHorasAutonomia() {
20
return horasAutonomia;
21 }
22
23 public void setHorasAutonomia(int horasAutonomia) {
24
this.horasAutonomia = horasAutonomia;
25 }
26
27 public double getPeso() {
28
return peso;
29 }
30
31 public void setPeso(double peso) {
32
this.peso = peso;
33 }
34
35 }
1 package parte2;
2 public class Sobremesa extends Ordenador{
3 String tipoMonitor;
4
5 public Sobremesa(String procesador, double velocidad, int memoria,
String tipoMonitor) {
6
super();
7
this.setProcesador(procesador);
8
this.setVelocidad(velocidad);
9
this.setMemoria(memoria);
10
this.tipoMonitor = tipoMonitor;
11 }
64
12
13 // (Leer antes el comentario en la clase Portatil)
14 // Aunque no es necesario, podemos llamar nosotros explcitamente
a ese constructor por defecto
15
16 public String getTipoMonitor() {
17
return tipoMonitor;
18 }
19
20 public void setTipoMonitor(String tipoMonitor) {
21
this.tipoMonitor = tipoMonitor;
22 }
23
24 }
7.8 Programa sobre composicin y herencia III

Una empresa de telecomunicaciones nos encarga realizar la primera versin de un
programa para gestionar mensajes de texto en diferentes formatos: e-mail, SMS (mensajes
cortos de telefona mvil) y chat (mensajera instantnea). Todos los mensajes,
independientemente del formato, tienen un usuario emisor, un usuario receptor y un texto
de mensaje. Adems, en particular, un e-mail tiene un Asunto (de tipo texto) y un conjunto
de usuarios a los que llegar copia del mensaje; un SMS tiene un nmero del centro
servidor, y un mensaje instantneo tiene un protocolo de mensajera. De cada usuario
podemos necesitar su nombre, su direccin de correo electrnico, su nmero de telfono
mvil y su direccin IP. Los mensajes pueden enviarse, y al hacerlo se escribe por pantalla
el cuerpo del mensaje independientemente de su formato.
1. Dibujar un esquema con las clases necesarias para este programa, indicando los
atributos y mtodos que tiene cada una (slo indicarlos, sin escribir su cdigo). No es
necesario incluir mtodos get y set. El esquema debe reflejar grficamente la
herencia de clases en caso de que la haya.
La empresa nos explica ahora que al enviar un SMS debe haber un comportamiento
especial (el resto de formatos de mensaje mantienen su comportamiento): si el usuario
receptor no tiene mvil, debe imprimirse un mensaje de error. Adems, si el mensaje SMS
ocupa ms de 145 caracteres, antes de imprimirlo debemos irlo reduciendo hasta que no
sobrepase ese tamao. La reduccin se hace con el mtodo String reduce(String cadena),
programado por otra empresa e incluido en el package smstools. Cada vez que se ejecuta
este mtodo, mediante un diccionario de abreviaturas se reduce levemente la longitud del
texto.
2. Explicar, en relacin al concepto de herencia, cul sera la mejor solucin para
encajar en el diseo anterior este comportamiento particular del mtodo enviar para
los SMS. Indicar una solucin alternativa sin utilizar herencia y comentar sus ventajas
o inconvenientes.
3. Codificar el constructor de la clase correspondiente a los SMS. La presencia o
ausencia de constructor en una clase padre, afecta de alguna manera a la clase que
hereda?
1. Codificar el mtodo que permite enviar mensajes SMS.
65
Solucin
Solucin al Apartado 1:
Usuario
Mensaje

private String email;
private String movil;
private String ip;
private Usuario emisor;

private Usuario receptor;
private String texto;
void enviar()
Usuario(String, String,
movil, ip)
Sms
Usuario
private String email;
private String movil;
private String ip;
Usuario(String, String,
movil, ip)
Chat
private int servidor;
private String cliente;
Sms(Usuario, Usuario,
String, int)
Chat(Usuario, Usuario,
String, String)
Habra que reescribir el mtodo enviar en la clase Sms, de forma que el mtodo
enviar original permaneciera en la clase Mensaje. As, cuando se imprima un email o un
mensaje instantneo, se recurrir al mtodo heredado de la clase padre, pero cuando se
imprima un SMS se ejecutar el mtodo redefinido.
La alternativa sin herencia sera eliminar el mtodo enviar de la clase padre y escribirlo
individualmente para cada formato de mensaje. Sin embargo, esta solucin es peor, porque
implica duplicar informacin al escribir un mismo cdigo varias veces (en este caso dos,
pero podran ser ms), con la consiguiente dificultad para mantener la coherencia en caso
de un cambio en el cdigo.
Al crear un objeto de la clase que hereda, lo primero que se hace es llamar implcitamente al
constructor por defecto de la clase padre, por lo que no es necesario escribir cdigo
adicional:
public Sms(Usuario emisor, Usuario receptor, String texto,
boolean multimedia, int servidor) {
this.setEmisor(emisor);
this.setReceptor(receptor);
this.setTexto(texto);
this.servidor = servidor;
}
Sin embargo, si hemos definido un constructor con argumentos para la clase padre, el
constructor por defecto deja de estar accesible y por tanto es necesario llamar
explcitamente al constructor de la clase padre que hemos creado:
public Sms(Usuario emisor, Usuario receptor, String texto,
boolean multimedia, int servidor) {
super(emisor,receptor,texto);
this.servidor = servidor;
}
66
public void enviar() {
if (this.getReceptor().getMovil()== null)
System.out.println("ERROR: El receptor carece de mvil.");
else
{
while(this.getTexto().length()>145)
this.setTexto(Smstools.reduce(this.getTexto()));
System.out.println(this.getTexto());
}}
7.9 Gestor de animales

Nuevo ejemplo de gestor que reutilizaremos despus para aadir herencia.
Clase Animal
Clase GestorAnimales
67
68
69
7.10 Gestor de animales aadiendo herencia

En la ltima parte de las prcticas, as como en los exmenes, es habitual tener que aadir
herencia. Vamos a ilustrar esto con el ejemplo anterior.
Clase Perro:
70
Clase Gato:
Clase Color:
Observa que no hay que cambiar absolutamente nada en las clases ya existentes, Animal y
GestorAnimales. Sin embargo, es habitual cambiar la visibilidad de los atributos en las clases
padre a protected.
Al implementar la herencia hay que decidir si la clase padre (en este caso Animal) pasa a ser
abstracta. Para ello nos preguntamos: queremos que sea posible instanciar un objeto de la clase
Animal, o por el contrario queremos que el usuario se vea obligado a escoger entre instanciar un
Perro o un Gato?
Si en algn mtodo del gestor nos interesa distinguir el tipo de animal, podemos hacerlo
con el operador instanceof. Por ejemplo, en el mtodo imprimir:

FI Apuntes 2015

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

FI Apuntes 2015

Загружено:

Авторское право:

Доступные форматы

FUNDAMENTOS

Teresa Sastre Toral

Alberto Ruiz Cristina

Fundamentos de Programacin en Java

ELEMENTOS BSICOS DEL LENGUAJE JAVA .................................................................. 1

ESTRUCTURA DE UN PROGRAMA EN JAVA ................................................................................... 1

ESTRUCTURAS DE CONTROL DE FLUJO ........................................................................... 4

CLASES Y OBJETOS .............................................................................................................. 15

ESTRUCTURAS DE ALMACENAMIENTO .......................................................................... 30

DOCUMENTACIN DE LAS CLASES .................................................................................. 35

ANTES DE LA CLASE: ............................................................................................................... 35

COMPOSICIN, HERENCIA Y POLIMORFISMO ............................................................. 37

EJEMPLOS DE PROGRAMAS ............................................................................................... 44

PROGRAMAS SENCILLOS SOBRE ESTRUCTURAS DE CONTROL ...................................................... 44

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

1 Elementos bsicos del lenguaje Java

Lnea 3: declaramos el mtodo main.

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

1.2 Elementos bsicos para empezar a programar

Es importante respetar una serie de convenciones de nombres. Es fcil acostumbrarse a

Los tipos predefinidos, variables y mtodos se escriben en minscula, como int,

Las constantes se escriben en maysculas, como PI.

Las clases se escriben con la inicial en mayscula, como Ejemplo.

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

Existen dos tipos de comentarios. El primero se llama comentario de bloque y est

Ahora nos atrevemos a hacer un pequeo programa:

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

2 Estructuras de control de flujo

Las estructuras de seleccin permiten ejecutar una u otra porcin de cdigo

Las estructuras de repeticin permiten ejecutar una misma porcin de cdigo

2.2 Estructuras de seleccin

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

2.2.3 Operador condicional

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

2.3 Estructuras de repeticin

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

La relacin entre while y for es muy estrecha y se muestra en la siguiente tabla:

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

Cmo elegir la estructura de repeticin adecuada?

Si es posible que el bucle no se ejecute, usar while.

Si queremos que al menos se ejecute una vez, usar do-while.

Si sabemos cuntas veces queremos ejecutarlo, usar for.

Si queremos recorrer todos los elementos de un vector, usar for.

2.3.4 Ruptura del flujo

2.3.5 Manejo de excepciones

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

2.4 Programas de ejemplo

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

/* ESTRUCTURAS DE REPETICIN: DO-WHILE */

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

Las clases se crean cuando:

Hay un concepto nuevo de un problema a solucionar.

Si no se inicializan los atributos ni de la anterior forma ni mediante mtodos, se inicializan

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

tipoAcceso TipoDevuelto nombreMtodo (TipoParametro1

El tipo de acceso en los mtodos es idntico al de los atributos. Se recomienda a los

3.2.3 Autorefencia this

Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina