• Author / Uploaded
• TitusRodrigalvarez

Citation preview

FUNDAMENTOS DE PROGRAMACIÓN EN JAVA

Teresa Sastre Toral Madrid-Las Tablas

Alberto Ruiz Cristina Madrid Sur-Pinto (Revisión 2014)

Fundamentos de Programación en Java 1

ELEMENTOS BÁSICOS DEL LENGUAJE JAVA .................................................................. 1 1.1 1.2

2

ESTRUCTURA DE UN PROGRAMA EN JAVA ................................................................................... 1 ELEMENTOS BÁSICOS PARA EMPEZAR A PROGRAMAR .................................................................. 2

ESTRUCTURAS DE CONTROL DE FLUJO ........................................................................... 4 2.1 OBJETIVOS ................................................................................................................................ 4 2.2 ESTRUCTURAS DE SELECCIÓN .................................................................................................... 4 2.2.1 if...................................................................................................................................... 4 2.2.2 if-else .............................................................................................................................. 5 2.2.3 Operador condicional ...................................................................................................... 5 2.2.4 switch .............................................................................................................................. 5 2.3 ESTRUCTURAS DE REPETICIÓN ................................................................................................... 6 2.3.1 while ............................................................................................................................... 6 2.3.2 do-while .......................................................................................................................... 7 2.3.3 for ................................................................................................................................... 7 2.3.4 Ruptura del flujo .............................................................................................................. 8 2.3.5 Manejo de excepciones .................................................................................................... 8 2.4 PROGRAMAS DE EJEMPLO ........................................................................................................... 9 2.4.1 Programa 1 ..................................................................................................................... 9 2.4.2 Programa 2 ................................................................................................................... 14

3

CLASES Y OBJETOS .............................................................................................................. 15 3.1 OBJETIVOS .............................................................................................................................. 15 3.2 CLASE ..................................................................................................................................... 15 3.2.1 Atributos........................................................................................................................ 16 3.2.2 Métodos......................................................................................................................... 16 3.2.3 Autorefencia this............................................................................................................ 17 3.2.4 Método constructor........................................................................................................ 18 3.2.5 Sobrecarga .................................................................................................................... 19 3.3 OBJETOS ................................................................................................................................. 19 3.3.1 Referencias compartidas: alias ...................................................................................... 20 3.4 EJEMPLO DE CÓDIGO ................................................................................................................ 20 3.5 ELEMENTOS DE CLASE ............................................................................................................. 22 3.6 CLASES PREDEFINIDAS ............................................................................................................. 22 3.7 ÁMBITOS................................................................................................................................. 22 3.8 PAQUETES ............................................................................................................................... 23 3.9 DERECHOS DE ACCESO ............................................................................................................. 25 3.10 PROGRAMAS DE EJEMPLO .................................................................................................... 26 3.11 ENUMERADOS ..................................................................................................................... 29

4

ESTRUCTURAS DE ALMACENAMIENTO .......................................................................... 30 4.1 4.2 4.3 4.4 4.5 4.6

5

OBJETIVOS .............................................................................................................................. 30 COMPARACIÓN ENTRE UN ARRAY Y UN ARRAYLIST .................................................................. 30 ARRAY.................................................................................................................................... 30 ARRAYLIST ............................................................................................................................. 31 RECORRIDO DE ESTRUCTURAS .................................................................................................. 32 CÓDIGO DE EJEMPLO ................................................................................................................ 34

DOCUMENTACIÓN DE LAS CLASES .................................................................................. 35 5.1 5.2 5.3

ANTES DE LA CLASE: ............................................................................................................... 35 ANTES DE UN MÉTODO: ............................................................................................................ 35 GENERAR LA DOCUMENTACIÓN................................................................................................ 36

6

COMPOSICIÓN, HERENCIA Y POLIMORFISMO ............................................................. 37 6.1 OBJETIVOS .............................................................................................................................. 37 6.2 COMPOSICIÓN ......................................................................................................................... 37 6.3 HERENCIA ............................................................................................................................... 38 6.3.1 Compatibilidad de tipos ................................................................................................. 40 6.3.2 Ámbitos y visibilidad...................................................................................................... 40 6.3.3 Reescritura .................................................................................................................... 40 6.3.4 Los constructores........................................................................................................... 40 6.4 TABLA DE COMPATIBILIDAD..................................................................................................... 41 6.5 COMPATIBILIDAD DE TIPOS ...................................................................................................... 41 6.6 REESCRITURA Y LIGADURA DINÁMICA ...................................................................................... 42 6.7 POLIMORFISMO ....................................................................................................................... 42 6.8 CLASES ABSTRACTAS .............................................................................................................. 43

