Resumen Java

FUNDAMENTOS DE PROGRAMACIN EN JAVA
Teresa Sastre Toral Alberto Ruiz Cristina
I.S.B.N.: 84-690-3077-9
Fundamentos de Programacin en Java

1 2 INTRODUCCIN............................................................................................................................ 1 ELEMENTOS BSICOS DEL LENGUAJE JAVA..................................................................... 2 2.1 2.2 3 ESTRUCTURA DE UN PROGRAMA EN JAVA ................................................................................. 2 ELEMENTOS BSICOS PARA EMPEZAR A PROGRAMAR ................................................................ 3
ESTRUCTURAS DE CONTROL DE FLUJO .............................................................................. 6 3.1 3.2 3.2.1 3.2.2 3.2.3 3.2.4 3.3 3.3.1 3.3.2 3.3.3 3.3.4 3.3.5 3.4 OBJETIVOS................................................................................................................................. 6 ESTRUCTURAS DE SELECCIN .................................................................................................... 6 if ........................................................................................................................................... 6 if-else.................................................................................................................................... 6 Operador condicional.......................................................................................................... 7 switch ................................................................................................................................... 7 ESTRUCTURAS DE REPETICIN ................................................................................................... 8 while..................................................................................................................................... 8 do-while ............................................................................................................................... 8 for......................................................................................................................................... 9 Ruptura del flujo ................................................................................................................ 10 Manejo de excepciones ...................................................................................................... 10 PROGRAMA DE EJEMPLO .......................................................................................................... 11
CLASES Y OBJETOS (PRIMERA PARTE) .............................................................................. 16 4.1 OBJETIVOS............................................................................................................................... 16 4.2 CLASE...................................................................................................................................... 16 4.2.1 Atributos............................................................................................................................. 17 4.2.2 Mtodos.............................................................................................................................. 17 4.2.3 Autorefencia this ................................................................................................................ 18 4.2.4 Mtodo constructor............................................................................................................ 19 4.2.5 Sobrecarga......................................................................................................................... 20 4.3 OBJETOS .................................................................................................................................. 20 4.3.1 Referencias compartidas: alias.......................................................................................... 21
CLASES Y OBJETOS (SEGUNDA PARTE).............................................................................. 22 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 OBJETIVOS............................................................................................................................... 22 ELEMENTOS DE CLASE ............................................................................................................. 22 CLASES PREDEFINIDAS ............................................................................................................ 22 MBITOS ................................................................................................................................. 22 PAQUETES ............................................................................................................................... 23 DERECHOS DE ACCESO ............................................................................................................ 25 PROGRAMAS DE EJEMPLO ........................................................................................................ 25 ENUMERADOS.......................................................................................................................... 28
ESTRUCTURAS DE ALMACENAMIENTO............................................................................. 30 6.1 6.2 6.3 6.4 6.5 6.6 OBJETIVOS............................................................................................................................... 30 COMPARACIN ENTRE UN ARRAY Y UN ARRAYLIST ................................................................ 30 ARRAY .................................................................................................................................... 30 ARRAYLIST ............................................................................................................................. 31 RECORRIDO DE ESTRUCTURAS ................................................................................................. 32 CDIGO DE EJEMPLO ............................................................................................................... 33
COMPOSICIN, HERENCIA Y POLIMORFISMO................................................................ 35 7.1 OBJETIVOS............................................................................................................................... 35 7.2 COMPOSICIN .......................................................................................................................... 35 7.3 HERENCIA ............................................................................................................................... 36 7.3.1 Compatibilidad de tipos ..................................................................................................... 38 7.3.2 mbitos y visibilidad.......................................................................................................... 38
7.3.3 7.3.4 7.4 7.5 7.6 7.7 7.8 8
Reescritura......................................................................................................................... 38 Los constructores ............................................................................................................... 38 TABLA DE COMPATIBILIDAD .................................................................................................... 39 COMPATIBILIDAD DE TIPOS...................................................................................................... 39 REESCRITURA Y LIGADURA DINMICA .................................................................................... 40 POLIMORFISMO ........................................................................................................................ 41 CLASES ABSTRACTAS .............................................................................................................. 41
EJERCICIOS DE PROGRAMACIN EN JAVA...................................................................... 42 8.1 8.1.1 8.2 8.2.1 8.2.2 8.2.3 8.2.4 8.3 8.3.1 8.3.2 8.3.3 8.4 8.4.1 8.4.2 8.4.3 8.5 8.5.1 8.5.2 8.5.3 8.5.4 8.5.5 8.5.6 8.5.7 EJEMPLO BSICO DE UN PROGRAMA EN JAVA .......................................................................... 42 Solucin ............................................................................................................................. 42 EJERCICIOS SOBRE ESTRUCTURAS DE CONTROL ....................................................................... 43 Ejercicio 1.......................................................................................................................... 43 Ejercicio 2.......................................................................................................................... 43 Ejercicio 3.......................................................................................................................... 43 Solucin a los ejercicios de estructuras de control del 1 al 3............................................ 43 EJERCICIOS SOBRE CLASES Y OBJETOS ..................................................................................... 47 Ejercicio 1.......................................................................................................................... 47 Ejercicio 2.......................................................................................................................... 49 Ejercicio 3.......................................................................................................................... 52 EJERCICIOS SOBRE ESTRUCTURAS DE ALMACENAMIENTO ....................................................... 57 Ejercicio 1.......................................................................................................................... 57 Ejercicio 2.......................................................................................................................... 57 Ejercicio 3.......................................................................................................................... 58 EJERCICIOS DE COMPOSICIN, HERENCIA Y POLIMORFISMO..................................................... 59 Ejercicio 1.......................................................................................................................... 59 Ejercicio 2.......................................................................................................................... 63 Ejercicio 3.......................................................................................................................... 64 Ejercicio 4.......................................................................................................................... 67 Ejercicio 6.......................................................................................................................... 69 Ejercicio 7.......................................................................................................................... 73 Ejercicio 8.......................................................................................................................... 75
Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina
1 Introduccin
Este texto pretende ser una iniciacin sencilla al lenguaje de programacin Java. Se ha concebido como un apoyo para los estudiantes de la asignatura Fundamentos de Informtica de Ingeniera Industrial en la Universidad Nacional de Educacin a Distancia (UNED). Se trata de una asignatura de primer curso, y por tanto nos dirigimos a estudiantes que tienen conocimientos de informtica a nivel de usuario pero poca o ninguna experiencia en el mundo de la programacin. A lo largo de los siguientes captulos el estudiante aprender gradualmente a disear sus programas y programarlos de forma correcta. El texto combina la explicacin de los elementos propios del lenguaje Java con la progresiva incorporacin de conceptos tericos propios del paradigma orientado a objetos. Se trata por tanto de conseguir que el alumno avance paralelamente tanto en el dominio del lenguaje como en la capacidad para disear correctamente los programas. El desarrollo equilibrado de ambas habilidades es necesario para lograr una visin global de la programacin: este texto pretende ser un apoyo para conseguirlo. El ltimo apartado, y el ms extenso, incluye una coleccin de ejercicios de programacin resueltos que ayudan a practicar y comprobar los avances. Recomendamos estudiar la teora y los ejercicios simultneamente. Para comenzar a trabajar es necesario instalar Java en el ordenador, as como un entorno de desarrollo para compilar los programas de forma cmoda. Se ha incluido un anexo que explica cmo realizar la instalacin y presenta un entorno de desarrollo sencillo, llamado JGrasp, que resulta recomendable para que el alumno comience a programar. Esperamos que este texto sea de utilidad y facilite al alumno el acercamiento al mundo de la programacin en Java. Teresa Sastre Toral y Alberto Ruiz Cristina (profesores de Universidad)
2 Elementos bsicos del lenguaje Java

