fi tsastre aruiz

Teresa Sastre Toral

Alberto Ruiz Cristina

I.S.B.N.: 84-690-3077-9

FUNDAMENTOS

DE PROGRAMACIN

EN JAVA

Fundamentos de Programacin en Java

1 INTRODUCCIN............................................................................................................................ 1

2 ELEMENTOS BSICOS DEL LENGUAJE JAVA..................................................................... 2

2.1 ESTRUCTURA DE UN PROGRAMA EN JAVA ................................................................................. 2 2.2 ELEMENTOS BSICOS PARA EMPEZAR A PROGRAMAR................................................................ 3

3 ESTRUCTURAS DE CONTROL DE FLUJO.............................................................................. 6

3.1 OBJETIVOS................................................................................................................................. 6 3.2 ESTRUCTURAS DE SELECCIN.................................................................................................... 6

3.2.1 if ........................................................................................................................................... 6 3.2.2 if-else.................................................................................................................................... 6 3.2.3 Operador condicional .......................................................................................................... 7 3.2.4 switch ................................................................................................................................... 7

3.3 ESTRUCTURAS DE REPETICIN................................................................................................... 8 3.3.1 while..................................................................................................................................... 8 3.3.2 do-while ............................................................................................................................... 8 3.3.3 for......................................................................................................................................... 9 3.3.4 Ruptura del flujo ................................................................................................................ 10 3.3.5 Manejo de excepciones ...................................................................................................... 10

3.4 PROGRAMA DE EJEMPLO .......................................................................................................... 11

4 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

5 CLASES Y OBJETOS (SEGUNDA PARTE).............................................................................. 22

5.1 OBJETIVOS............................................................................................................................... 22 5.2 ELEMENTOS DE CLASE ............................................................................................................. 22 5.3 CLASES PREDEFINIDAS ............................................................................................................ 22 5.4 MBITOS ................................................................................................................................. 22 5.5 PAQUETES ............................................................................................................................... 23 5.6 DERECHOS DE ACCESO ............................................................................................................ 25 5.7 PROGRAMAS DE EJEMPLO ........................................................................................................ 25 5.8 ENUMERADOS.......................................................................................................................... 28

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

6.1 OBJETIVOS............................................................................................................................... 30 6.2 COMPARACIN ENTRE UN ARRAY Y UN ARRAYLIST................................................................ 30 6.3 ARRAY .................................................................................................................................... 30 6.4 ARRAYLIST ............................................................................................................................. 31 6.5 RECORRIDO DE ESTRUCTURAS ................................................................................................. 32 6.6 CDIGO DE EJEMPLO ............................................................................................................... 33

7 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 Reescritura......................................................................................................................... 38 7.3.4 Los constructores ............................................................................................................... 38

7.4 TABLA DE COMPATIBILIDAD .................................................................................................... 39 7.5 COMPATIBILIDAD DE TIPOS...................................................................................................... 39 7.6 REESCRITURA Y LIGADURA DINMICA .................................................................................... 40 7.7 POLIMORFISMO........................................................................................................................ 41 7.8 CLASES ABSTRACTAS .............................................................................................................. 41

8 EJERCICIOS DE PROGRAMACIN EN JAVA...................................................................... 42

8.1 EJEMPLO BSICO DE UN PROGRAMA EN JAVA .......................................................................... 42 8.1.1 Solucin ............................................................................................................................. 42

8.2 EJERCICIOS SOBRE ESTRUCTURAS DE CONTROL....................................................................... 43 8.2.1 Ejercicio 1.......................................................................................................................... 43 8.2.2 Ejercicio 2.......................................................................................................................... 43 8.2.3 Ejercicio 3.......................................................................................................................... 43 8.2.4 Solucin a los ejercicios de estructuras de control del 1 al 3............................................ 43

8.3 EJERCICIOS SOBRE CLASES Y OBJETOS ..................................................................................... 47 8.3.1 Ejercicio 1.......................................................................................................................... 47 8.3.2 Ejercicio 2.......................................................................................................................... 49 8.3.3 Ejercicio 3.......................................................................................................................... 52

8.4 EJERCICIOS SOBRE ESTRUCTURAS DE ALMACENAMIENTO....................................................... 57 8.4.1 Ejercicio 1.......................................................................................................................... 57 8.4.2 Ejercicio 2.......................................................................................................................... 57 8.4.3 Ejercicio 3.......................................................................................................................... 58

8.5 EJERCICIOS DE COMPOSICIN, HERENCIA Y POLIMORFISMO..................................................... 59 8.5.1 Ejercicio 1.......................................................................................................................... 59 8.5.2 Ejercicio 2.......................................................................................................................... 63 8.5.3 Ejercicio 3.......................................................................................................................... 64 8.5.4 Ejercicio 4.......................................................................................................................... 67 8.5.5 Ejercicio 6.......................................................................................................................... 69 8.5.6 Ejercicio 7.......................................................................................................................... 73 8.5.7 Ejercicio 8.......................................................................................................................... 75

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

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 Fundamentos de Programacin en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

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),