7

EJEMPLOS DE PROGRAMAS ............................................................................................... 44 7.1 7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.9 7.10

PROGRAMAS SENCILLOS SOBRE ESTRUCTURAS DE CONTROL ...................................................... 44 EJERCICIO SOBRE CONSTRUCTORES .......................................................................................... 47 EJERCICIOS SOBRE ESTRUCTURAS DE ALMACENAMIENTO ......................................................... 51 EJERCICIO SENCILLO CON ORIENTACIÓN A OBJETOS .................................................................. 53 GESTOR DE CUADRADOS .......................................................................................................... 55 PROGRAMA SOBRE COMPOSICIÓN Y HERENCIA .......................................................................... 59 PROGRAMA SOBRE COMPOSICIÓN Y HERENCIA II ....................................................................... 61 PROGRAMA SOBRE COMPOSICIÓN Y HERENCIA III ..................................................................... 64 GESTOR DE ANIMALES ............................................................................................................. 66 GESTOR DE ANIMALES AÑADIENDO HERENCIA ...................................................................... 69

Fundamentos de Programación en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

1

1 Elementos básicos del lenguaje Java 1.1 Estructura de un programa en Java En Java se llama programa a un conjunto de clases. Una clase es un archivo de extensión “.java” que normalmente describe un concepto, como “Triangulo” o “Alumno”. De momento no entramos en el concepto de clase, que se abordará más adelante. Una de las clases (archivos) del programa debe tener un método llamado “main”. Un método describe una acción que realiza la clase. Por ejemplo, “calcularArea” podría ser un método de la clase Triangulo, mientras que “obtenerDni” podría ser un método de la clase Persona. De nuevo nos remitimos a capítulos posteriores para ahondar en el concepto de método. De momento nos quedamos, por tanto, con que el programa más sencillo que podamos escribir estará compuesto por una sola clase, que tendrá un método llamado “main” (principal en inglés) por donde el programa empezará a ejecutar. A continuación se escribe el programa más sencillo que se puede escribir en Java, y que iría 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 números se han incluido para poder referirnos a cada línea, pero en el programa no se escribirían. Sugerimos al alumno que adquiera una visión general de este programa pero que aún no se preocupe por no comprender los detalles. Los elementos fundamentales que vemos en este programa son: 

Línea 1: formalizamos la clase (“class”) Ejemplo (el nombre debe coincidir con el del archivo, incluidas las mayúsculas y minúsculas).



Línea 3: declaramos el método “main”.



Línea 5: aquí vendrían las acciones del programa. En este caso sólo tenemos una acción, que imprime en pantalla el mensaje “Hola”.

Obsérvese que en Java se utilizan las llaves para delimitar los distintos elementos. Así, las llaves de las líneas 2 y 7 delimitan la clase “Ejemplo”, mientras que las llaves más internas de las líneas 4 y 6 delimitan el método “main”. Es una buena costumbre utilizar los tabuladores para que el programa se lea de forma más sencilla y agradable. Así, cada vez que se abra una llave, conviene escribir las líneas siguientes con una tabulación más que la anterior. El resto del capítulo tratará de introducir de forma eminentemente práctica los conceptos fundamentales para poder empezar a programar. Recomendamos al alumno que, una vez estudie este capítulo, acuda al anexo para aprender a poner en marcha el entorno de trabajo en su ordenador y trate de reproducir en su máquina los programas de ejemplo que se irán mostrando a continuación.

2

Fundamentos de Programación en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

1.2 Elementos básicos para empezar a programar Ya hemos visto cómo dar forma a un programa de prueba, y cómo imprimir en pantalla un texto. También es posible escribir en pantalla operaciones numéricas: System.out.println((15 -2 + 7)/2);