2.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.
2.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.
3 Estructuras de control de flujo

3.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.
3.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.
3.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
3.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.
Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina Sintaxis en java:
if (condicin) { sentencias; } else { sentencias; }
false
condicin
true
sentencias 1
sentencias 2
3.2.3 Operador condicional

Se trata de una reescritura resumida del if-else. No se usa habitualmente. Sintaxis en java:
expresin booleana ? expresin1 : expresin2
3.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).
8 Sintaxis en java:
switch (expresin) { case valor1: sentencias; break; case valor2: sentencias; // cuidado con el break! case valor3: sentencias; break; default: sentencias; }
3.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:
3.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
3.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 true
condicin false
3.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.
10
3.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.
3.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. 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 }
11
3.4 Programa de ejemplo

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--; 56 ++temp1; // temp1 vuelve a valer 1 57 System.out.println("Se escribir 0: " + --temp1);
12
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

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"); }

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 178 179 /* 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);
13
/* 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."); } /* ESTRUCTURAS DE REPETICIN: DO-WHILE */
14
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 227 228 229 230 231 232 233 234 235 236 237 238 239 240

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."); } } /* MANEJO DE EXCEPCIONES */ int numero = 0, intentos = 0; Scanner teclado = new Scanner(System.in); do { try { System.out.println("Introduce un nmero entre 0 y 10: "); numero = teclado.nextInt(); } catch(InputMismatchException e) { System.out.println("Error en la lectura."); } finally {
15
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
16
4 Clases y Objetos (primera parte)

4.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.
4.2 Clase
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; Cliente c; declaro la variable x del tipo entero 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 */ } }
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.
17
4.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.
4.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.
18
En cuanto a la estructura de mtodo, se declara dentro de la estructura de clase:

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.
4.2.3 Autorefencia this

Es una referencia especial para que se pueda nombrar a los elementos de la propia clase dentro de ella. Es til utilizarla cuando puede haber problemas de ambigedad. Por ejemplo, supongamos que el atributo de una clase y un parmetro se denominan de igual
19
forma. Cmo se puede saber dentro del mtodo que tiene ese parmetro si estamos hablando del parmetro o del atributo? Ejemplo:
... private int edad; // atributo edad ... public void setEdad(int edad) { this.edad = edad; // distinguimos el atributo de la clase, edad, del parmetro }
4.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 estos los valores por defecto explicados anteriormente (null, 0, false, etc.). Es importante
20
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.
4.2.5 Sobrecarga
Hay sobrecarga cuando existen varios mtodos que se llaman igual pero que pueden usar parmetros distintos y/o devuelven resultados distintos.
4.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();
21
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.
4.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.
22
5 Clases y Objetos (segunda parte)

5.1 Objetivos
En este captulo se profundizar en el manejo y organizacin de las clases, trabajando los conceptos de elementos de clase, mbitos, paquetes, derechos de acceso y clases predefinidas.
5.2 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.
5.3 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;
5.4 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
23
( ) ; ( int y )
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.
5.5 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.
24
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: 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 .,
25
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;
5.6 Derechos de acceso

Los modificadores de visibilidad ya se vieron en clases anteriores, y se resumen en la siguiente tabla: Modificador Privada Por defecto Protegida Pblica Sintaxis private int x; int x; protected int x; public int x; Visibilidad Slo dentro de la clase Clases dentro del paquete Clases dentro del paquete y subclases dentro o fuera del paquete 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.
5.7 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 parNombre, String parApellidos, 22 int parAoDeNacimiento,int parNumeroPersonal) 23 { 24 nombre = parNombre; 25 apellidos = parApellidos; 26 aoDeNacimiento = parAoDeNacimiento ;
26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

numeroPersonal = parNumeroPersonal; } /* En la estructura de la clase se declara a continuacin las acciones o mtodos que pueden llevar a cabo */ // Estos son los mtodos modificadores public void setNombre(String nombre) { /* Se utiliza la autorefencia this para discernir entre el atributo y el parmetro */ this.nombre = nombre; } public void setApellidos(String parApellidos) { apellidos = parApellidos; } public void setAoDeNacimiento(int parAoDeNacimiento) { aoDeNacimiento = parAoDeNacimiento; } public void setNumeroPersonal(int parNumeroPersonal) { numeroPersonal = parNumeroPersonal; } 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;

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 } 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; } 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
27
28
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 TerceraClase 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 objAlumno1 = new Alumno("Guillermo","Puertas",1955,36); 11 objAlumno1.ponCurso("FUND_INF",'M'); 12 objAlumno1.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 objAlumno1 y objAlumno2 apuntan al mismo 16 objeto. Se puede observar al imprimir el alumno2*/ 17 18 Alumno objAlumno2 = objAlumno1; 19 objAlumno2.imprime(); 20 /* Si queremos que el objAlumno2 tenga unos datos distintos 21 tendremos que crear otro objeto distinto al de objAlumno1, 22 de la siguiente forma */ 23 24 objAlumno2 = new Alumno("Linus","Torvalds",1969,22); 25 objAlumno1.ponCurso("FUND_INF",'M'); 26 objAlumno2.imprime(); 27 } 28 } // fin de la clase TerceraClase
5.8 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:
Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina Contenido del archivo Turno.java:
public enum Turno {MAANA, TARDE, NOCHE}
29
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 nombre; 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
6 Estructuras de almacenamiento
6.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.
6.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.
6.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];
6.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. 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(Object o) 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. Este mtodo comprueba si hay elementos en el ArrayList. Devuelve el elemento especificado en la posicin del
boolean isEmpty() void clear()
Borra todos los elementos del ArrayList.
Object get(int index)
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
6.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). 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));
} Por ser una accin tan frecuente, Java ofrece una alternativa para recorrer estructuras de forma ms cmoda y operar con cada uno de sus elementos. Esta alternativa est disponible tanto para arrays como para ArrayList. Ejemplo:
for (Integer i_dia: diasSemana) { System.out.println(El da es + i_dia);
33
Esta sentencia se entiende como: Sea i_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. Para evitar confusiones sugerimos llamar de la forma i_nombre a estas variables que no son exactamente ndices sino que contienen el valor de cada elemento de la estructura, aunque no existe un convenio definido al respecto. 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; } }
6.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; circunferencias[1] = cir2; circunferencias[2] = cir3; // 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()); }
34
// 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); // 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();
35
7 Composicin, herencia y polimorfismo