!= (distinto). Tambin se usan los operadores AND (Y, representado por &&) y OR (O, representado por ||). Por ejemplo, la expresin:

(x>=0)&&(x


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

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.

condicin

sentencias

true

false


Sintaxis en java:

if (condicin) { sentencias; } else { sentencias; }

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

condicin

sentencias 2

truefalse

sentencias 1


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

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

condicin sentenciastrue

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


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 }


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


58 temp1 = 1; 59 System.out.println("Se escribir 1: " + temp1--); 60 /* Otros operadores de asignacin */ 61 temp1=10; 62 temp1+=20; // temp1 valdr ahora 30 63 64 /* ESTRUCTURAS DE SELECCION: IF */ 65 boolean flag=true; 66 67 if ((flag!=true) || (7y) 91 { 92 System.out.println("Estructuras de control anidadas"); 93 } 94 } 95 } 96 97 int dia=2; 98 if (dia==1) 99 { 100 System.out.println("Lunes"); 101 } 102 else if (dia==2) 103 { 104 System.out.println("Martes"); 105 } 106 else if (dia==3) 107 { 108 System.out.println("Mircoles"); 109 } 110 else if (dia==4) 111 { 112 System.out.println("Jueves"); 113 } 114 else if (dia==5) 115 { 116 System.out.println("Viernes"); 117 } 118


119 /* ESTRUCTURAS DE SELECCIN: SWITCH */ 120 switch(dia) 121 { 122 case 1: 123 System.out.println("Lunes"); 124 break; 125 case 2: 126 System.out.println("Martes"); 127 break; 128 case 3: 129 System.out.println("Mircoles"); 130 break; 131 case 4: 132 System.out.println("Jueves"); 133 break; 134 case 5: 135 System.out.println("Viernes"); 136 default: 137 System.out.println("Ninguno de los anteriores"); 138 } 139 140 switch(dia) 141 { 142 case 1: 143 case 2: 144 case 3: 145 case 4: 146 case 5: 147 System.out.println("Da Laborable"); 148 break; 149 case 6: 150 case 7: 151 System.out.println("Fin de Semana"); 152 break; 153 default: 154 System.out.println("Error. No es un da de la semana"); 155 } 156 157 /* ESTRUCTURAS DE SELECCIN: OPERADOR CONDICIONAL */ 158 System.out.print("El mayor es "); 159 System.out.println(x>y ? x: y); 160 161 /* ESTRUCTURAS DE REPETICIN: WHILE */ 162 int i = 5; 163 while (i>0) 164 { 165 System.out.println("Paso por el bucle while 5 veces."); 166 i--; 167 } 168 i = 5; 169 while (i-->0) 170 { 171 System.out.println("Paso por el 2do bucle while 5 veces."); 172 } 173 i = 4; 174 while (--i>0) 175 { 176 System.out.println("Paso por el 3er bucle while 3 veces."); 177 } 178 179 /* ESTRUCTURAS DE REPETICIN: DO-WHILE */


180 i=4; 181 do 182 { 183 System.out.println("Paso por el bucle do-while 5 veces."); 184 } 185 while (i-->0); 186 187 do 188 { 189 System.out.println("El do-while ejecuta al menos 1 vez."); 190 } 191 while (10>100); 192 193 /* ESTRUCTURAS DE REPETICIN: FOR */ 194 for (int k=1; k


241 intentos++; 242 } 243 } 244 while (numero10); 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


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; declaro la variable x del tipo entero

Cliente c; declaro el objeto c de la clase Cliente

Las clases nos permiten definir nuestros propios tipos, ms elaborados y con ms funcionalidades.

La clase est formada por las caractersticas que la definen, tambin llamadas atributos, y las acciones que puede llevar a cabo, que pasaremos a llamar mtodos.

La estructura que tiene una clase se muestra en el siguiente ejemplo:

tipoAcceso class NombreClase {

tipoAcceso TipoAtributo nombreAtributo; tipoAcceso TipoDevuelto nombreMtodo (TipoParametro1 nombreParametro1, TipoParametroN nombreParametroN) {

Tipo nombreVariableLocal; sentencias; /* Si el tipo de retorno es distinto del void tendr que tener

la palabra reservada return */ }

}

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.


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.


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


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


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();


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.


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 ( int y ) 10 { 11 int z; 12 x = y; 13 this.m1 ( ) ; 14 } //m2 15 } //c1

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.


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


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 Sintaxis Visibilidad