Sin embargo, la programación no sería muy útil si siempre fuese necesario utilizar valores numéricos 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 básica, al pulsar la tecla “Memoria” de nuestra calculadora tradicional. Surge así el concepto de variable. Al igual que en Matemáticas, las variables son representaciones simbólicas de un valor numérico que puede variar a lo largo de la ejecución del programa. Sin embargo, en Java vamos un paso más allá y establecemos que las variables no sólo pueden ser números, sino que también pueden contener, por ejemplo, cadenas de texto. Surge así el concepto de tipo de datos. En Matemáticas, cuando decimos “x = 6”, se asume que x es un número. En Java hay que hacerlo explícito: int x; x = 6;

En la primera línea 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";

Obsérvese que en la propia línea de declaración también podemos darle valores iniciales con el operador “=”. A eso se le llama asignación. Más adelante se verá que puede haber variables de muchos más tipos. También 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 fácil acostumbrarse a hacerlo y redunda en unos programas más sencillos y fáciles de leer. Las reglas básicas son: 

Los tipos predefinidos, variables y métodos se escriben en minúscula, como “int”, “area” y “main”.



Las constantes se escriben en mayúsculas, como “PI”.



Las clases se escriben con la inicial en mayúscula, como “Ejemplo”.

Otro elemento interesante son los comentarios. Se trata de texto que Java no interpretará, y que sólo sirve para que nosotros escribamos información sobre el programa que consideremos interesante. Por ejemplo:

Fundamentos de Programación en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

3

/* 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 líneas. El segundo tipo se llama comentario de línea y sólo afecta al texto que va detrás de los símbolos “//” hasta terminar la línea. ¿Es posible asignar a una variable el valor de otra variable de distinto tipo? La respuesta es sí, pero con precaución. En caso de que no haya pérdida de información, 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 pérdida de información, 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 conversión forzada de tipo: double d2 = 4.56; int i2 = (int) d2; // correcto

Ahora nos atrevemos a hacer un pequeño programa: double base; double altura; double areaRectangulo; base = 5.4 ; altura = 2.3; areaRectangulo = base * altura ; System.out.println("El área del rectángulo es: " +

areaRectangulo) ;

Obsérvese que al escribir por pantalla podemos concatenar valores de texto con valores numéricos o variables, a través 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 capítulo de introducción destacando que tanto “2+4*7” como “base*altura” son expresiones numéricas. Existe otro tipo de expresiones, llamadas lógicas, cuyo resultado no es un valor numérico sino un valor lógico: cierto (“true”) o falso (“false”). La utilidad de este tipo de expresiones se verá en el próximo capítulo: de momento basta con aprender a escribirlas. Para ello se utilizan operadores lógicos como “>” (mayor), “=0)&&(x0) { System.out.println("Paso por el bucle while 5 veces."); i--; } i = 5; while (i-->0) { System.out.println("Paso por el 2do bucle while 5 veces."); } i = 4; while (--i>0) { System.out.println("Paso por el 3er bucle while 3 veces."); }

11

12

Fundamentos de Programación en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226

/* ESTRUCTURAS DE REPETICIÓN: DO-WHILE */ i=4; do { System.out.println("Paso por el bucle do-while 5 veces."); } while (i-->0); do { System.out.println("El do-while ejecuta al menos 1 vez."); } while (10>100); /* ESTRUCTURAS DE REPETICIÓN: FOR */ for (int k=1; k 70 ) { horario = 'M'; } } // Estos son los métodos de consulta public String getNombre() { return this.nombre; } public String getApellidos() { return apellidos; } public int getAñoDeNacimiento() { return añoDeNacimiento; } public int getNumeroPersonal() { return numeroPersonal; } public String getGrupo() { return grupo;

27

28 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 }

Fundamentos de Programación en Java. Teresa Sastre Toral, Alberto Ruiz Cristina } public char getHorario() { return horario; } // métodos de comportamiento public void imprime () { System.out.println("Nombre: " + nombre + + " Apellidos: " + apellidos); System.out.println("Año de nacimiento: " + añoDeNacimiento); System.out.println("Número personal: " + numeroPersonal); /* Se puede acceder desde la clase al atributo o llamando al método*/ System.out.println("Grupo: " + grupo + " horario: " + getHorario()); System.out.println(); } // fin de la clase Alumno