7.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.
7.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 corresponden con el tipo de una 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. 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
Los datos del cliente (dni, nombre, apellido) quedaran recogidos en la clase Cliente.
36
Grficamente la composicin se representara de esta forma:
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) Cliente private long dni; private String nombre; private String apellido; public Cliente (long dni,, String nombre, String apellido)
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.
7.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.
Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina Ejemplo:
37
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 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) Cliente private long dni; private String nombre; private String apellido; public Cliente (long dni,, String nombre, String apellido)
BilleteTren private String categoria; public BilleteTren (long numBillete, Calendar fechaHora, int numAsiento, String locSalida, String locLlegada, Cliente cliente, int precio, String Categoria)
Figura 1
38
7.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 Realizacin de casting Billete billete = billeteTren; 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.
7.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 Privada Por defecto Protegida Pblica Sintaxis private int x; int x; protected int x; public int x; Visibilidad Slo dentro de la clase Clases dentro del paquete Clases dentro del paquete y subclases dentro o fuera del paquete Todas las clases
7.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).
7.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;
39
7.4 Tabla de compatibilidad

Esta tabla aclara cundo podemos utilizar los conceptos de composicin y herencia: Composicin Herencia Ejemplos: Composicin Herencia Aula Profesor <<tiene-un>> <<es-una>> Profesor Persona Clase contendora Clase hijo <<tiene-un>> <<es-un>> Clase contenida Clase base o padre
7.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)
40
{ Alumno al2 = (Alumno) p2; } else { System.out.println(ERROR: no es un alumno); }
7.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.
41
7.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.
7.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; } . . . }
42
8 Ejercicios de programacin en java

8.1 Ejemplo bsico de un programa en java
Completar en l el siguiente cdigo:
/* Crear un programa que calcule el rea de un tringulo, el permetro de una circunferencia y su rea, e imprimir el resultado por pantalla. */ public class Ejemplo2 { public static void main (String [] args) { /*implementar el metodo main*/ } }
8.1.1 Solucin
5 public class Ejemplo2 { 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 }
43
8.2 Ejercicios sobre estructuras de control

8.2.1 Ejercicio 1
Reescribir los ejemplos de ruptura de flujo con continue y break incluidos en el programa de muestra para que no necesiten utilizar estos mecanismos.
8.2.2 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.
8.2.3 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.
8.2.4 Solucin a los ejercicios de estructuras de control del 1 al 3

1 import java.util.Scanner; 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 System.out.println("El nmero " + k + " es par."); 17 } 18 } 19 20 // Eliminar el break (solucin 1): 21 int miNumero = 1853; 22 int temp1=0; 23 while (temp1!=miNumero) 24 { 25 temp1++;
44
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 86 int suma=0;

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 147 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; copiaNumero--;
45
46
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; } System.out.println("El nmero " + k + " es par."); }
47
8.3 Ejercicios sobre clases y objetos