Privada private int x; Slo dentro de la clase

Por defecto int x; Clases dentro del paquete

Protegida protected int x; Clases dentro del paquete y subclases dentro o fuera del paquete

Pblica public int x; Todas las clases

Ahora podemos entender los privilegios relacionados con los paquetes, pero an no hemos visto el concepto de subclases, que se reserva para la siguiente clase.

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 ;


27 numeroPersonal = parNumeroPersonal; 28 29 } 30 31 /* En la estructura de la clase se declara 32 a continuacin las acciones o 33 mtodos que pueden llevar a cabo */ 34 35 // Estos son los mtodos modificadores 36 public void setNombre(String nombre) 37 { 38 /* Se utiliza la autorefencia this para 39 discernir entre el atributo y el parmetro */ 40 this.nombre = nombre; 41 } 42 43 public void setApellidos(String parApellidos) 44 { 45 apellidos = parApellidos; 46 } 47 48 public void setAoDeNacimiento(int parAoDeNacimiento) 49 { 50 aoDeNacimiento = parAoDeNacimiento; 51 } 52 53 public void setNumeroPersonal(int parNumeroPersonal) 54 { 55 numeroPersonal = parNumeroPersonal; 56 } 57 58 public void setGrupo(String parGrupo) 59 { 60 grupo = parGrupo; 61 } 62 63 public void setHorario(char parHorario) 64 { 65 horario = parHorario; 66 } 67 68 public void ponCurso (String parGrupo, char parHorario) 69 { 70 grupo = parGrupo; 71 if (numeroPersonal > 35 ) 72 { 73 horario = 'T';_ 74 } 75 else 76 { 77 horario = parHorario; 78 } 79 80 } 81 82 /* Este mtodo est sobrecargado ya que 83 se crea dos veces con distintos parametros */ 84 85 public void ponCurso (String parGrupo) 86 { 87 grupo = parGrupo;


88 if (numeroPersonal > 70 ) 89 { 90 horario = 'M'; 91 } 92 93 } 94 95 // Estos son los mtodos de consulta 96 public String getNombre() 97 { 98 return this.nombre; 99 } 100 101 public String getApellidos() 102 { 103 return apellidos; 104 } 105 106 public int getAoDeNacimiento() 107 { 108 return aoDeNacimiento; 109 } 110 111 public int getNumeroPersonal() 112 { 113 return numeroPersonal; 114 } 115 116 public String getGrupo() 117 { 118 return grupo; 119 } 120 121 public char getHorario() 122 { 123 return horario; 124 } 125 126 // mtodos de comportamiento 127 public void imprime () 128 { 129 System.out.println("Nombre: " + nombre + 130 + " Apellidos: " + apellidos); 131 System.out.println("Ao de nacimiento: " + aoDeNacimiento); 132 System.out.println("Nmero personal: " + numeroPersonal); 133 /* Se puede acceder desde la clase 134 al atributo o llamando al mtodo*/ 135 System.out.println("Grupo: " + grupo + " horario: " 136 + getHorario()); 137 System.out.println(); 138 } 139 } // fin de la clase Alumno


Una vez creada la clase Alumno ya podemos crear objetos de dicha clase para poder trabajar con alumnos concretos, para ello vamos a crearnos otra clase llamada TerceraClase que tendr un mtodo main. Esta clase se almacenar en la misma carpeta que la clase Alumno porque de lo contrario no funcionara con lo estudiado hasta ahora. Esta clase crear alumnos y realizar varias acciones con ellos. Si se hubiera querido se hubiera podido crear el mtodo main en la misma clase Alumno, pero para ver la utilidad de la reutilizacin de clases hemos decidido no realizar el mtodo main en dicha clase.

1 public class 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:


Contenido del archivo Turno.java:

public enum Turno {MAANA, TARDE, NOCHE}

Contenido del archivo DiasSemana.java:

public enum DiasSemana {LUNES, MARTES, MIERCOLES, JUEVES, VIERNES}

A propsito del ejemplo del turno, obsrvese la siguiente clase de ejemplo y el uso de los tipos enumerados: el atributo turno se declara como un objeto de la clase Turno que acabamos de definir.

public class Alumno { private String 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); } }


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, Mircoles, Jueves, Viernes};

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]);


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 arrayEnteros = new ArrayList();

ArrayList alumnos = new ArrayList();

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 miNuevoArray = new ArrayList(otroArray);

A continuacin se resumen algunos de los mtodos ms interesantes que nos ofrece la clase ArrayList:

boolean add(Object o) Este mtodo aade un nuevo elemento al final de la lista.

boolean remove(Object o) Este mtodo borra el objeto que se pasa como parmetro si ste est presente dentro de la lista. Si no est el mtodo devuelve false.