Una vez creada la clase Alumno ya podemos crear objetos de dicha clase para poder trabajar con alumnos concretos, para ello vamos a crearnos otra clase llamada TerceraClase que tendrá un método main. Esta clase se almacenará en la misma carpeta que la clase Alumno porque de lo contrario no funcionaría con lo estudiado hasta ahora. Esta clase creará alumnos y realizará varias acciones con ellos. Si se hubiera querido se hubiera podido crear el método main en la misma clase Alumno, pero para ver la utilidad de la reutilización de clases hemos decidido no realizar el método main en dicha clase. 1 public class Test 2 { 3 4 public static void main (String []args) 5 { 6 /* Declaramos un objeto de tipo Alumno y lo creamos, 7 observar que no podriamos utilizar el constructor 8 por defecto Alumno() ya que en la clase Alumno ya hemos 9 definido un constructor nuevo con parametros */ 10 Alumno guille = new Alumno("Guillermo","Puertas",1955,36); 11 guille.ponCurso("FUND_INF",'M'); 12 guille.imprime(); 13 /*Al declarar una nueva referencia al objeto y asignarle 14 el antiguo objeto no se crea un objeto nuevo sino que las 15 dos referencias guille y alumno1 apuntan al mismo 16 objeto. Se puede observar al imprimir el alumno1*/ 17 18 Alumno alumno1 = guille; 19 alumno1.imprime(); 20 /* Si queremos que el alumno1 tenga unos datos distintos 21 tendremos que crear otro objeto distinto al de guille, 22 de la siguiente forma */ 23 24 alumno1 = new Alumno("Linus","Torvalds",1969,22); 25 guille.ponCurso("FUND_INF",'M'); 26 alumno1.imprime(); 27 } 28 }

Fundamentos de Programación en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

29

3.11 Enumerados Existe un tipo de clase un poco especial, que define tipos de datos enumerados. Supongamos que queremos describir en un atributo un día de la semana, o el turno en que un alumno de un curso está matriculado. Para facilitar esta tarea existen los tipos enumerados, que sólo admiten un rango determinado de valores. Estos tipos constituyen clases. Para definir los tipos correspondientes a los ejemplos anteriores crearíamos dos clases: Turno y DiasSemana. Su contenido sería distinto al de las clases que hemos visto hasta ahora: Contenido del archivo Turno.java: public enum Turno {MAÑANA, TARDE, NOCHE}

Contenido del archivo DiasSemana.java: public enum DiasSemana {LUNES, MARTES, MIERCOLES, JUEVES, VIERNES}

A propósito del ejemplo del turno, obsérvese 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","López",Turno.MAÑANA); } }

30

Fundamentos de Programación en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

4 Estructuras de almacenamiento 4.1 Objetivos Una variable u objeto puede representar un número, 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 capítulo es dar a conocer diferentes estructuras de almacenamiento. En concreto, vamos a estudiar los arrays y los ArrayList.

4.2 Comparación entre un array y un ArrayList La diferencia fundamental entre ambas estructuras es que el array es una colección de tamaño fijo, mientras que el ArrayList es una colección de tamaño dinámico. Es decir, al declarar un array tenemos que conocer de antemano el tamaño que queremos que tenga la colección, mientras que en el caso del ArrayList no hace falta que le indiquemos el tamaño, sino que será él quien automáticamente vaya adaptando su tamaño al número de elementos. Por lo demás en ambos casos se trata de objetos, por tanto ambos deben inicializarse mediante el operador new, sólo que los arrays son un tipo predefinido y los ArrayList hay que importarlos del paquete java.util. Nota: de la Física heredamos el nombre del vector para los array de tamaño fijo con valores numéricos; sin embargo no recomendamos utilizar este término en ningún caso ya que Java implementa una clase Vector (no estudiada en la asignatura) que se parece mucho a ArrayList y por tanto es de tamaño dinámico. El uso de la palabra vector en programación, por tanto, no está claro y conviene evitar dicho término para evitar confusiones.

4.3 Array Cuando se trabaja con varios elementos del mismo tipo podemos declarar un array de dos formas : int [ ] arrayEnteros; String diasSemana[ ];

Todos los elementos del array tendrán que ser del mismo tipo. Observa que el array es un objeto y debe inicializarse: arrayEnteros = new int[20]; diasSemana = new String [100];