8.3.1 Ejercicio 1
Resolver el ejercicio planteado en la primera clase utilizando clases y objetos: es decir, definiendo clases que representen los conceptos de tringulo y circunferencia. Programaremos una tercera clase que ser la que tenga el mtodo main. Desde este mtodo crearemos objetos concretos de tringulos y circunferencias, y utilizando los atributos y mtodos de dichas clases obtendremos rea y permetro 8.3.1.1
Solucin
Circunferencia Triangulo private double base; private double altura; public double getAltura(); public double getBase(); public double getArea(); public void setBase(double base); public void setAltura(double altura); private double radio; private double area; private double perimetro; private final double PI = 3.1416; public Circunferencia(double radio); public double getRadio(); public double getArea(); public void getPerimetro();
PrimeraClase
public static void main(String [] args)
1 public class PrimeraClase { 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 }
48
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 }
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 }
49
8.3.2 Ejercicio 2
Se pide que creis una clase Tarjeta que tiene como caractersticas el nmero de cuenta que se asocia con la tarjeta, el saldo de la cuenta asociada a la tarjeta, el nmero secreto de la tarjeta y la cantidad mxima diaria a sacar. Con la clase Tarjeta se puede realizar movimientos como sacar dinero, ingresar dinero y consultar el saldo, tambin se puede realizar cambios en la cantidad mxima a sacar y realizar comprobaciones como introducir el nmero secreto y comprobar que sea el mismo que el de la tarjeta. Dentro del mtodo de sacar dinero se tiene que tener en cuenta dos condiciones: la primera es que no se puede dejar la cuenta en menos de 200 euros y la segunda que no se puede pedir sacar cantidades superiores a la cantidad mxima diaria. Si esto sucediera se tendra que sacar por pantalla un mensaje que dijera porqu no se ha podido realizar la operacin. Se pide tambin crear un programa principal main (puede ser dentro de la clase Tarjeta o en otra clase) donde se cree un objeto tarjeta (o varios) y se aadan unas serie de datos. Por ejemplo: numero de cuenta 135, saldo disponible 2320 , saldo mximo a sacar 500 y el nmero secreto 3212. Despus realizar los pasos que supuestamente realizaras en un cajero: Introducir el cdigo clave y comprobar que es el correcto, si no dar un mensaje de error (esto se realiza llamando al mtodo de la clase Tarjeta que implemente esta accin). Si no da error sacar dinero de la cuenta. Podis probar a sacar una cantidad superior a la permitida, etc. 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.
8.3.2.1
Solucin
1 import java.util.Scanner; 2 import java.util.InputMismatchException; 3 4 public class Tarjeta 5 { 6 private double numCuenta; 7 private double saldoCuenta; 8 private int numSecreto; 9 private double cantidadMaximaDiaria; 10 private double limiteCuenta = 200; 11 12 public Tarjeta (double numCuenta, double saldoCuenta, int numSecreto, double cantidadMaximaDiaria) 13 { 14 this.numCuenta = numCuenta; 15 this.saldoCuenta = saldoCuenta; 16 this.numSecreto = numSecreto; 17 this.cantidadMaximaDiaria = cantidadMaximaDiaria;
50
18 } 19 20 public void ingresarDinero(double ingreso) 21 { 22 saldoCuenta += ingreso; 23 } 24 25 public void sacarDinero (double dinero) 26 { 27 if (dinero <= cantidadMaximaDiaria) 28 { 29 if ((saldoCuenta - dinero) >= limiteCuenta) 30 saldoCuenta -=dinero; 31 else 32 System.out.println("La cantidad no puede estar por debajo de 200"); 33 } 34 else 35 System.out.println("La cantidad mxima diaria que puede sacar con la tarjeta es:" + cantidadMaximaDiaria); 36 } 37 38 public double consultarSaldo() 39 { 40 return saldoCuenta; 41 } 42 43 public void cambiarCantidadMaxDiaria (double cantidad) 44 { 45 cantidadMaximaDiaria = cantidad; 46 } 47 48 public boolean comprobarNumeroSecreto(int numIntroducido) 49 { 50 return (this.numSecreto == numIntroducido); 51 } 52 53 public static void main (String [] args) 54 { 55 Scanner scn = new Scanner(System.in); 56 Tarjeta tarj = new Tarjeta(135,2320,3212,500); 57 // Pasos para sacar introducir sacar dinero de una tarjeta en un cajero 58 // 1. introducir el nmero clave y ver si es el correcto 59 int numSecreto = 0; 60 // cuenta el nmero de intentos de nmero secreto 61 int contador = 0; 62 // operacin que se realiza sobre la tarjeta 63 int operacion = 0; 64 // cantidad necesaria para realizar las operaciones 65 int cantidad = 0; 66 do 67 { 68 try 69 { 70 System.out.println("Introduzca el nmero clave por pantalla"); 71 numSecreto = scn.nextInt(); 72 // Al ponerlo el contador detrs de la lectura de pantalla hace que no cuente los errores no nmericos 73 contador++;
51
74 } 75 catch(InputMismatchException e) 76 { 77 System.out.println("Error se ha introducido el caracter: " + scn.next()); 78 numSecreto = 0; 79 } 80 } while ((!tarj.comprobarNumeroSecreto(numSecreto)) && (contador < 3)); 81 82 if (contador >=3) 83 System.out.println("Ha realizado tres intentos y el nmero no es el correcto, por favor, retire la tarjeta."); 84 else 85 { 86 do 87 { 88 // Texto para elegir la opcion a realizar 89 System.out.println("Teclee 1 si quiere sacar dinero."); 90 System.out.println("Teclee 2 si quiere introducir dinero."); 91 System.out.println("Teclee 3 si quiere consultar saldo."); 92 System.out.println("Teclee 4 si quiere cambiar la cantidad mxima a sacar."); 93 System.out.println("Teclee 5 si quiere salir."); 94 try 95 { 96 operacion = scn.nextInt(); 97 switch(operacion) 98 { 99 case 1: 100 try 101 { 102 System.out.println("Introduzca la cantidad a sacar:"); 103 cantidad = scn.nextInt(); 104 tarj.sacarDinero (cantidad); 105 } 106 catch(InputMismatchException e) 107 { 108 System.out.println("Error se ha introducido el caracter: " + scn.next()); 109 cantidad = 0; 110 } 111 break; 112 _ case 2: 113 _ try 114 _ { 115 System.out.println("Introduzca la cantidad a ingresar:"); 116 cantidad = scn.nextInt(); 117 tarj.ingresarDinero(cantidad); 118 } 119 catch(InputMismatchException e) 120 { 121 System.out.println("Error se ha introducido el caracter: " + scn.next()); 122 cantidad = 0; 123 } 124 break; 125 case 3:
52
126 System.out.println("Su saldo es de: " + tarj.consultarSaldo() + " euros"); 127 break; 128 case 4: 129 try 130 { 131 System.out.println("Introduzca la cantidad mxima diaria:"); 132 cantidad = scn.nextInt(); 133 tarj.cambiarCantidadMaxDiaria(cantidad); 134 } 135 catch(InputMismatchException e) 136 { 137 System.out.println("Error se ha introducido el caracter: " + scn.next()); 138 cantidad = 0; 139 } 140 break; 141 case 5: 142 break; 143 default: 144 System.out.println("El nmero introducido no corresponde con ninguna opcin."); 145 } // end del switch 146 } 147 catch(InputMismatchException e) 148 { 149 System.out.println("Error se ha introducido el caracter: " + scn.next()); 150 operacion = 0; 151 } 152 }while (operacion != 5); // end del while 153 } // end del if (contador > 3) 154 } // end metodo main 155 } // end class
8.3.3 Ejercicio 3
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
53
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: 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). - Imprimir los datos de la pelcula por pantalla. 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). - Imprimir los datos de la pelcula por pantalla. 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.
54
8.3.3.1
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 this.nombre = nombre; 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 this.nombre = nombre; 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 }

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
55
56
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 } 86
57
8.4 Ejercicios sobre estructuras de almacenamiento