boolean remove(int i) Este mtodo borra el objeto que se encuentra en la posicin i de la lista. Si no est el mtodo devuelve false.

int size() Este mtodo es similar al atributo length del array y devuelve el tamao del ArrayList.


boolean contains(Object elem) Devuelve true si el ArrayList contiene el elemento especificado.

int indexOf(Object elem) Como el anterior, pero devuelve la posicin en que se encuentra el elemento. Si no est devuelve -1.

boolean isEmpty() Este mtodo comprueba si hay elementos en el ArrayList.

void clear() Borra todos los elementos del ArrayList.

Object get(int index) Devuelve el elemento especificado en la posicin del ArrayList.

El resto de los mtodos pueden encontrarse en la documentacin que aporta la web de Java:

http://java.sun.com/j2se/1.5.0/docs/api/java/util/ArrayList.html

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

}


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 cuadrados = new ArrayList(); Cuadrado c1 = new Cuadrado(10); Cuadrado c2 = new Cuadrado(20); cuadrados.add(c1); cuadrados.add(c2); cuadrados.add(new Cuadrado(30)); // recorrido abreviado de estructuras for (Cuadrado i_cuadrado: cuadrados) { System.out.println("Lado del cuadrado: " + i_cuadrado.getLado()); }


// siempre podemos usar nmeros como elementos: ArrayList arrayEnteros = new ArrayList(); arrayEnteros.add(5); arrayEnteros.add(7); // recorrido abreviado for (Integer numero: arrayEnteros) { System.out.println(numero); }

// recorrido tradicional for (int i=0; i


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 import java.util.Calendar; 2 3 public class Billete 4 { 5 private long numBillete; 6 private Calendar fechaHora; 7 private int numAsiento; 8 private String locSalida; 9 private String locLlegada; 10 private Cliente cliente; 11 private int precio; 12 13 public Billete (long numBillete, Calendar fechaHora, 14 int numAsiento,String locSalida, String locLlegada, 15 Cliente cliente, int precio) 16 { 17 this.numBillete = numBillete; 18 this. fechaHora = fechaHora; 19 this.numAsiento = numAsiento; 20 this.locSalida = locSalida; 21 this.locLlegada = locLlegada; 22 this.cliente = cliente; 23 this.precio = precio; 24 } 25 }

Ejemplo 1

Los datos del cliente (dni, nombre, apellido) quedaran recogidos en la clase Cliente.


Grficamente la composicin se representara de esta forma:

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.

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,, Stringnombre, String apellido)

Billete



Billete



Cliente



Cliente




Ejemplo:

La clase Billete Tren tiene los mismos atributos y mtodos que la clase Billete. La diferencia es que el billete del tren tiene un atributo adicional: la categora. Por eso la clase BilleteTren sera de la siguiente forma:

1 import java.util.Calendar; 2 3 public class BilleteTren extends Billete 4 { 5 private String categoria; 6 7 public BilleteTren (long numBillete, Calendar fechaHora, 8 int numAsiento, String locSalida, String locLlegada, 9 Cliente cliente, int precio, String categoria) 10 { 11 super(numBillete,fechaHora,numAsiento, 12 locSalida,locLlegada,cliente,precio); 13 } 14 }

Ejemplo 3

En el anterior ejemplo todos los billetes de tren son tambin billetes, pero no ocurre lo mismo al revs: no todos los billetes son billetes de tren.

Para reconocer la herencia podemos preguntarnos si, por ejemplo, el billete de tren es-un billete. Si esto se corresponde entonces puede que necesitemos herencia cuando desarrollemos aplicaciones.

Un ejemplo grfico de cmo quedara la herencia (incluyendo la composicin anterior) sera:

Billete



Cliente



BilleteTren

private String categoria;

public BilleteTren (long numBillete, Calendar fechaHora, int numAsiento, String locSalida, String locLlegada, Cliente cliente, int precio, StringCategoria)

Billete



Cliente



Billete



Billete



Cliente



Cliente



BilleteTren



BilleteTren



Figura 1


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 Billete billete = billeteTren;

Realizacin de casting BilleteTren billeteTren = (BilleteTren) billete;

Ejemplo 4

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

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 Sintaxis Visibilidad

Privada private int x; Slo dentro de la clase

Por defecto int x; Clases dentro del paquete

Protegida protected int x; Clases dentro del paquete y subclases dentro o fuera del paquete

Pblica public int x; Todas las clases

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;


7.4 Tabla de compatibilidad

Esta tabla aclara cundo podemos utilizar los conceptos de composicin y herencia:

Composicin Clase contendora Clase contenida

Herencia Clase hijo Clase base o padre

Ejemplos:

Composicin Aula Profesor

Herencia Profesor Persona

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)


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


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; } . . . }


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 me

fi tsastre aruiz

Documents