El número entre los corchetes indica el tamaño que tendrá el array, es decir, el número máximo de elementos que podrá contener. Existe una forma de juntar en una sola sentencia la inicialización y el relleno del array: int [] arrayEnteros = {1, 2, 3, 4, 5}; String [] diasSemana = {“Lunes”, “Martes”, “Viernes”};

“Miércoles”,

“Jueves”,

Con estas sentencias fijamos también el tamaño del vector; este sistema sólo es recomendable si el tamaño del array va a ser reducido. Ahora si queremos acceder e imprimir, según el ejemplo anterior al martes, tendríamos que hacer lo siguiente: System.out.println(“El día es: ” + diasSemana[1]);

Fundamentos de Programación en Java. Teresa Sastre Toral, Alberto Ruiz Cristina

31

Obsérvese que pedimos la posición 1: esto es debido a que los elementos de los arrays empiezan a contar desde 0 y terminan, por tanto, en (número de elementos – 1). Para asignar un valor a un elemento de un array sólo es necesario decir en que posición se encuentra el elemento al que se le quiere asignar el valor. arrayEnteros[2] = 5;

Esto indica que en la tercera posición del array “arrayEnteros” se ha introducido el valor 5. Además de los arrays de una dimensión puede haber arrays de dos, tres, cuatro ó n dimensiones. Por ejemplo, un array de dos dimensiones y valores numéricos representa lo que conocemos como matriz. Este tipo de arrays se declararían, por ejemplo, de la siguiente forma: int [ ][ ] tabla;

y se iniciarían de la siguiente manera: tabla = new int [5][7];

4.4 ArrayList A diferencia de los arrays, cuyo tamaño es fijo, las colecciones en Java (de las que ArrayList es un ejemplo) son estructuras de almacenamiento que crecen dinámicamente. Esto quiere decir que no tienen un tamaño determinado: se les puede asignar un tamaño de inicio, pero éste variará automáticamente si se introducen más 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 símbolos de menor y mayor. En ArrayList no hay forma de inicializar valores como hacíamos con los arrays, pero sin embargo tenemos la opción de crear un ArrayList copiando en él todos los elementos de otro. Ejemplo: ArrayList miNuevoArray = new ArrayList(otroArray);

A continuación se resumen algunos de los métodos más interesantes que nos ofrece la clase ArrayList: 

boolean add(Object o)  Este método añade un nuevo elemento al final de la

lista. 

boolean remove(Object o)  Este método borra el objeto que se pasa como

parámetro si éste está presente dentro de la lista. Si no está el método devuelve false. 

boolean remove(int i)  Este método borra el objeto que se encuentra en la

posición i de la lista. Si no está el método devuelve false. 

int size()  Este método es similar al atributo length del array y devuelve el

tamaño del ArrayList.

32

Fundamentos de Programación en Java. Teresa Sastre Toral, Alberto Ruiz Cristina



boolean contains(Object elem)  Devuelve true si el ArrayList contiene el

elemento especificado. 

int indexOf(Object elem)  Como el anterior, pero devuelve la posición en

que se encuentra el elemento. Si no está devuelve -1. 

boolean isEmpty()  Este método 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 posición del

ArrayList.

El resto de los métodos pueden encontrarse en la documentación que aporta la web de Java: http://java.sun.com/j2se/1.5.0/docs/api/java/util/ArrayList.html

4.5 Recorrido de estructuras Al trabajar con estructuras es inevitable que surja el problema de cómo 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 tamaño de la estructura. Para ello: 

En arrays tenemos disponible el atributo “length”



En ArrayList tenemos el método “size()”

Recuerda la diferencia porque uno es atributo y el otro es método, aunque representen exactamente lo mismo (el tamaño de la estructura). Tiene sentido que en el caso de los arrays sea un atributo, puesto que no se va a modificar nunca y es por tanto una propiedad de los mismos. En el caso del ArrayList, puesto que modificará con el tiempo su tamaño, es más razonable obtenerlo “preguntándolo” en cada momento con un método. Existen tres formas de recorrer una estructura: Primera: un for normal Ejemplo con arrays: for (int i=0; i < diasSemana.length; i++) { System.out.println(“El día ” + i + “ es ” + diaSemana[i]);

} Ejemplo con ArrayList: for (int i=0; i < diasSemana.size(); i++) { System.out.println(“El día ” + i + “ es ” + diaSemana.get(i));

}

for(int i=0; i