8.4.1 Ejercicio 1
Escribir un programa que calcule la diagonal de una matriz cuadrada de lado n. Puedes darle valores fijos o pedirlos al usuario por teclado. 8.4.1.1
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 11 12 final int N = 3; 13 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 21 22 int resDiagonal = 1; 23 for (int i= 0 ; i < matriz.length ; i++) 24 resDiagonal = resDiagonal * matriz[i][i]; 25 26 System.out.println(resDiagonal); 27 28 } 29 }
8.4.2 Ejercicio 2
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. 8.4.2.1
1 2 3 4 5 6 7 8 9 10
Solucin
import java.util.Scanner; import java.util.ArrayList; public class SumaEstructura { public static void main (String[] args) { // Al no saber a priori el nmero de elementos // que se van a recibir del alumno la estructura // de almacenamiento a utilizar tiene que poder // ser dinamica. Nosotros proponemos el uso del
58
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 }
8.4.3 Ejercicio 3
Razona qu estructura (array o ArrayList) has escogido para resolver los problemas anteriores. 8.4.3.1 Solucin 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.
59
8.5 Ejercicios de composicin, herencia y polimorfismo

8.5.1 Ejercicio 1
Un gran almacn se dedica a la venta de productos de alimentacin, ropa y electrnica. Cada producto se caracteriza por un precio, un nombre y un cdigo de barras. Los productos de alimentacin tiene a su vez una fecha de caducidad (se puede crear con enteros para el da, el mes y la hora). Los productos electrnicos tienen un plus adicional por ser tener todos 3 aos de garanta y los productos de ropa tienen como caracterstica el material en que han sido elaborados (slo el material principal). El almacn realiza ventas, cada venta puede estar formada un cdigo de venta y por varios productos. Se desea: 1. Realizar un diagrama donde se vean las relaciones entre clases, junto a los atributos y mtodos de cada una. 2. Se desea que la clase venta tenga un mtodo que realice la suma de 3 productos: una pizza de 3,5 euros, un pijama de 30 euros y un reproductor de mp3 de 80 euros con un plus de 8,5. 3. Implementar todas las clases con sus atributos y mtodos.
4.
Ejecutar el ejemplo del apartado 2 para ver que precio da la suma de la compra.
8.5.1.1 Solucin Diagrama de clases

Venta private static long codVenta = 0; private Vector productos; Producto private String codigoBarras; private String nombre; private double precio; public Venta() public void aadirProducto(Producto pr) Public double calcularVenta() public Producto(String codigoBarras, String nombre, double precio) public double calcularPrecio()
Alimentacion private GregorianCalendar fechaCad;
Ropa private String material;
Electrnica private double plus;
public Alimentacion(String codigoBarras, String nombre, double precio, GregorianCalendar fecha)
public Ropa(String codigoBarras, String nombre, double precio, String material)
public Ropa(String codigoBarras, String nombre, double precio, double plus) public double calcularPrecio()
60
1 public class Producto 2 { 3 private String codigoBarras; 4 private String nombre; 5 private double precio; 6 7 public Producto(String codigoBarras, String nombre, double precio) 8 { 9 this.codigoBarras = codigoBarras; 10 this.nombre = nombre; 11 this.precio = precio; 12 } 13 14 15 public double calcularPrecio() 16 { 17 return precio; 18 } 19 20 // El resto de los mtodos que se necesitan son los get y set de cada atributo 21 // el getPrecio correspondera con calcularPrecio 22 23 }
1 import java.util.GregorianCalendar; 2 3 public class Alimentacion extends Producto 4 { 5 private GregorianCalendar fechaCaducidad; 6 7 public Alimentacion(String codigoBarras, String nombre, Double precio, GregorianCalendar fecha) 8 { 9 super(codigoBarras,nombre,precio); 10 fechaCaducidad = fecha; 11 12 } 13 14 // El resto de los mtodos que se necesitan son los get y set del atributo material, el resto los hereda 15 16 }

1 2 public class Ropa extends Producto 3 { 4 5 private String material; 6 7 public Ropa(String codigoBarras, String nombre, double precio, String material) 8 { 9 super(codigoBarras,nombre,precio); 10 this.material = material; 11 12 } 13 14 // El resto de los mtodos que se necesitan son los get y set del atributo material, el resto los hereda 15 16 }
61
1 public class Electronica extends Producto 2 { 3 4 private double plus; 5 6 7 public Electronica(String codigoBarras, String nombre, double precio, double plus) 8 { 9 super(codigoBarras,nombre,precio); 10 this.plus = plus; 11 12 } 13 public double calcularPrecio() 14 { 15 return super.calcularPrecio() + plus; 16 17 } 18 19 20 // El resto de los mtodos que se necesitan son los get y set del atributo material, el resto los hereda 21 22 23 }
62
1 import java.util.Vector; 2 import java.util.GregorianCalendar; 3 4 public class Venta 5 { 6 7 private static long codVenta = 0; 8 private Vector productos = new Vector(); 9 10 public Venta(Producto pr) 11 { 12 codVenta++; 13 productos.add(pr); 14 15 } 16 17 public double calcularVenta() 18 { 19 double total = 0; 20 Producto pr; 21 for (int i=0; i< productos.size(); i++) 22 { 23 pr = (Producto) productos.elementAt(i); 24 total += pr.calcularPrecio(); 25 } 26 return total; 27 } 28 29 30 public void aadirProducto(Producto pr) 31 { 32 productos.add(pr); 33 } 34 35 // El resto de los mtodos que se necesitan son los get y set 36 37 38 // Vamos a crear un mtodo main aqu como punto de entrada al programa 39 // Podriamos crearnos otra clase que llamar a ventas y en ella poder tener el main 40 41 public static void main (String [] args) 42 { 43 44 GregorianCalendar fechaCadPizza = new GregorianCalendar(2006,12,23); 45 46 Alimentacion pizza = new Alimentacion("1111","Pizza Buitone 4 quesos", 3.5,fechaCadPizza); 47 Ropa pijama = new Ropa("2222","Pijama caballero",30,"algodon"); 48 Electronica mp3 = new Electronica("3333","mp3",80,8.5); 49 Venta v1 = new Venta(pizza); 50 v1.aadirProducto(pijama); 51 v1.aadirProducto(mp3); 52 System.out.println("El total de la compra es: " + v1.calcularVenta()); 53 54 } 55 }
63
8.5.2 Ejercicio 2
La librera Nuevo Mundo ha decidido gestionar las ventas de sus libros, revistas y cmic. Las ventas pueden ser de varias obras a la vez, ya sean libros, revistas o cmic. Cada obra se caracteriza por tener en comn el identificador, el nombre, el nombre del autor (supongamos que slo hay un autor), la editorial, el ao de edicin y el precio. Las revistas a su vez tienen el nmero de serie. Los cmic tambin tienen el nmero del dibujante. Adems cada obra dispone del IVA que se tiene que aplicar. ste ser siempre el mismo en funcin del tipo de obra: las revistas el 7%, los libros el 3% y los cmics el 10%. Tambin se podr realizar el clculo del precio final sumando al precio de la obra el IVA correspondiente. Se pide: 1. Dibujar un esquema con las clases necesarias para este programa, indicando los atributos y los mtodos en caso de haberlos. 2. Implementar la clase Venta. Qu estructura sera la ms adecuada para poder almacenar todas las obras que se venden? 3. Suponiendo que la clase venta tiene un mtodo que sea importe de la venta. Implementar dicho mtodo para que calcule el coste total de la venta. 8.5.2.1
Solucin
Solucin apartado 1
Venta
private Vector obras_vendidas = new Vector(); public Venta () public Venta (Vector obras_vendidas) public void addObra(Obra obra) public double importeVenta()
Obra (Abstract)
private int id; private String nombre; private String autor; private String editorial; private int aoEdiccion; private double precio; public Obra(int id, String nombre, String autor, String editorial, int aoEdiccion, double precio) public abstract double calcularImporte()
Comic
private String nDibujante; private static final double iva = 10; public Obra(int id, String nombre, String autor, String editorial, int aoEdiccion, double precio, String nDibujante) public double calcularImporte()
Revista
private int numSerie; private static final double iva = 7; public Revista(int id, String nombre, String autor, String editorial, int aoEdiccion, double precio, int numSerie) public double calcularImporte()
Libro
private static final double iva = 3; public Libro(int id, String nombre, String autor, String editorial, int aoEdiccion, double precio) public double calcularImporte()
No se han puesto en el esquema pero tambin seran necesarios los mtodos get y set de cada atributo en cada clase.
64
Solucin apartados 2 y 3.
import java.util.Vector; public class Venta { private Vector obras_vendidas = new Vector(); public Venta (){} public Venta (Vector obras_vendidas) {this.obras_vendidas = obras_vendidas;} public void addObra(Obra obra) {obras_vendidas.addElement(obra);} public Vector getObras_vendidas() {return obras_vendidas;} public void setObras_vendidas(Vector obras_vendidas) {this.obras_vendidas = obras_vendidas;} public double importeVenta() { double costeTotal = 0; Obra ob; for(int i=0; i < obras_vendidas.size();i++) { ob = (Obra)obras_vendidas.elementAt(i); costeTotal += ob.calcularImporte(); } return costeTotal; } }
La estructura ms adecuada sera la del Vector ya que no se sabe a priori las ventas que se van a realizar.
8.5.3 Ejercicio 3
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.
65
Supongamos a partir de ahora que estamos programando el mtodo main, y que hemos creado los siguientes objetos:
Clase Artista Artista Artista Libro
Nombre objeto gonzaloSuarez carmeloGomez maribelVerdu ciudadanoSade
Datos Nombre: Gonzalo Surez; Ao de nacimiento: 1954 Nombre: Carmelo Gmez; Ao de nacimiento: 1962 Nombre: Maribel Verd; Ao de nacimiento: 1970 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? 8.5.3.1 Solucin Solucin al apartado 1:
Obra
private String titulo; private Artista autor; private int aoEdicion; String getTitulo() void setTitulo(String) Artista getAutor() void setAutor(Artista) int getAoEdicion() void setAoEdicion(int)
Artista
private String nombre; private int aoNacimiento; Artista(String, int) int getAoNacimiento() void setAoNacimiento(int) String getNombre() void setNombre(String)
Libro
private String editorial; private int nPaginas; Libro(String, Artista, int, String, int) String getEditorial() void setEditorial(String) int getNPaginas() void setNPaginas(int) void imprimir()
Disco
private String discografica; private int nCanciones; Disco(String, Artista, int, String, int) String getDiscografica() void setDiscografica(String) int getNCanciones() void setNCanciones(int) void imprimir()
Pelicula
private String productora; private Artista[] interpretes; Pelicula(String, Artista, int, String, Artista[]) Artista[] getInterpretes() void setInterpretes(Artista[]) String getProductora() void setProductora(String) void imprimir()
66
Solucin al apartado 2:
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(); } }
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; }
Solucin al apartado 3:
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);
Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina Solucin al apartado 4:
67
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.
8.5.4 Ejercicio 4
El Estado, a travs de los bancos, oferta deuda pblica a sus clientes. La deuda pblica tiene distintas modalidades que son: letras del tesoro y bonos. Todas ellas se pueden agrupar en lo que se denomina cartera de inversin. Cualquier deuda tiene la fecha de suscripcin, el tipo de inters que oferta y su valor. Adems necesita de un mtodo que calcule, dada una fecha, la cantidad de intereses que va generando. Para ello se ha de tener en cuenta que en las letras del tesoro los intereses no se actualizan hasta finalizar el plazo de la deuda y en los bonos se actualizan anualmente. El plazo de la deuda es diferente en funcin de la modalidad de la deuda. Para las letras del tesoro el plazo es de 2 aos, mientras que los bonos tendrn una duracin de 5 aos. Se pide: 1. Realizar un diagrama de clases. En este diagrama se debe incluir las clases necesarias, sus relaciones (explicando brevemente el por qu de cada una), los atributos de cada clase, el tipo de stos y su tipo de acceso. Tambin definir sus mtodos incluyendo el constructor. (slo indicarlos, sin escribir su cdigo). 2. Implementar la clase Letra del Tesoro. 3. Suponemos el siguiente ejemplo: Manuel tiene una cartera de inversin en el banco con las siguientes deudas: Se pide: a. Realizar las sentencias concretas para crear cada una de las deudas expuestas anteriormente. b. Implementar un mtodo y decir en qu clase se encuentra (aadirlo tambin al diagrama de clases) dnde se pueda calcular dada una fecha qu intereses produce toda la cartera de inversin. Implementar las sentencias necesarias para dada la fecha de hoy, se pueda saber qu intereses ha generado toda la deuda de la cartera. 2 letras del tesoro, una por valor de 500 euros al 4% de inters a fecha de 01/10/2005 y la otra por valor de 900 al 5% a fecha de 01/06/2004. 2 bonos de estado al 7% de inters con fecha de 10/06/2003 con un valor de 3000.
68
8.5.4.1 Solucin Diseo de clases

CARTERA static private int identificador = 0; private Vector deudas; public Cartera () public int getIdentificador () public void addDeuda(Deuda deuda) public double calcularTotalIntereses (GregorianCalendar fecha) DEUDA (Abstract) protected GregorianCalendar gcFechaSuscripcion; protected int iTipoInteres; protected int iValor; public GregorianCalendar getGcFechaSuscripcion() public double getDTipoInteres() public int getIValor() public setGcFechaSuscripcion(GregorianCalendar gcFechaSuscripcion) public void setDTipoInteres(double dTipoInteres) public void setIValor(int iValor) abstract public double calcularInteres (GregorianCalendar fecha)
LETRA final private int iaosPlazo = 2; public Letra (GregorianCalendar gcFechaSuscripcion, int dTipoInteres,int iValor) public double calcularInteres (GregorianCalendar fecha)
BONO final private int iaosPlazo = 5; public Bono (GregorianCalendar gcFechaSuscripcion, int dTipoInteres,int iValor) public double calcularInteres (GregorianCalendar fecha)
Implementar la clase Letra del tesoro.

import java.util.GregorianCalendar; import java.util.Calendar; public class Letra extends Deuda { final private int iaosPlazo = 2; public Letra (GregorianCalendar gcFechaSuscripcion,int dTipoInteres,int iValor) { this.gcFechaSuscripcion = gcFechaSuscripcion; if ((dTipoInteres > 0) &&(dTipoInteres <= 100)) this.dTipoInteres = dTipoInteres; else System.out.println("El inters debe estar entre 0 y 100."); this.iValor = iValor; } public double calcularInteres (GregorianCalendar fecha) { Calendar gcFechaFinPlazo = gcFechaSuscripcion; // Suma dos aos a la fecha de suscripcin gcFechaFinPlazo.add(Calendar.DATE,2); if (gcFechaFinPlazo.getTimeInMillis()<= fecha.getTimeInMillis()) return (iValor*(dTipoInteres/100)); else return 0; } }
Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina Resolviendo el ejemplo de Manuel. Ejemplo:
GregorianCalendar fecha1 = new GregorianCalendar(2005,10,1); GregorianCalendar fecha2 = new GregorianCalendar(2004,6,1); Letra letra1 = new Letra(fecha1,4,500); Letra letra2 = new Letra(fecha2,5,900); GregorianCalendar fecha3 = new GregorianCalendar(2003,6,10); Bono bono1 = new Bono(fecha3,7,3000); Bono bono2 = new Bono(fecha3,7,3000);
69
Cartera cartera1 = new Cartera(); cartera1.addDeuda(letra1); cartera1.addDeuda(letra2); cartera1.addDeuda(bono1); cartera1.addDeuda(bono2);
Implementar el mtodo calcularTotalIntereses, mtodo de la clase Cartera.

public double calcularTotalIntereses (GregorianCalendar fecha) { double totalDeudas = 0; Deuda auxDeuda; for (int i=0;i<deudas.size();i++) { auxDeuda = (Deuda) deudas.elementAt(i); totalDeudas += auxDeuda.calcularInteres(fecha); } return totalDeudas; }
// por defecto al crear un objeto del tipo gregorian calendar se // crea con la fecha actual GregorianCalendar fecha4 = new GregorianCalendar();
long interesTotales = cartera1.calcularTotalIntereses(fecha4); System.out.println(interesTotales);
8.5.5 Ejercicio 6
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).
70
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 8.5.5.1 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)
Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina Parte 2
71
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()); 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 }
72
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 } 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 }
73
8.5.6 Ejercicio 7
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? 4. Codificar el mtodo que permite enviar mensajes SMS. 8.5.6.1 Solucin Solucin al Apartado 1:
Usuario
private String nombre; private String email; private String movil; private String ip; Usuario(String, String, movil, ip)
Mensaje
private Usuario emisor; private Usuario receptor; private String texto; void enviar()
Usuario
private String nombre; private String email; private String movil; private String ip; Usuario(String, String, movil, ip)
Sms
private int servidor; Sms(Usuario, Usuario, String, int)
Chat
private String cliente; Chat(Usuario, Usuario, String, String)
74
Solucin al Apartado 2: 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. Solucin al Apartado 3: 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; }
Solucin al Apartado 4:
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()); } }
75
8.5.7 Ejercicio 8
Se quiere crear un programa que gestione los mens de un establecimiento. Para ello se tiene una clase men, la cul est formada por el nmero del men, y adems tiene el primer plato, el segundo plato y el postre. El primer plato, segundo plato y postre a su vez estn formados por el nmero del plato y l nombre del plato. La diferencia radica en que en el segundo plato se tiene que saber si se aade guarnicin y en el postre se aclara si es de tipo fruta o dulce. Una vez creadas las clases necesarias con sus atributos y mtodos crear dentro del programa principal unos mens teniendo en cuenta que primero se tienen que crear los platos y postres nombrados a continuacin. Despus se crearn los mens formados por dichos platos y postres. Supongamos que tenemos los primeros: 1. Sopa de fideos. 2. Ensalada de trigueros. 3. Endivias con roquefor. Los segundos: 1. Ternera con patatas. 2. Pescado con ensalada. 3. Fritura. Los postres: 1. Fruta (manzana). 2. Fruta (Kiwis). 3. Dulce (Flan). 4. Dulce (Tarta). Con estos platos se elaborar 3 mens compuesto de: Men nmero 1: 2 primero, 1 segundo, 3 postre. Men nmero 2: 1 primero, 3 segundo, 4 postre. Men nmero 3: 3 primero, 2 segundo, 2 postre. Una vez creados todos los objetos necesarios, tanto para los platos y postres como para los mens, se pide que se lea por pantalla un nmero correspondiente a un men y que se imprima segn el nmero dado el men correspondiente. 8.5.7.1 Solucin Para guardar todos las clases comunes vamos a crear un paquete restaurante, para ello creamos una carpeta que se denomine /restaurante y all vamos guardando todas las clases siguientes:
76
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
package restaurante; public class Plato { private int numeroIdent; private String nombrePlato; public Plato(int numeroIdent, String nombrePlato) { this.numeroIdent = numeroIdent; this.nombrePlato = nombrePlato; } public void setNumIdent(int numeroIdent) { this.numeroIdent = numeroIdent; } public void setNombrePlato(String nombrePlato) { this.nombrePlato = nombrePlato; } public int getNumIdent () { return this.numeroIdent; } public String getNombrePlato() { return this.nombrePlato; } }
1 package restaurante; 2 3 public class PlatoSegundo extends Plato 4 { 5 6 private boolean guarnicion; 7 8 public PlatoSegundo(int numeroIdent, String nombrePlato,boolean guarnicion) 9 { 10 super(numeroIdent,nombrePlato); 11 this.guarnicion = guarnicion; 12 13 } 14 15 public void setGuarnicion(boolean guarnicion) 16 { 17 this.guarnicion = guarnicion; 18 } 19 20 public boolean getGuarnicion () 21 {

22 return this.guarnicion; 23 } 24 }
77
1 package restaurante; 2 3 public class Postre extends Plato 4 { 5 6 private boolean conNata; 7 8 public Postre(int numeroIdent, String nombrePlato,boolean conNata) 9 { 10 super(numeroIdent,nombrePlato); 11 this.conNata = conNata; 12 13 } 14 15 public void setConNata(boolean conNata) 16 { 17 this.conNata = conNata; 18 } 19 public boolean getConNata () 20 { 21 return this.conNata; 22 } 23 }
1 package restaurante; 2 3 public class Menu 4 5 { 6 private int numMenu; 7 private Plato primerPlato; 8 private PlatoSegundo segundoPlato; 9 private Postre postre; 10 11 12 public Menu (int numMenu, Plato primerPlato, PlatoSegundo segundoPlato, Postre postre) 13 { 14 this.numMenu = numMenu; 15 this.primerPlato = primerPlato; 16 this.segundoPlato = segundoPlato; 17 this.postre = postre; 18 19 } 20 21 public void imprimirMenu() 22 { 23 System.out.println("El menu nmero: " + numMenu); 24 System.out.println("El primer es: " + primerPlato.getNombrePlato());; 25 System.out.print("El segundo es: " + segundoPlato.getNombrePlato());
78
26 if (segundoPlato.getGuarnicion()) 27 System.out.println(" con guarnicin"); 28 else 29 System.out.println(); 30 System.out.print("El postre es: " + postre.getNombrePlato()); 31 if (postre.getConNata()) 32 System.out.println(" con nata"); 33 else 34 System.out.println(); 35 36 } 37 38 }
La clase que contiene el mtodo main la guardaremos en el directorio previo al que denominamos restaurante, de forma que as podremos importar el paquete restaurante.
1 import restaurante.*; 2 3 public class EjecutaMenu 4 { 5 6 public static void main (String[] args) 7 { 8 // Creo los primeros platos _ 9 10 Plato primerPlato1 = new Plato (1,"Sopa de fideos"); 11 Plato primerPlato2 = new Plato (2,"Ensalada de trigueros"); 12 Plato primerPlato3 = new Plato (3,"Endivias con roquefor"); 13 14 15 // Creo los segundos 16 17 PlatoSegundo segundoPlato1 = new PlatoSegundo (4,"Ternera",true); 18 PlatoSegundo segundoPlato2 = new PlatoSegundo (5,"Pescado",true); 19 PlatoSegundo segundoPlato3 = new PlatoSegundo (6,"Fritura",false); 20 21 22 // Creo postre_ 23 24 Postre postre1 = new Postre (4,"Fresas",true); 25 Postre postre2 = new Postre (5,"Flan",true); 26 Postre postre3 = new Postre (6,"Tarta",false); 27 28 29 // menu 30 31 Menu menu1 = new Menu(1,primerPlato2,segundoPlato1, postre3); 32 Menu menu2 = new Menu(2,primerPlato1,segundoPlato3, postre1); 33 Menu menu3 = new Menu(3,primerPlato3,segundoPlato2, postre2); 34 35 menu1.imprimirMenu(); 36 menu2.imprimirMenu(); 37 menu3.imprimirMenu(); 38 } 39 40 }

Resumen Java

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Resumen Java

Încărcat de

Drepturi de autor:

Formate disponibile

FUNDAMENTOS DE PROGRAMACIN EN JAVA

Teresa Sastre Toral Alberto Ruiz Cristina

Fundamentos de Programacin en Java

7.3.3 7.3.4 7.4 7.5 7.6 7.7 7.8 8

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

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

2 Elementos bsicos del lenguaje Java

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

2.2 Elementos bsicos para empezar a programar

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

Ahora nos atrevemos a hacer un pequeo programa:

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

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

3 Estructuras de control de flujo

3.2 Estructuras de seleccin

3.2.3 Operador condicional

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

3.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

3.3.4 Ruptura del flujo

3.3.5 Manejo de excepciones

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

3.4 Programa 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

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

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

4 Clases y Objetos (primera parte)

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

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

En cuanto a la estructura de mtodo, se declara dentro de la estructura de clase:

4.2.3 Autorefencia this

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

4.2.4 Mtodo constructor

Si no nos interesa dar valores iniciales, escribiramos:

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

Entonces podremos acceder al valor del atributo de esta forma:

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

4.3.1 Referencias compartidas: alias

Y a continuacin declaramos otra variable y le asignamos el valor de la primera:

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

5 Clases y Objetos (segunda parte)

5.2 Elementos de clase

5.3 Clases predefinidas

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

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

2. Importar el paquete: hay que identificar cada elemento importado.

... 3. Importar todos los elementos del paquete.

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

5.6 Derechos de acceso

5.7 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

Contenido del archivo DiasSemana.java:

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

6.2 Comparacin entre un array y un ArrayList

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

y se iniciaran de la siguiente manera:

Este mtodo aade un nuevo elemento al final de la

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