revisores compañeros amigos que han creído en...

Agradecimientos

Gracias… A Dios por la vida misma, por haberme dado la capacidad de pensar y porque me ha permitido llegar sano a este momento. A mis padres por haberme dado la vida, porque gran parte de lo que soy se lo debo a ellos y porque todas sus enseñanzas han sido la base para llegar hasta aquí. A todos mis hermanos porque muchos de sus actos me han servido como ejemplo para terminar este proceso, por su apoyo incondicional y porque siempre han creído en mi. A mi asesora por su sabiduría, asesoría y paciencia durante todo el proceso. A mis revisores por su disposición, porque su valioso aporte ayudo a realizar un trabajo mejor y mas completo. A mis compañeros y amigos que han creído en mi.

Contenido tematico

Programación orientada a objetos en Java

INDICE CONTENIDO DE FIGURAS ................................................................................................. 5 INTRODUCCION................................................................................................................ 6 UNIDAD I. ARREGLOS UNIDIMENSIONALES Y MULTIDIMENSIONALES ......................... 7

1.1 Arreglos Unidimensionales (Listas) .................................................................................... 8 1.1.1 Conceptos básicos..................................................................................................... 8 1.1.2 Operaciones............................................................................................................ 11 1.1.3 Aplicaciones............................................................................................................ 15

1.2 Arreglos Bidimensionales ................................................................................................ 17 1.2.1 Conceptos básicos.................................................................................................. 17 1.2.2 Operaciones............................................................................................................ 19 1.2.3 Aplicaciones............................................................................................................ 26

1.3 Arreglos multidimensionales ........................................................................................... 29 1.3.1 Conceptos básicos................................................................................................... 29 1.3.2 Aplicaciones............................................................................................................ 30

1.4 Ejercicios resueltos......................................................................................................... 32 1.5 Ejercicios propuestos...................................................................................................... 34

UNIDAD II. MÉTODOS Y MENSAJES ............................................................................... 36 2.1 Atributos Const y Static .................................................................................................. 37 2.2 Concepto de método...................................................................................................... 37 2.3 Declaración de Métodos ................................................................................................. 38 2.4 Llamadas a Métodos ...................................................................................................... 39 2.5 Tipos de Métodos........................................................................................................... 40

2.5.1 Métodos Estáticos o de Clase ................................................................................... 40 2.5.2 Métodos Normales .................................................................................................. 43

2.6 Referencia this .............................................................................................................. 44 2.7 Forma de Pasar Argumentos........................................................................................... 45 2.8 Devolver un valor desde un método ................................................................................ 48 2.9 Estructura del Código ..................................................................................................... 51 2.10 Ejercicios Resueltos:..................................................................................................... 51 2.11 Ejercicios propuestos:................................................................................................... 54

UNIDAD III. CONSTRUCTOR, DESTRUCTOR (RECOLECTOR DE BASURA)...................... 56 3.1 Concepto de método constructor .................................................................................... 57 3.2 Recolector de basura (garbage collector)......................................................................... 57 3.3 Declaración de métodos constructores ............................................................................ 59 3.4 Aplicaciones de constructores y destructores (Recolectores de basura) ............................. 60 3.5 Tipos de Métodos Constructores y Destructores (Recolectores de Basura) ......................... 63 3.6 Ejercicios propuestos...................................................................................................... 69

UNIDAD IV. SOBRECARGA.............................................................................................. 70 4.1 Conversión de Tipos....................................................................................................... 71 4.2 Sobrecarga de Métodos.................................................................................................. 76 4.3 Sobrecarga de Operadores ............................................................................................ 83 4.4. Ejercicios resueltos........................................................................................................ 84 4.5 Ejercicios Propuestos...................................................................................................... 87

UNIDAD V. HERENCIA..................................................................................................... 88 5.1 Introducción a la Herencia.............................................................................................. 89 5.2 Herencia Simple............................................................................................................. 90 5.3 Herencia Múltiple ........................................................................................................... 94 5.4 Clase Base y Clase Derivada .......................................................................................... 94

5.4.1 Definición de la Clase Base ..................................................................................... 94 5.4.2 Definición de Clase Derivada.................................................................................... 95

Contenido tematico

Programación orientada a objetos en Java 3

5.5 Parte Protegida.............................................................................................................. 96 5.5.1 Propósito de la Parte Protegida ................................................................................ 96

5.6 Redefinición de los miembros de las clases derivadas....................................................... 97 5.7 Clases Virtuales y Visibilidad ........................................................................................... 98 5.8 Constructores en Clases Derivadas.................................................................................. 98 5.9 Aplicaciones................................................................................................................... 99 5.10 Ejercicios propuestos...................................................................................................110

UNIDAD VI. POLIMORFISMO Y REUTILIZACION ......................................................... 112 6.1 Concepto de polimorfismo .............................................................................................113 6.2 Clases abstractas ..........................................................................................................116

6.2.1 Definición ..............................................................................................................116 6.2.2 Redefinición...........................................................................................................118

6.3 Definición de una Interfaz .............................................................................................120 6.4 Implementación de la Definición de una Interfaz.............................................................121 6.5 Reutilización de la definición de una Interfaz ..................................................................123 6.6 Definición y Creación de Paquetes..................................................................................129 6.7 Reutilización de las clases de un Paquete / Librería .........................................................132 6.8 Clases Genéricas (Plantillas) .........................................................................................134 6.9 Ejercicios Resueltos.......................................................................................................134 6.10 Ejercicios Propuestos...................................................................................................139

UNIDAD VII. EXCEPCIONES.......................................................................................... 140 7.1 Definición .....................................................................................................................141

7.1.1 ¿Qué son las Excepciones? .....................................................................................141 7.1.2 Clases de Excepciones Predefinidas por el Lenguaje .................................................142 7.1.3 Propagación de Excepciones ...................................................................................146

7.2 Gestión de Excepciones .................................................................................................147 7.2.1 Manejo de Excepciones ..........................................................................................148 7.2.1 Lanzamiento de Excepciones ..................................................................................152

7.3 Excepciones Definidas por el Usuario .............................................................................155 7.3.1 Clase Base de las Excepciones ................................................................................155 7.3.2. Creación de una Clase Derivada del Tipo Excepción.................................................157 7.3.3 Manejo de una Excepción Definida por el Usuario.....................................................159

7.4 Ejercicios resueltos........................................................................................................160 7.5 Ejercicios propuestos: ...................................................................................................163

UNIDAD 8.FLUJOS Y ARCHIVOS ................................................................................... 164 8.1 Definición de archivos de texto y Archivos Binarios .........................................................165 8.2 Operaciones Básicas en Archivos de Texto y Binario........................................................166

8.2.1 Crear.....................................................................................................................166 8.2.2 Abrir......................................................................................................................166 8.2.3 Cerrar....................................................................................................................167 8.2.4 Lectura y Escritura .................................................................................................167 8.2.5 Recorrer ................................................................................................................177

8.3 Aplicaciones..................................................................................................................178 8.4 Ejercicios propuestos.....................................................................................................183

CONCLUSIONES ............................................................................................................ 184 ANEXO I. INTRODUCCIÓN AL LENGUAJE JAVA ............................................................ 185

1.1 Introducción .................................................................................................................186 1.2 Características de Java ..................................................................................................186

1.2.1 Simple...................................................................................................................186 1.2.2 Orientado a Objetos ...............................................................................................187 1.2.3 Distribuido .............................................................................................................187 1.2.4 Robusto.................................................................................................................187 1.2.5 Seguro ..................................................................................................................187

Contenido tematico


1.2.6 Portable.................................................................................................................187 1.2.7 Arquitectura Neutral ...............................................................................................187 1.2.8 Rendimiento medio ................................................................................................188 1.2.9 Multithread ............................................................................................................188

1.3 Java frente a los demás lenguajes..................................................................................188 1.4 Como Compilar y Ejecutar Programas en Java ................................................................190

1.4.1 Javac.....................................................................................................................190 1.4.2 Java ......................................................................................................................190 1.4.3 Appletviewer..........................................................................................................190

1.5 Estructuras de Datos Básicas en Java.............................................................................191 1.5.1 Tipos de Datos.......................................................................................................191 1.5.2 Enteros..................................................................................................................191 1.5.3 Tipos de Datos Enteros en Java ..............................................................................192 1.5.4 Tipos de Datos Reales en Java................................................................................192 1.5.5 Caracteres .............................................................................................................192 1.5.6 Boolean .................................................................................................................193 1.5.7 Variables ...............................................................................................................193

1.6 Entornos de Desarrollo de Java......................................................................................194 1.6.1 Bluej .....................................................................................................................194 1.6.2 Jcreator .................................................................................................................194 1.6.3 Jbuilder .................................................................................................................195 1.6.4 Netbeans...............................................................................................................195 1.6.5 Eclipse...................................................................................................................195

ANEXO II. EL ENTORNO DE DESARROLLO ECLIPSE ..................................................... 197 2.1. ¿Que es Eclipse? ..........................................................................................................197 2.2. Trabajando con Eclipse ................................................................................................197

2.2.1. Creación de un proyecto........................................................................................197 2.2.2. Creando clases......................................................................................................198 2.2.3. Ejecutando el programa ........................................................................................199 2.2.4. Depuración de programas......................................................................................199 2.2.5. Otras herramientas interesantes. ...........................................................................200

BIBLIOGRAFIA.............................................................................................................. 207

Indice de figuras

Programación orientada a objetos en Java

CONTENIDO DE FIGURAS Figura 1: Arreglo de 12 elementos ............................................................................................ 11 Figura 2: Ordenamiento de los elementos de un arreglo usando el método de la burbuja ............ 12 Figura 3: Proceso completo del ordenamiento del arreglo .......................................................... 13 Figura 4: Ilustración de los arreglos bidimensionales.................................................................. 17 Figura 5: Ilustración de arreglos bidimensionales (2). ................................................................ 18 Figura 6: Un arreglo de tres dimensiones (4 x 5 x 3).................................................................. 29 Figura 7: Las 36 posibles sumas de los dados............................................................................ 35 Figura 8: El recolector de basura de Java funciona determinando los objetos que son alcanzables.58 Figura 9: Clase bicicleta ........................................................................................................... 90 Figura 10: Ilustración del polimorfismo. ...................................................................................113 Figura 11: Polimorfismo y reutilización .....................................................................................114 Figura 12 Ilustración de la herencia .........................................................................................115 Figura 13 Jerarquía de las clases de excepciones......................................................................142 Figura 14: Propagación de excepciones....................................................................................146 Figura 15 Manejo de Excepciones. ...........................................................................................148 Figura 16: Clase base de la clase Throwable. ...........................................................................156 Figura 17: Primera pantalla de Eclipse .....................................................................................200 Figura 18: Selección del tipo de proyecto en Eclipse .................................................................201 Figura 19: Datos sobre el proyecto en Eclipse ..........................................................................201 Figura 20: Creación de una clase en Eclipse .............................................................................202 Figura 21: Creación de un fichero vació en Eclipse....................................................................202 Figura 22: La perspectiva Java con las vistas mostrando una clase en Eclipse ............................203 Figura 23: Configuración para ejecutar la aplicación: proyecto y clase con el main en Eclipse......203 Figura 24: Argumentos para enviar al programa y argumentos para enviar a la Maquina Virtual en Eclipse ...................................................................................................................................204 Figura 25: Consola con el resultado de la ejecución en Eclipse. .................................................204 Figura 26: Barra de Herramientas de Eclipse. ...........................................................................205 Figura 27: La perspectiva debug en Eclipse. .............................................................................205 Figura 28: La perspectiva debug en acción en Elipse.................................................................206 Figura 29: Asistente de código (pulsando Ctrl + espacio) en Eclipse. .........................................206

Introducción


INTRODUCCION

Actualmente una de las áreas más candentes en la industria y en el ámbito académico es la orientación a objetos. La orientación a objetos promete mejoras de amplio alcance en la forma de diseño, desarrollo y mantenimiento del software ofreciendo una solución a largo plazo a los problemas y preocupaciones que han existido desde el comienzo en el desarrollo de software: la falta de portabilidad del código y reusabilidad, código que es difícil de modificar, ciclos de desarrollo largos y técnicas de codificación no intuitivas.

Un lenguaje orientado a objetos ataca estos problemas. Tiene tres características básicas: debe estar basado en objetos, basado en clases y capaz de tener herencia de clases. Muchos lenguajes cumplen uno o dos de estos puntos; muchos menos cumplen los tres. La barrera más difícil de sortear es usualmente la herencia.

En un principio eran muy pocos los lenguajes de programación que atacaban los tres problemas anteriores. Como una solución a eso, nace Java. Java es un lenguaje de programación con el que se puede realizar cualquier tipo de programa. En la actualidad es un lenguaje muy extendido y cada vez cobra más importancia tanto en el ámbito de Internet como en la informática en general. Está desarrollado por la compañía Sun Microsystems con gran dedicación y siempre enfocado a cubrir las necesidades tecnológicas más punteras.

Una de las principales características por las que Java se ha hecho muy famoso es que es un lenguaje independiente de la plataforma. Eso quiere decir que si hacemos un programa en Java podrá funcionar en cualquier ordenador del mercado. Es una ventaja significativa para los desarrolladores de software.

Actualmente Java se utiliza en un amplio abanico de posibilidades y casi cualquier cosa que se puede hacer en cualquier lenguaje se puede hacer también en Java y muchas veces con grandes ventajas.

El presente material es un libro de texto que sirve como herramienta importante de apoyo para la materia de Programación orientada a objetos (POO) basada en el lenguaje de programación java.

Dicho material se compone de ocho unidades, más dos anexos; una de introducción al lenguaje de programación java y la otra de Eclipse uno de los entornos de desarrollo mas usados en dicho lenguaje. Además cada una de las unidades contiene un apartado de ejercicios resueltos y ejercicios propuestos para que el lector pueda practicar los conocimientos adquiridos.

Cada uno de los temas de las unidades se desarrolló en base a dos o más autores para que el lector pueda comparar y elegir el enfoque que considere más apropiado de acuerdo a su opinión personal.

Unidad I. Arreglos unidimensionales y multidimensionales


UNIDAD I. ARREGLOS UNIDIMENSIONALES Y MULTIDIMENSIONALES

Conceptos básicos, operaciones y aplicaciones con arreglos



Unidad 1. Arreglo Unidimensional Y Multidimensional

1.1 Arreglos Unidimensionales (Listas1)

1.1.1 Conceptos básicos Definición de un arreglo unidimensional (vectores)

En java, un arreglo unidimensional es un grupo de variables (llamadas elementos o componentes) que contienen valores del mismo tipo. Los arreglos son objetos, por lo que se consideran como tipos de referencia. Los elementos de un arreglo en java pueden ser tipos primitivos2 o de referencias (incluyendo arreglos). Para hacer referencia a un elemento específico en un arreglo se debe especificar el nombre de la referencia al arreglo y el número de la posición del elemento en el arreglo. El número de posición del elemento se conoce formalmente como el índice o subíndice del elemento en el arreglo. Todos los elementos de un arreglo deben ser del mismo tipo. Declaración y creación de arreglos Unidimensionales Para crear un arreglo, antes hay que crear una variable de arreglo del tipo deseado. La forma general de un arreglo unidimensional es: Tipo nombre-de-variable[ ]; Los objetos arreglo ocupan espacio en memoria. Todos los objetos en java deben de crearse con la palabra clave new 3. El programador especifica el tipo de cada elemento y el número de elementos que se requieren para el arreglo. La siguiente declaración crea 12 elementos para el arreglo de enteros de nombre c: int c[] = new int[12]; Esta tarea también puede realizarse en dos pasos, como se muestra a continuación: int c[]; //declara la variable arreglo c = new int [12]; //crea el arreglo

Al crear un arreglo cada uno de sus elementos recibe un valor predeterminado de cero para los elementos numéricos de tipos primitivos, falso para los elementos boléanos y nulo para las referencias (cualquier tipo no primitivo).

1 Vectores 2 Tipo primitivo son las variables propias del lenguaje, p. e. char, int, boolean, y float. 3 El operador new se utiliza en Java para la creación de objetos.



En la tabla 1.1.1, se muestra los diferentes valores de inicialización para cada uno de los tipos de variable:

Tipo de elemento Valor inicial byte

int

float

char

referencia a objeto

short

long

double

boolean

0 0

0.0f

‘\u0000’

nulo 0

0L

0.0d

falso

Tabla 1.1 Diferentes valores de inicialización para cada tipo de variable

Si se quiere inicializar un arreglo de valores diferente a los que se muestran en la tabla

anterior, se puede combinar, la declaración, construcción e inicialización en un sólo paso. La siguiente línea de código inicializa un arreglo de 5 flotantes:

float[] diametros = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f};

Se pueden crear varios arreglos en una sola declaración. La siguiente declaración de un arreglo String reserva 100 elementos para b y 27 para x: String b[] = new String [100], x[] = new String [27];

Al declararse un arreglo, su tipo y los corchetes pueden combinarse al principio de las declaraciones para indicar que todos los identificadores en la declaración son referencias a arreglos. Por ejemplo: double[] arreglo1, arreglo2;

En la línea anterior se declara el arreglo1 y arreglo2 como referencias a arreglos de valores double. Como se vio anteriormente, la declaración y creación del arreglo pueden combinarse en la declaración. La siguiente declaración reserva 10 elementos para el arreglo1 y 20 para el arreglo2 de tipo double: double[] arreglo1 = new double[10], arreglo2 = new double[20];



Un programa puede declarar arreglos de cualquier tipo. Todo elemento de un arreglo de tipo primitivo es una variable del tipo declarado del arreglo. Por ejemplo, cada uno de los elementos de un arreglo int es una variable int. En un arreglo que sea de tipo de referencia, cada elemento del arreglo es una referencia a un objeto del tipo declarado de ese arreglo. Cada uno de los elementos de un arreglo String es una referencia a un objeto String.

En la figura 1 se muestra una representación lógica de un arreglo de enteros llamado c, este arreglo contiene 12 elementos (es decir variables). Un programa puede hacer referencia a cualquiera de estos elementos mediante una expresión de acceso a un arreglo que incluye el nombre del arreglo, seguido por el índice del elemento especifico encerrado entre corchetes ([]). El primer elemento en cualquier arreglo tiene el índice cero (lo que se denomina como elemento cero) 4. Por lo tanto, el primer elemento del arreglo c es c[0], el segundo elemento es c[1], el séptimo elemento del arreglo es c[6] y, en general, el i-esimo elemento del arreglo c es[c-i]. Los nombres de los arreglos siguen las mismas convenciones, que los demás nombres de las variables.

Un índice debe ser un entero positivo o una expresión entera que pueda promoverse a un int. Si un programa utiliza una expresión como índice, el programa evalúa la expresión para determinar el índice. Por ejemplo supóngase que la variable a es 5 y que b es 6, entonces la instrucción: C [ a + b ] += 2; suma 2 al elemento c[11] del arreglo. Obsérvese que el nombre del arreglo con subíndice es una expresión de acceso al arreglo. Dichas expresiones pueden utilizarse en el lado izquierdo de una asignación, para colocar un nuevo valor en un elemento del arreglo.

4 En Java todos los Arreglos siempre empiezan con en el subíndice 0.



Figura 1: Arreglo de 12 elementos

1.1.2 Operaciones Ejemplo: Imprimir Elementos del Arreglo Para imprimir, se recorre el arreglo con un ciclo for desde la posición 0 hasta a.length5 - 1. Además, se imprime la palabra "Arreglo" y luego se subraya. Por lo tanto con el ciclo, se imprime cada elemento almacenado en a[i].

Código 1.2.1. Imprime los valores de un arreglo de 10 elementos.

Ordenar Elementos del Arreglo

5 Esta propiedad contiene el tamaño del arreglo.



Para ordenar el arreglo, se usará el algoritmo de la burbuja 6 que consiste en ir comparando el elemento i con i + 1 del arreglo, para ordenar en forma ascendente. Si se encuentra que a[i] es mayor que a[i+1], se intercambian dichos elementos.

Código 1.1.2.2. Ordena los elementos de un arreglo y después los imprime

ya ordenados Por ejemplo, al ejecutar el ciclo for(i = 0 ...) se encuentra que hay que cambiar de posición los elementos "Peru" y "Bolivia". Para realizar este cambio, se lleva a cabo las tres instrucciones que muestra en la figura 2.

Figura 2: Ordenamiento de los elementos de un arreglo usando el método de la burbuja

Ahora bien, además se tiene que aplicar el ciclo for, tantas veces como elementos tenga el arreglo, ya que en el peor caso los elementos podrían estar ordenados en forma descendente. Es para eso que se implementa el ciclo for con el índice k. En la figura 3, se muestra el estado del arreglo, y los valores de los índices i y k.

6 También conocido como bubblesort



Figura 3: Proceso completo del ordenamiento del arreglo

Comparación de Strings7 Para comparar Strings (lexicográficamente) no se puede usar el operador de igualdad 8 ==. Para comparar dos strings se ocupa el método int compareTo(String str) de la clase String de la siguiente manera : Funcionamiento de la función compare Sean a y b objetos de tipo String. La instrucción: a.compareTo(b) 1) retorna un valor menor que cero si a es menor que b 2) retorna un valor mayor que cero si a es mayor que b 3) retorna 0 (cero) si b es igual que a En el siguiente ejemplo, se recorre el arreglo, comparando el String pasado como parámetro con cada a[i]. Inicializa una variable p en -1, asumiendo que el String no se va

7 Cadenas 8 El operador = = sólo se utiliza para la comparación de números



a encontrar. Si durante el ciclo se encuentra, se asigna a p la posición correspondiente (i) y se ejecuta la instrucción break9 para no seguir buscando.

Código 1.1.2.3. Función que busca un carácter en una cadena, retorna -1

si no la encuentra o la posición si la encuentra.

Contar los elementos del Arreglo El método char charAt(int indice) de la clase String, retorna el caracter ( de tipo char) i-ésimo de un string. String temp = "DEA" temp.charAt(0) --> 'D' temp.charAt(1) --> 'E' temp.charAt(2) --> 'A' temp.length( ) --> 3 (número de caracteres) Para recorrer la cadena carácter por carácter se usa: for(i = 0; i < temp.length( ) ; i++ ) Realizando la comparación (temp.charAt(i) == c) se va verificando si se cumple la condición. Si esto ocurre, el contador cont se incrementa en 1. Ahora, como hay que recorrer todo el arreglo en busca del carácter, se recorre el arreglo con un ciclo for(k = 0...), y dentro de este ciclo, se asigna a temp, el valor de a[k].

9 La sentencia break se utiliza para finalizar un ciclo.



Código 1.1.2.4. Función que cuenta las veces que un carácter se encuentra

en una cadena.

1.1.3 Aplicaciones Ejemplo 1 Ejemplo de una declaración de un arreglo unidimensional. En un arreglo llamado “arreglo” se almacena cantidad de días que tienen los doce meses del año.

Código 1.1.3.1.declaración e inicialización de un arreglo.

Cuando se ejecuta el programa, imprime el número de días de abril. Ya se menciono que los índices de arreglo en Java comienzan con cero, de manera que el número de días del mes de abril es month_days[3] = 30.

La declaración de una variable arreglo se puede combinar con la reserva de memoria para el propio arreglo, como se ve aquí.



int dias_mes[] = new int[12];

Esta es la forma de declarar arreglos en Java. Los arreglos también pueden inicializarse cuando se declaran. Un inicializador de arreglo es una lista de expresiones entre llaves y separadas por comas, que separan los valores de los elementos del arreglo. Automáticamente se creará un arreglo suficientemente grande para contener el número de elementos que se haya especificado en el inicializador del arreglo. No es necesario utilizar new. Ejemplo 2. Versión mejorada del programa anterior:

Código 1.1.3.2. Versión mejorada del programa anterior.

Al ejecutar este programa, se listara misma salida que la que se genero la versión anterior.

Java comprueba estrictamente que no se almacenan o se reverencien valores que están fuera del rango del arreglo de forma accidental10. El sistema de interpretación de Java, revisa el valor de cada índice dentro de dias_mes para asegurarse de que están comprendidos entre 0 y 11. Si se intenta acceder a los elementos que están fuera de rango del arreglo (números negativos o número mayores al rango del arreglo) se provocará un error en el momento de la ejecución.

Ejemplo 3. Aquí se tiene otro ejemplo que utiliza un arreglo unidimensional, y donde se calcula la media de un conjunto de números.

Código 1.1.3.3. Calcula e imprime la media de cinco valores.

10 Es una de las características por las que Java sobresale con respecto a otros lenguajes de programación.



Al ejecutarse el programa anterior arrojara el valor promedio de los cinco números contenidos en el arreglo números.

1.2 Arreglos Bidimensionales

1.2.1 Conceptos básicos Definición de Arreglos Bidimensionales

Se define como un conjunto de datos del mismo tipo organizados en dos o más columnas y uno o más renglones, es decir es una matriz o una tabla. Los arreglos con dos dimensiones se utilizan a menudo para representar tablas de valores, que constan de información ordenada en filas y columnas. Para identificar un elemento especifico de una tabla, se deben especificar los índices. Por convención, el primer índice indica la fila del elemento y el segundo, su columna. En Java los arreglos bidimensionales son arreglos de arreglos. Como era de esperarse, se parecen y actúan como los arreglos multidimensionales.

Cuando un arreglo tiene dos dimensiones, hay mas en lo que se tiene que pensar. Considérese esta declaración e inicialización: int[][] mints = new int[3][4]

Es natural asumir que mints contiene 12 enteros e imaginarlos organizados dentro de columnas y renglones, como se muestran en la tabla 1.2.1.

1 2 3 4 91 92 93 94

2001 2002 2003 2004 Tabla 1.2.1. Manera incorrecta de pensar acerca de arreglos

multidimensionales.

Realmente la tabla, esta desencaminada, mints es realmente un arreglo con tres elementos. Cada elemento es una referencia a un arreglo conteniendo 4 enteros, como se muestra en la figura 4.

Figura 4: Ilustración de los arreglos bidimensionales.



Los arreglos subordinados en una bidimensión no tienen que ser todos de la misma longitud. Es posible crear un arreglo como el que se muestra en la figura 5.

Figura 5: Ilustración de arreglos bidimensionales (2).

La figura 5 muestra un arreglo donde hay elementos de un arreglo de 3 enteros,

un arreglo de 4 enteros y un arreglo de 2 enteros. Tal arreglo puede ser creado con la declaracíon: int[][] mints = { {1, 2, 3}, {91,92,93,94}, {2001, 2002} }; int[] reemplazo = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; myInts[1] = reemplazo;

Declaración y Creación de Arreglos Bidimensionales

Un arreglo bidimensional llamado b con dos filas y dos columnas, podría declararse e inicializarse con inicializadores de arreglos anidados, como se muestra a continuación: int b[][] = { {1 , 2}, {3 , 4}}; Los valores inicializadores se agrupan por filas entre corchetes. Por lo tanto, 1 y 2 inicializan b[0][0] y b[0][1]; 3 y 4 inicializan b[1][0] y b[1][1]. El compilador determina el número de filas contando el número de inicializadores de arreglos anidados11 en el inicializador del arreglo. El compilador determina el número de columnas en una fila contando los valores inicializadores en el inicializador del arreglo para esa fila. En java los arreglos bidimensionales se mantienen como arreglos de arreglos unidimensionales. Por lo tanto el arreglo b en la declaración anterior en realidad esta compuesto de tres arreglos unidimensionales separados. El arreglo b en si es un arreglo unidimensional que contiene dos elementos. Cada elemento es una referencia a un arreglo unidimensional de variables int.

11 Representados por conjuntos de llaves dentro de las llaves externas.



Arreglos bidimensionales con filas de distintas longitudes La forma en que java representa los arreglos Bidimensionales los hace bastante flexibles. De hecho, las longitudes de las filas en el arreglo b no tienen que ser iguales. Por ejemplo: int b[][] = { { 1, 2 }, { 3, 4, 5 } }; En la línea anterior se crea el arreglo entero b con dos elementos (los cuales se determinan según el número de inicializadores anidados) que representan las filas del arreglo bidimensional. Cada elemento de b es una referencia a un arreglo unidimensional de variables int. El arreglo int de la fila 0 es una arreglo unidimensional con dos elementos (1 y 2), y el arreglo int de la fila 1 es un arreglo unidimensional con tres elementos (3, 4 y 5). Creación de arreglos bidimensionales mediante expresiones de creación de arreglos

Un arreglo bidimensional con el mismo número de columnas en cada fila puede crearse mediante una expresión de creación de arreglos. Por ejemplo, en las siguientes líneas se declararán el arreglo b y se asignarán una referencia a un arreglo de tres por cuatro: Int b[][]; B = new int [2] [ ]; //crea 2 filas b [ 0 ] = new int [ 5 ]; //crear 5 columnas para la fila 0 b [ 1] = new int [ 3 ]; // crear 3 columnas para la fila 1 Estas instrucciones crean un arreglo bidimensional con dos filas. La fila 0 tiene 5 columnas y la fila 1 tiene 3 columnas.

1.2.2 Operaciones Mostrar un vector Ejemplo Para mostrar un vector en pantalla, se hace mediante un ciclo que se ejecutará n veces, donde n es el numero de elementos que tiene el vector. El ejemplo que sigue, se declara un vector String de 10 elementos. El programa contiene dos ciclos, en el primero se inicializa el vector con los valores de cadena 0, cadena 1, cadena 2 y así sucesivamente hasta llegar a cadena 9. en el segundo ciclo se manda a pantalla los 10 valores que contiene el vector.



Código 1.2.2.1. Inicializa e imprime los elementos de un arreglo.

Mostrar una matríz Mostrar una matriz en la pantalla de texto es difícil, ya que Java no dispone de una función que sitúe el cursor de texto en una posición de la pantalla, como lo hace la función gotoxy disponible en los lenguajes C/C++. La única alternativa que queda es mostrar los elementos de una fila unos a continuación de los otros separados por un tabulador, después otra fila y así hasta mostrar todos los elementos de la matriz. En el siguiente ejemplo se muestra en pantalla una matriz de 2 x 3; primero se inicializa la matriz en la línea int [][]a ={{1,2,3},{10,20,30}};. Se separan los elementos de una fila mediante el carácter tabulador '\t', Cuando se acaba una fila se inserta un retorno de carro '\n' y se continua con la siguiente fila, y así sucesivamente.

Código 1.2.2.3. Inicializa e imprime los elementos de un arreglo

bidimensional de 3 x 3.



Se muestra en pantalla la matriz mediante la línea: System.out.print("\t" +a[i][j]); Copia de una matriz dada Para realizar una copia se ha de implementar la interface 12 Cloneable, y redefinir la función miembro clone de la clase base Object. El primer paso es la llamada a la función clone de la clase base Object.

Código 1.2.2.4 Función que realiza la copia de una matriz dada usando la

función “clone” de la clase matriz. Para obtener una copia a de una matriz d se escribe. Matriz a = (Matriz)d.clone(); La promoción (casting) es necesaria ya que clone devuelve una referencia a un objeto de la clase base Object. Traza de una matriz Se denomina traza de una matriz cuadrada a la suma de los elementos de su diagonal principal.

12 En el capitulo VI se explica de manera detallada el uso de una interface.



Código 1.2.2.5. Imprime los elementos de la diagonal de un arreglo

bidimensional de 2 x 2. Para obtener la traza de la matriz a de la sección anterior se escribe Traza=obj1.Traza(); Ejemplo Suma de dos matrices cuadradas Cuando se suman dos matrices de las mismas dimensiones

Se obtiene otra matriz c en la que sus elementos cij son la suma de los correspondientes elementos de las matrices a y b, es decir C[i][j]=a[i][j]+b[i][j] Para sumar dos matrices, se define una función miembro estática denominada suma. Dentro de la función, se crea una matriz temporal resultado, con la misma dimensión de las matrices que intervienen en la operación, y se guardan en sus elementos el resultado de la suma de las matrices a y b. Finalmente, la función suma devuelve la matriz resultado.



Código 1.2.2.6. Función que recibe de parámetros dos matrices

bidimensionales y hace la suma de sus elementos. La función que suma dos matrices se llama de la siguiente manera: double[][] a1={{1, 2, 3},{4,5,6},{7,8,9}}; Matriz a=new Matriz(a1); double[][] b1={{1, 0, -1},{2,1,3},{-1, 0, 2}}; Matriz b=new Matriz(b1); Matriz re=Matriz.suma(a, b); System.out.println("matriz "+re); Producto de dos matrices La regla para multiplicar dos matrices es bastante más complicada que para sumar dos matrices de las mismas dimensiones. En general, se pueden multiplicar dos matrices de dimensiones m x n y n x q, dando como resultado una matriz de dimensiones m x q.

Los elementos c[i][j] se obtienen multiplicando los elementos a[i][k] de la fila i por los elementos a[k][j] de la columna j, y sumando los resultados.

La codificación se realiza empleando un triple ciclo for, guardando en los elementos de la matriz local resultado la suma de los productos de la fórmula anterior.



Código 1.2.2.7. Función que recibe de parámetros dos matrices

bidimensionales y arroja el producto de sus elementos. Otras variantes de la operación producto son: El producto de un escalar (número real) por una matriz que da como resultado otra matriz cuyos elementos están todos multiplicados por dicho escalar. Se define también la operación conmutativa.

Código 1.2.2.8. Función que realiza el producto de dos matrices

utilizando el productor escalar. Al multiplicar una matriz cuadrada de dimensión n, por un vector columna de la misma dimensión se obtiene otro vector columna. Cada elemento del vector resultante se obtiene multiplicando los elementos de una fila de la matriz por los correspondientes elementos del vector columna y se suman los resultados. La codificación de esta función producto es la siguiente:



Al multiplicar un vector fila por una matriz cuadrada de la misma dimensión se obtiene otro vector fila. El código es semejante al de la función producto definida previamente.

Matriz Traspuesta Una matriz traspuesta de otra matriz es aquella que tiene los mismos elementos pero dispuestos en forma distinta. Las columnas de la matriz original se transforman en filas de la matriz traspuesta. La definición de la función estática traspuesta no reviste dificultad alguna.

Código 1.2.2.8. Función que realiza la matriz traspuesta de una matriz

dada.



Para hallar la matriz traspuesta de la matriz a se escribe double[][] a1={{1, 2, 3},{4,5,6},{7,8,9}}; Matriz a=new Matriz(a1); Matriz tras=Matriz.traspuesta(a); System.out.println("matriz traspuesta"+tras);

1.2.3 Aplicaciones Ejemplo 1 El siguiente programa se crea un arreglo bidimensional de 4 x 5 ,se enumera cada uno de los elementos del arreglo de izquierda a derecha y de arriba abajo, y se muestran estos valores:

Código 1.2.3.1. Inicialización e impresión de un arreglo bidimensional de

4 x 5. Este programa generará la siguiente salida: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19



Cuando se reserva memoria para un arreglo bidimensional13, se puede únicamente especificar la memoria para la primera dimensión, la del extremo izquierdo. El espacio para las dimensiones restantes puede reservarse de manera separada.

Ejemplo 2: El siguiente código reserva memoria para la primera dimensión de dosD cuando se declara. El espacio para la segunda dimensión se reserva manualmente. Int dosD[][] = new int[4][]; dosD[0] = new int[5]; dosD[1] = new int[5]; dosD[2] = new int[5]; dosD[3] = new int[5];

En este caso no resulta ventajoso reserva espacio para la segunda dimensión de forma individual, pero en otros casos, puede que sí lo sea. Por ejemplo, cuando se reserva memoria para dos dimensiones de forma separada, no es necesario reservar el mismo número de elementos para cada dimensión. Como se ha dicho, dado que los arreglos bidimensionales son arreglos de arreglos, la longitud de cada arreglo se puede establecer de forma independiente. Como ejemplo, véase el siguiente programa, que crea un arreglo bidimensional en que los tamaños de la segunda dimensión no son iguales14:

Código 1.2.3.2. Reserva memoria para la primera dimensión de dosD cuando se declara. El espacio para la segunda dimensión se reserva manualmente.

13 Siempre se reserva usando el operador new. 14 Arreglos irregulares.



Este programa genera la siguiente salida: 0 1 2 3 4 5 6 7 8 9 El arreglo creado con este programa tiene en el siguiente aspecto;

[0][0] [1[0] [1[1][2[0] [2[1] [2][2] [3[0] [3[1] [3][2] [3][3]

El uso de arreglos bidimensionales irregulares puede no ser apropiado para muchas aplicaciones porque funciona de manera contraria a lo que la gente espera encontrarse en un arreglo bidimensional. Con todo, este tipo de arreglos puede utilizare de forma efectiva en algunas situaciones. Por ejemplo, si se necesita un arreglo bidimensional muy grande de escasos elementos (es decir, en la que no se vayan a utilizarse todos los elementos), un arreglo irregular puede ser la solución ideal. Es posible inicializar arreglos bidimensionales, para hacerlo, simplemente hay que introducir entre llaves el inicializador de cada dimensión. El siguiente programa crea un arreglo en la que cada elemento contiene el producto de la fila y los índices de la columna. Obsérvese también que pueden usarse tanto expresiones como valores literales en los inicializadores del arreglo.

Código 1.2.3.3. Inicialización e impresión de un arreglo bidimensional

irregular Cuando se ejecute este programa se obtendrá la siguiente salida:



0.0 0.0 0.0 0.0 0.0 1.0 2.0 3.0 0.0 2.0 4.0 6.0 0.0 3.0 6.0 9.0

Como puede apreciarse, cada fila en el arreglo se inicializa según se ha especificado en las listas de inicialización.

1.3 Arreglos multidimensionales

1.3.1 Conceptos básicos Java proporciona la posibilidad de almacenar varias dimensiones, aunque raramente los datos del mundo real requieren más de dos o tres dimensiones. El medio mas fácil de dibujar un arreglo de tres dimensiones es dibujar un cubo, tal como se muestra en la figura 6.

Figura 6: Un arreglo de tres dimensiones (4 x 5 x 3).

Un arreglo tridimensional se puede considerar como un conjunto de arreglos bidimensionales combinados juntos, para formar, en profundidad, una tercera dimensión. El cubo se construye con filas15, columnas16 y planos17. Por consiguiente, un elemento dado se localiza especificando su plano, fila y columna. Una definición de un arreglo tridimensional equipos es: int equipos[] [] [] = new int [3] [15] [10]; un ejemplo típico de un arreglo de tres dimensiones es el modelo libro, en el que cada pagina del libro es un arreglo bidimensional construido por filas y columnas. Así por

15 Dimensión vertical. 16 Dimensión horizontal. 17 Dimensión en profundidad.



ejemplo, cada pagina tiene cuarenta y cinco líneas que forman las filas del arreglo y ochenta caracteres por línea, que forman las columnas del arreglo. Por consiguiente si el libro tiene quinientas paginas, existirán quinientos planos y el número de elementos será 500 x 80 x 45 = 1,800,000.

1.3.2 Aplicaciones El arreglo libro tiene tres dimensiones [PAGINA] [LINEAS] [COLUMNAS], que definen el tamaño del arreglo. El tipo de datos del arreglo es char, ya que los elementos, son caracteres. ¿Cómo se puede acceder a la información del libro? El método más fácil es mediante ciclos anidados. Dado que el libro se compone de un conjunto de páginas, el ciclo mas externo será el ciclo de pagina, y el ciclo de columna será el ciclo mas interno. Esto significa que el ciclo de filas se insertará entre los ciclos de páginas y columnas. El código siguiente permite procesar el arreglo:

Código 1.3.2.1 Ilustración de acceso al arreglo libro de tres dimensiones mediante ciclos for anidados.



Código 1.3.2.2 Determina si una matriz es simétrica. Si lo es, genera números aleatorios de 0 a 7. El programa itera hasta encontrar una raíz

simétrica.



1.4 Ejercicios resueltos 1.4.1 Declare un arreglo x de 10 elementos e inicialícelo con valores del 1 al 10 y Muestre el séptimo valor del arreglo.

1.4.2. Declare un arreglo de flotantes de 70 elementos y muestre la suma de todos los elementos.

1.4.3 Declare un arreglo entero de 8 elementos y ordénelo usando el método de la burbuja.



1.4.4. Declare un arreglo bidimensional de 11 x 11 y imprima las tablas de multiplicar del 0 al 10.



1.5 Ejercicios propuestos 1.5.1 Determinar e imprimir los valores menor y mayor contenidos en el arreglo w con 99 elementos de punto flotante. 1.5.2 Diseñe un programa que guarde los 10 números dígitos y luego los imprima en forma ascendente y descendente. Usando, para ello, un arreglo de una dimensión. 1.5.3 En un arreglo se ha almacenado el número total de toneladas de cereales cosechadas durante cada mes del año anterior. Se desea la siguiente información:

a) El promedio anual de toneladas cosechadas. b) ¿Cuántos meses tuvieron una cosecha superior al promedio anual? c) ¿Cuántos meses tuvieron una cosecha inferior al promedio anual?.

Escriba un programa que proporciones estos datos. 1.5.4 Crear un vector de n elementos. Visualizarlo luego de desplazar los elementos una posición de tal forma que el último elemento ocupe la primera posición, el primero la segunda y así sucesivamente. 1.5.5 Diseñe una matriz en Java, de 6*6 elementos, y luego muestre, la suma de sus filas, y columnas por separado. 1.5.6 Se desea saber la suma y la multiplicación de dos matrices A y B, cada una con m*n elementos. 1.5.7 Realice una búsqueda binaria en un arreglo unidimensional. Una búsqueda binaria, es de la siguinte forma: se lee el valor que se desea buscar, se compara la primera posición, si son iguales, fin de la búsqueda; de lo contrario, compararlo con la posición dos, y así sucesivamente, si se llega al final del arreglo y no se encontró el valor, se debe indicar con una leyenda. Pero si se encuentra, se debe especificar la posición, que ese valor ocupa en el arreglo. 1.5.8 Etiquete los elementos del arreglo bidimensional ventas de 3 X 5, para indicar el orden en el que se establecen en cero, mediante el siguiente fragmento de programa. for (int fila = 0; fila < ventas.length; fila++) for( int col = 0; col > ventas[fila].length; col++) ventas[fila][col]=0; 1.5.9 Escriba un programa para simular el tiro de dos dados. El programa debe utilizar Math.random una vez para tirar el primer dado, y de nuevo para tirar el segundo dado. Después debe calcularse la suma de los dos valores que variar del 2 al 7, siendo 7 la suma más frecuente. En la figura 7 se muestran las 36 posibles combinaciones de los dos dados. El programa debe tirar los dados 36,000 veces. Utilice una arreglo unidimensional para registrar el número de veces que aparezca cada una de las posibles sumas.



Figura 7: Las 36 posibles sumas de los dados. 1.5.10 El juego del ahorcado se juega con dos personas (o una persona y una computadora). Un jugador selecciona una palabra y el otro jugador trata de adivinar la palabra adivinando letras individuales. Diseñar un programa para jugar el ahorcado. Sugerencia: Almacenar una lista de palabras en un array y seleccionar palabras aleatoriamente.

Unidad II. Métodos y mensajes


UNIDAD II. MÉTODOS Y MENSAJES

Concepto, Declaración, Tipos y Ejemplos de Métodos, Formas de pasar Argumentos y Estructura de Código.



UNIDAD 2. MÉTODOS Y MENSAJES

2.1 Atributos Const y Static Nota: El Atributo const no se utiliza en este lenguaje (java) Atributo Static18

Si se declara un atributo static, todas las instancias de esa clase comparten ese atributo, si lo cambia en una de ellas, todas ven el cambio en su propio atributo. El atributo pertenece a la clase, no a los objetos creados a partir de ella. El atributo static es atributo único para todos los objetos de la clase, estos son llamados también atributos de clase.

El que un atributo sea común a todos los objetos de la clase se plasma en que sólo habrá una copia del atributo global a todos los objetos de la clase Ejemplos: static int a = 5, b = 4;

En el ejemplo anterior se declaran tres variables (a y b). Las variables a y b son estáticas para toda la clase.

2.2 Concepto de método

Los métodos son funciones que pueden ser llamadas dentro de la clase o por otras clases, por lo tanto los métodos son funciones definidas dentro de una clase. Salvo los métodos static o de clase, se aplican siempre a un objeto de la clase por medio del operador punto (.). Dicho objeto es su argumento implícito. Los métodos pueden además tener otros argumentos explícitos que van entre paréntesis. En general un método es:

• Un bloque de código que tiene un nombre • Recibe unos parámetros o argumentos (opcionalmente) • Contiene sentencias o instrucciones para realizar algo (opcionalmente) y devuelve

un valor de algún tipo conocido (opcionalmente).

18 Atributo Estático



2.3 Declaración de Métodos Una declaración de método proporciona mucha información sobre el método al

compilador, al sistema en tiempo de ejecución y a otras clases y objetos. Junto con el nombre del método, la declaración lleva información como el tipo de

retorno del método, el número y el tipo de los argumentos necesarios, y qué otras clases y objetos pueden llamar al método. Los únicos elementos necesarios para una declaración de método son:

• El nombre • El tipo de retorno del método

Por ejemplo, el código siguiente declara un método llamado estaVacio() en la clase Pila que devuelve un valor booleano19.

Código 2.3.1 Declaración de un método que devuelve un valor boleano. En el código siguiente se declara un método llamado suma que devuelve la suma de dos valores. El método recibe de parámetros dos valores enteros:

Código 2.3.2 Llamada a un método llamado suma que recibe dos valores como parámetros y retorna un entero con la suma de los dos valores.

19 Los valores boléanos (boolean) solo aceptan dos valores, falso o verdadero.



2.4 Llamadas a Métodos Para ejecutar o mandar llamar a un método sólo es necesario poner el nombre del

objeto seguido por un punto y el nombre del método seguido de ( ). Si el método recibe algún valor como parámetro, dicho valor se debe especificar (entre paréntesis) a la hora de llamar al método.

Los métodos pueden ser invocados o llamados de cualquier método de la clase, incluido él mismo. Además, si el método recibe parámetros, cuando se invoca, hay que pasar un valor a cada argumento, a través de una variable o un valor constante. En Java, la acción de pasar valores a parámetros de tipo primitivo (int, double, boolean, char..) se denomina paso de parámetros por valor. En éste caso, los argumentos que los reciben, no pueden ser modificados por la función. En caso que el parámetro sea de tipo Clase o arreglo, lo que se está haciendo es un paso de parámetros por referencia 20, y en este caso, los parámetros si pueden ser modificados por el método.

20 En el paso de parámetro por referencia se pasa el valor como parámetro y cualquier cambio al valor en el método afecta directamente a la variable.



Código 2.4.1 Llamada a un método que determina si un número es par o

impar. Los métodos se invocan con su nombre, y pasando la lista de argumentos entre paréntesis. El par de argumentos se usa como si fuera una variable del Tipo devuelto por el método. Por ejemplo: char x; x = mayor(2,3); Se llama a los métodos dentro de una instancia de una clase utilizando el operador punto (.). La forma general de una llamada: referencia_a_objeto . nombre_de_método ( lista_de_parámetros );

Aquí, referencia_a_objeto es cualquier variable que se refiere a un objeto, nombre_de_método es el nombre de un método de la clase con la que se declaró referencia_a_objeto y lista_de_parámetros es una lista de valores o expresiones separados por comas que coinciden en número y tipo con cualquiera de los métodos declarados como nombre_de_método en la clase. En caso de que el método no reciba parámetros, en “lista argumentos” no se escribe nada. En este caso, se podría llamar al método init sobre cualquier objeto Point. Point p = new Point(); p.init();

2.5 Tipos de Métodos

2.5.1 Métodos Estáticos o de Clase

Se cargan en memoria en tiempo de compilación y no a medida que se ejecutan las líneas de código del programa. Van precedidos del modificador static. Para invocar a un método estático no se necesita crear un objeto de la clase en la que se define.

Si se invoca desde la clase en la que se encuentra definido, basta con escribir su nombre. Si se le invoca desde una clase distinta, debe anteponerse a su nombre, el de la clase en que se encuentra seguido del operador punto (.) <NombreClase>.metodoEstatico()

Suelen emplearse para realizar operaciones comunes a todos los objetos de la clase. No afectan a los estados de los mismos21. Por ejemplo, si se necesita un método para contabilizar el número de objetos creados de una clase, tiene sentido que sea

21 A los valores de sus variables de instancia.



estático ya que su función (aumentar el valor de una variable entera) se realizaría independientemente del objeto empleado para invocarle.

No es conveniente usar muchos métodos estáticos, pues si bien se aumenta la rapidez de ejecución, se pierde flexibilidad, no se hace un uso efectivo de la memoria y no se trabaja según los principios de la Programación Orientada a Objetos.

A veces se desea crear un método que se utiliza fuera del contexto de cualquier instancia. Todo lo que se tiene que hacer es declarar estos métodos como static. Los métodos estáticos sólo pueden llamar a otros métodos static directamente, y no se pueden referir a this o super 22 de ninguna manera. Las variables también se pueden declarar como static, pero debe ser consciente que es equivalente a declararlas como variables globales, que son accesibles desde cualquier fragmento de código. Se puede declarar un bloque static que se ejecuta una sola vez si se necesitan realizar cálculos para inializar las variables static. Ejemplos de Métodos Estáticos Ejemplo 1:

Código 2.5.1.1 El ejemplo muestra una clase que tiene un método static,

algunas variables static y un bloque de inicialización static. Esta es la salida del programa. bloque static inicializado x = 42

22 Estos dos conceptos (this y super) se explican en los temas posteriores.



a = 3 b = 12 Ejemplo 2:

Código 2.5.1.2 La funcionalidad de un método varía en función de si es invocado por el objeto hucha 1 o por hucha 2, no tendría sentido

considerarlo estático.

Código 2.5.1.3 La funcionalidad del método es la misma, independientemente del objeto empleado para invocarlo. Sí tiene sentido

declararlo estático.



Ejemplo 3:

Código 2.5.1.4 Programa que calcula la raíz cuadrada de 100 y con un retardo de 3 segundos calcula el valor de 2 a la 8 potencia.

2.5.2 Métodos Normales

Los métodos son funciones definidas dentro de una clase. Salvo los métodos static o de clase, se aplican siempre a un objeto de la clase por medio del operador punto (.). Dicho objeto es su argumento implícito. Los métodos pueden además tener otros argumentos explícitos que van entre paréntesis, a continuación del nombre del método.

La primera línea de la definición de un método se llama declaración o header; el código comprendido entre las llaves {…} es el cuerpo o body del método. Considérese el siguiente método tomado de la clase Circulo 23:

Código 2.5.2.1 Demuestra encabezado y cuerpo de un método.

El header consta del cualificador de acceso (public, en este caso), del tipo del valor de retorno (Circulo en este ejemplo, void si no tiene), del nombre de la función y de una lista de argumentos explícitos entre paréntesis, separados por comas. Si no hay argumentos explícitos se dejan los paréntesis vacíos. 23 Es una subclase no abstracta de la clase abstracta ObjetoGrafico



Los métodos tienen visibilidad directa de las variables miembro del objeto que es su argumento implícito, es decir, pueden acceder a ellas sin cualificarlas con un nombre de objeto y el operador punto (.). De todas formas, también se puede acceder a ellas mediante la referencia this, de modo discrecional o si alguna variable local o argumento las oculta.

El valor de retorno puede ser un valor de un tipo primitivo o una referencia. En cualquier caso no puede haber más que un único valor de retorno (que puede ser un objeto o un array). Se puede devolver también una referencia a un objeto por medio de un nombre de interface. El objeto devuelto debe pertenecer a una clase que implemente esa interface.

Se puede devolver como valor de retorno un objeto de la misma clase que el método o de una sub-clase, pero nunca de una super-clase. Los métodos pueden definir variables locales. Su visibilidad llega desde la definición al final del bloque en el que han sido definidas. No hace falta inicializar las variables locales en el punto en que se definen, pero el compilador no permite utilizarlas sin haberles dado un valor. A diferencia de las variables miembro, las variables locales no se inicializan por defecto.

Si en el header del método se incluye la palabra native (Ej: public native void miMetodo();) no hay que incluir el código o implementación del método. Este código deberá estar en una librería dinámica (Dynamic Link Library o DLL 24). Es la forma de poder utilizar conjuntamente funciones realizadas en otros lenguajes desde código escrito en Java.

Un método también puede declararse como synchronized (Ej: public synchronized double miMetodoSynch(){...}). Estos métodos tienen la particularidad de que sobre un objeto no pueden ejecutarse simultáneamente dos métodos que estén sincronizados

2.6 Referencia this 25 Java incluye un valor de referencia especial llamado this, que se utiliza dentro de

cualquier método para referirse al objeto actual. El valor this se refiere al objeto sobre el que ha sido llamado el método actual. Se puede utilizar this siempre que se requiera una referencia a un objeto del tipo de una clase actual. Si hay dos objetos que utilicen el mismo código, seleccionados a través de otras instancias, cada uno tiene su propio valor único de this.

Normalmente, dentro del cuerpo de un método de un objeto se puede referir directamente a las variables miembros del objeto. Sin embargo, algunas veces no se querrá tener ambigüedad sobre el nombre de la variable miembro y uno de los argumentos del método que tengan el mismo nombre.

24 Estas librerías son archivos de funciones compiladas normalmente en lenguajes distintos de Java (C, C++, Fortran, etc.) 25 En español “este”.



Por ejemplo, el siguiente constructor de la clase HSBColor inicializa alguna variable miembro de un objeto de acuerdo a los argumentos pasados al constructor. Cada argumento del constructor tiene el mismo nombre que la variable del objeto cuyo valor contiene el argumento.

Código 2.6.1. Programa que ejemplifica el uso de referencia this.

Se debe utilizar this en este constructor para evitar la ambigüedad entre el argumento luminosidad y la variable miembro luminosidad (y así con el resto de los argumentos). Escribir luminosidad = luminosidad; no tendría sentido. Los nombres de argumentos tienen mayor precedencia y ocultan a los nombres de las variables miembro con el mismo nombre. Para referirse a la variable miembro se debe hacer explícitamente a través del objeto actual--this. También se puede utilizar this para llamar a uno de los métodos del objeto actual. Esto sólo es necesario si existe alguna ambigüedad con el nombre del método y se utiliza para intentar hacer el código más claro.

2.7 Forma de Pasar Argumentos

En el paso de parámetros a funciones hay dos aproximaciones clásicas: el paso por valor y paso por referencia.

En el paso por valor se realiza una copia de los valores que se pasan, trabajando dentro de la función con la copia. Es por ello que cualquier cambio que sufran dentro, no repercute fuera de la función.

En el paso por referencia no se realiza dicha copia, por lo que las modificaciones de dentro de las funciones afectan a los parámetros y esos cambios permanecen al final de la función.

En Java el paso por parámetro es por valor, aunque los efectos son de paso por referencia cuando los argumentos son objetos. ¿cómo sucede eso? Pues es muy fácil, si una función tiene como argumento un tipo primitivo (int, float, etc...), en Java se realiza una copia para la función y cualquier cambio a dicho argumento no afecta a la variable original. Este paso de parámetros en Java está orientado a utilizar el valor de la variable para otros cálculos.



En el caso de los objetos es distinto. En realidad lo que sucede es que en Java

siempre se tienen referencias a los objetos. Por eso al pasar a una función como argumento un objeto, se pasa la referencia al mismo, es decir, aunque se hace una copia para el paso por valor, como lo que se copia es una referencia, los cambios al objeto referenciado sí son visibles y afectan fuera de la función.

La única excepción es la clase String , cuyos objetos no son mutables. Cualquier modificación de un objeto String lleva aparejada la creación de una nueva instancia del objeto. Si se desea el mismo comportamiento para el paso de parámetros del resto de objetos, se tiene que recurrir al objeto StringBuffer 26.

Algunos métodos no necesitan parámetros, pero la mayoría sí. Los parámetros permiten generalizar un método. Es decir, un método con parámetros puede operar sobre una gran variedad de datos y/o utilizarse en un gran número de situaciones diferentes. Para ilustrar este punto se utilizará un ejemplo muy sencillo.

Código 2.7.1 Función que devuelve el cuadrado del número 10.

Efectivamente, este método devuelve el cuadrado de 10, pero su utilización es muy limitada. Con todo, si se modifica el método de manera que tome un parámetro, como se ve a continuación, se consigue que Cuadrado2() sea mucho más útil.

Código 2.7.2 función que devuelve el cuadrado de cualquier valor que se

llame con el. Es decir Cuadrado2() ahora es un método de propósito general que puede calcular el cuadrado de cualquier número entero, no sólo de 10. Verificar el ejemplo:

26 La clase StringBuffer dispone de muchos métodos para modificar el contenido de los objetos StringBuffer.



En la primera llamada a Cuadrado2(), el valor 5 se pasa al parámetro i. en la

segunda llamada, i recibe el valor 9. En la tercera, se pasa el valor de y, que en este ejemplo es 2. Como muestran estos ejemplos, Cuadrado2() es capaz de devolver el cuadrado de cualquier dato que se pase al método. Es importante tener una idea precisa de lo que significan los términos parámetro y argumento. Un parámetro es una variable, definida por un método, que recibe un valor cuando se llama al método. Por ejemplo, en Cuadrado2(), i es un parámetro. Un argumento es un valor que se pasa a un método cuando se le llama. Por ejemplo Cuadrado2(100) pasa por 100 como argumento. Dentro de Cuadrado2(), el parámetro i recibe ese valor. Ejemplos de Llamadas a Métodos y Paso de Argumentos

En el siguiente ejemplo, se llama a un método de la misma clase simplemente con el nombre del método y los parámetros entre paréntesis, como se ve en el ejemplo:



Código 2.7.3 programa que ejemplifica la llamada a métodos y el paso de argumentos.

2.8 Devolver un valor desde un método

Java necesita que un método declare el tipo de dato del valor que devuelve. Si un método no devuelve ningún valor, debe ser declarado para devolver void 27. Los métodos pueden devolver tipos de datos primitivos o tipos de datos de referencia. En el siguiente ejemplo, el método estaVacio() de la clase Pila devuelve un tipo de dato primitivo, un valor booleano.

27 Nulo



Código 2.8.1 función que devuelve un valor boleano (falso o verdadero). Sin embargo, el método pop de la clase PILA devuelve un tipo de dato de referencia: un objeto.

Código 2.8.2 función que devuelve un tipo se dato de referencia. Los métodos utilizan el operador return para devolver un valor. Todo método que no sea declarado como void debe contener una sentencia return.

El tipo de dato del valor devuelto por la sentencia return debe corresponder con el tipo de dato que el método tiene que devolver; no se puede devolver un objeto desde un método que fue declarado para devolver un entero.



Cuando se devuelva un objeto, el tipo de dato del objeto devuelto debe ser una subclase o la clase exacta indicada. Cuando se devuelva un tipo interface 28, el objeto retornado debe implementar el interface especificado.

Definición de métodos que no retornan datos Existen métodos que no devuelven datos. En este caso se estaría definiendo un procedimiento, la sintaxis es muy similar a la de muchos lenguajes de programación estructurados:

Ejemplo:

Código 2.8.3 Función que no devuelve valor y visualiza un numero complejo.

En el ejemplo anterior se ha definido una clase que representa a un número complejo, la cual tiene un método que visualiza los valores real e imaginario del número. Declaración de un Método que no Devuelve Valores

Donde la palabra reservada return indica que la ejecución del método ha concluido y establece el valor de retorno 29.

28 Concepto ampliamente explicado en la unidad 6, subtema 6.3. 29 En realidad los métodos que no retornan datos son un caso especial de los métodos que retornan datos pero se retorna un tipo de dato void el cual es un valor nulo.



2.9 Estructura del Código Generalmente la estructura de un método es la siguiente: <modificadores de acceso> <tipo de dato de retorno> <nombre del método>(tipo1 arg1,tipo2 arg2,...){ Cuerpo del método; } Explicación de cada uno de los componentes de un método: Nombre del método: el que desee el programador. Número y tipo de argumentos asociados al método (tipo1 arg1,tipo2 arg2,...): constituye su firma. Los argumentos pueden ser tanto variables primitivas como variables referenciadas. Las variables primitivas se emplean para almacenar números, caracteres o valores lógicos, mientras que las referenciadas están asociadas a objetos de clases. Tipo de dato de retorno o tipo de dato que devuelve el método: Dato asociado a una variable primitiva. Dato asociado a una variable referenciada. void. Es lo que debe ponerse cuando el método no devuelve nada y, por ejemplo, simplemente muestra por consola un mensaje. Es el caso del método "void mostrarMensaje()". Modificadores de acceso: public, private, protected y sin modificador. Sirven para fijar el grado de accesibilidad de un método. Además de los de acceso, se tienen otros como static, synchronized, final, abstract, etc. que afectan de un determinado modo al método.

2.10 Ejercicios Resueltos:

2.10.1 Implementar un programa que sume tres números utilizando un método estático.



2.10.2 Implementar un programa que determine los 100 primeros números palíndromos (son los números que se leen igual de izquierda derecha que de derecha a izquierda) a partir de un número ingresado por teclado en adelante, usando un método para invertir los números.



2.10.3. Se quiere determinar cuantos y cuales números perfectos y pares, existen entre a y b. Nota : Un numero perfecto es aquel que la suma de sus divisores sea igual al numero. Ej --> 6 : 1 + 2 + 3

2.1.0.4Se desea saber el valor de la siguiente sumatoria: s = SUMATORIA x^2 - y : desde a hasta b Siendo x : numero primo e y = numero múltiplo de 5 o 7



2.11 Ejercicios propuestos: 2.11.1 Escribir un método que tenga un argumento de tipo entero y que devuelva la letra P. si el número es positivo, y la letra N, si es cero o negativo. 2.11.2 Escribir un método lógico de dos argumentos enteros, que devuelva true si uno divide al otro y false en caso contrario. 2.11.3 Escribir un método que convierta una temperatura dada en grados Celsius a grados Fahrenheit. La formula de conversión es: F = 9/5 C + 32



2.11.4 Crear un programa que contenga un método y que muestre por consola el número de veces que aparece la letra "a" en una cadena, la cual será dada desde el teclado.

2.11.5 Escribir un método lógico que determine si un carácter es uno de los dígitos de 0 a 9.

2.11.6 escribir un método lógico que determine si un carácter es una vocal.

2.11.7 Escribir un método Redondeo que acepte un valor real cantidad y un valor entero decimales y devuelva el valor cantidad redondeado al número especificado de decimales. (Por ejemplo, Redondeo (20.5632.2) devuelve 20.56. 2.11.8 Escribir un método que acepte un número de día, mes y año y lo visualice en el formato. dd/mm/aa 2.11.9 Escribir un mètodo que lea un entero positivo y a continuación visualice sus factores primos. 2.11.10 Escribir un programa que permita al usuario elegir el cálculo del área de cualquier de las figuras geométricas: Círculo, cuadrado, rectángulo o triangulo, mediante métodos.

Unidad III. Constructor, Destructor (Recolector de basura)


UNIDAD III. CONSTRUCTOR, DESTRUCTOR (RECOLECTOR DE BASURA)

Concepto, Declaración, Tipos y Aplicaciones de Constructores y

Destructores (Recolectores de Basura)



UNIDAD III. CONSTRUCTOR, DESTRUCTOR (RECOLECTOR DE BASURA)

3.1 Concepto de método constructor Un Constructor es un método especial en Java empleado para inicializar valores en

Instancias de objetos, a través de este tipo de métodos es posible generar diversos tipos de instancias para la clase en cuestión; la principal característica de este tipo de métodos es que llevan el mismo nombre de la clase. Los constructores tienen el mismo nombre que la clase, no retornan ningún valor y no pueden ser heredados. Un método constructor inicializa las variables de instancia de una clase.

Cuando se crea el objeto de una clase, new llama al método constructor de la clase para llevar acabo la inicialización. Un método constructor debe tener el mismo nombre que el de su clase30. Una clase puede contener constructores sobrecargados, los cuales permiten a los objetos de esa clase inicializarse de distintas maneras. Cuando un programa crea la instancia de un objeto de cierta clase, el programa puede proporcionar inicializadores (argumentos) entre paréntesis, a la derecha del nombre de la clase. Estos inicializadores se pasan como argumentos al constructor de la clase.

Se requiere que toda clase tenga al menos un constructor. Por lo tanto, si no se declaran constructores para una clase, el compilador crea un constructor predeterminado que no toma argumentos. El constructor predeterminado para una clase llama al constructor sin argumentos para su superclase (la clase que extiende).

3.2 Recolector de basura (garbage collector)31 Muchos otros lenguajes orientados a objetos necesitan que se siga la pista de los

objetos que se han creado y luego se destruyan cuando no se necesiten. Escribir código para manejar la memoria de esta es forma es aburrido y propenso a errores.

En el lenguaje de programación Java no existen los destructores, en lugar de eso, el entorno de ejecución de Java tiene un recolector de basura que periódicamente libera la memoria ocupada por los objetos que no se van a necesitar más. Java permite crear tantos objetos como se quiera (sólo limitados por los que el sistema pueda manejar) pero nunca tienen que ser destruidos. El entorno de ejecución Java borra los objetos cuando determina que no se van a utilizar más. Este proceso es conocido como recolección de basura.

El recolector de basura de Java es un barredor de marcas que escanea dinámicamente la memoria de Java buscando objetos, marcando aquellos que han sido referenciados. Después de investigar todos los posibles paths de los objetos, los que no

30 Incluyendo las mismas letras mayúsculas y minúsculas. 31 Los destructores no existen en Java



están marcados (esto es, no han sido referenciados) se les conoce como basura y son eliminados.

Un objeto es ilegible para la recolección de basura cuando no existen más referencias a ese objeto. Las referencias que se mantienen en una variable desaparecen de forma natural cuando la variable sale de su ámbito. O cuando se borra explícitamente un objeto referencia mediante la selección de un valor cuyo tipo de dato es una referencia a null.

El colector de basura funciona en un thread (hilo) de baja prioridad y funciona tanto síncrona como asíncronamente dependiendo de la situación y del sistema en el que se esté ejecutando el entorno Java.

El recolector de basura se ejecuta síncronamente cuando el sistema funciona fuera de memoria o en respuesta a una petición de un programa Java. Un programa Java le puede pedir al recolector de basura que se ejecute en cualquier momento mediante una llamada a System.gc(). Aunque pedir que se ejecute el recolector de basura no garantiza que los objetos sean recolectados.

La recolección de basura en Java funciona identificando objetos que son alcanzables por la máquina virtual de Java, como se muestra en la siguiente figura 8. De forma periódica32, la máquina virtual invoca al recolector de basura (GC)33. En la ejecución del programa, algunos objetos referencian a otros, creando un grafo dirigido. El recolector de basura examina todos los objetos en memoria y ve si son alcanzables desde el objeto raíz, es decir, si hay un camino en el grafo desde ese objeto raíz a cada objeto. Con esta información, el recolector de basura marca los objetos como alcanzables o no y libera todos los objetos que no son alcanzables.

Figura 8: El recolector de basura de Java funciona determinando los objetos que son alcanzables.

32 Por ejemplo, cuando la cantidad usada de memoria sobrepasa un cierto límite. 33 Garbage Collector



3.3 Declaración de métodos constructores Los métodos constructores tienen las siguientes características especiales:

• Se llama igual que la clase. • No devuelve nada, ni siquiera void. • Pueden existir varios, pero siguiendo las reglas de la sobrecarga de funciones. • De entre los que existan, tan sólo uno se ejecutará al crear un objeto de la clase. • Dentro del código de un constructor generalmente suele existir inicializaciones de

variables y objetos, para conseguir que el objeto sea creado con dichos valores iniciales.

Sintaxis: Declaración de constructores: <modificadordeVisibilidad> <NombredelaClase> ( <argumentos> ) { < declaraciones> }

Donde el modificadorvisibilidad es el tipo de modificador de acceso del constructor. El nombre de la clase como su nombre lo indica será el nombre del constructor. Se debe recordar que el constructor y la clase deben tener el mismo nombre. Los parámetros son las variables que reciben como parámetros el método constructor. Cabe mencionar que el constructor al ser método inicializador de variables, no devuelve ningún valor de retorno.

Cuando se declaren constructores para las clases, se pueden utilizar los especificadores de acceso normales para especificar si otros objetos pueden crear ejemplares de su clase.

private

Niguna otra clase puede crear un objeto de su clase.

La clase puede contener métodos públicos y esos métodos pueden construir un objeto y devolverlo, pero nada más.

protected Sólo las subclases de la clase pueden crear ejemplares de ella.

public Cualquiera puede crear un ejemplar de la clase.

package-access Nadie externo al paquete puede construir un ejemplar de su clase. Visibilidad por omisión.

Esto es muy útil si se quiere que las clases que se tengan en un paquete puedan crear ejemplares de la clase pero no se quiere que lo haga nadie más.



Ejemplo:

Código 3.3.1 Declaración de dos constructores. El primero no recibe argumentos y el segundo constructor recibe un valor entero de argumento.

En este ejemplo se tiene la clase “clase1”, la cual tiene dos constructores, uno no recibe ningún parámetro e inicializa la variable “y” en 1. El otro constructor recibe de aegumento la variable “par” que se utiliza para inicializar la variable “y”.

Ejemplo 2

Código 3.3.2 Declaración de dos constructores. El primero inicializa x e

y en 0 y el segundo inicializa los valores x e y con los argumentos pasados a la función A.

En el ejemplo anterior se tiene a la clase “A”, que tiene dos constructores, el primero inicializa las variables x e y en cero. Y el segundo constructor inicializa x e y con los valores pasados por los parámetros a y b.

3.4 Aplicaciones de constructores y destructores (Recolectores de basura)

Ejemplo 1

Se puede tener cualquier número de constructores, todos los cuales tienen el mismo nombre. Al igual que otros métodos sobrecargados, los constructores se diferencian unos de otros en el número y tipo de sus argumentos.



Se considerará la clase Rectangle del paquete java.awt 34 que proporciona varios constructores diferentes, todos llamados Rectangle(), pero cada uno con número o tipo diferentes de argumentos a partir de los cuales se puede crear un nuevo objeto Rectangle. Aquí están las firmas de los constructores de la clase java.awt.Rectangle.

public Rectangle() public Rectangle(int width, int height) public Rectangle(int x, int y, int width, int height) public Rectangle(Dimension size) public Rectangle(Point location) public Rectangle(Point location, Dimension size)

El primer constructor de Rectangle inicializa un nuevo Rectangle con algunos valores por defecto razonables, el segundo constructor inicializa el nuevo Rectangle con la altura y anchura especificadas, el tercer constructor inicializa el nuevo Rectangle en la posición especificada y con la altura y anchura especificadas, etc.

Típicamente, un constructor utiliza sus argumentos para inicializar el estado del nuevo objeto. Entonces, cuando se crea un objeto, se debe elegir el constructor cuyos argumentos reflejen mejor cómo se quiere inicializar el objeto.

Basándose en el número y tipos de los parámetros que se pasan al constructor, el compilador determina cual de ellos utilizar, Así el compilador sabe que cuando se escribe:

new Rectangle(0, 0, 100, 200);

El compilador utilizará el constructor que requiere cuatro argumentos enteros, y cuando se escribe:

new Rectangle(miObjetoPoint, miObjetoDimension);

Utilizará el constructor que requiere como argumentos un objeto Point y un objeto Dimension.

Ejemplo 2.

El constructor para esta subclase de Thread, un hilo que realiza animación, selecciona algunos valores por defecto como la velocidad de cuadro, el número de imágenes y carga las propias imágenes.

34 AWT es el acrónimo del X Window Toolkit para Java.



Código 3.3.1 declaración de constructores.

Obsérvese cómo el cuerpo de un constructor es igual que el cuerpo de cualquier otro método -- contiene declaraciones de variables locales, ciclos, y otras sentencias. Sin embargo, hay una línea en el constructor de Animacion que no se verá en un método normal--la segunda línea.

super("Animacion");

Esta línea invoca al constructor proporcionado por la superclase de Animacion--Thread. Este constructor particular de Thread acepta una cadena que contiene el nombre del Thread. Frecuentemente un constructor se aprovechará del código de inicialización escrito para la superclase de la clase.

En realidad, algunas clases deben llamar al constructor de su superclase para que el objeto trabaje de forma apropiada. Típicamente, llamar al constructor de la superclase es lo primero que se hace en el constructor de la subclase: un objeto debe realizar primero la inicialización de nivel superior.

Ejemplo 3.

A continuación se tiene a una clase árboles, la cual contiene cuatro constructores que inicializan los valores de manera diferente.

El primer constructor solo imprime la cadena “un árbol genérico”

El segundo constructor recibe de parámetro el tipo de árbol y lo imprime



El tercer constructor recibe de parámetro la altura del árbol y la imprime

El cuarto constructor recibe los dos parámetros, el tipo de árbol y la altura del árbol

Código 3.3.2 Declaración de diferentes constructores que inicializan valores de forma diferente.

3.5 Tipos de Métodos Constructores y Destructores (Recolectores de Basura)

Constructores Implícitos

Cuando se escriben clases, no es obligatorio declarar constructores porque Java proporcionar constructores. El constructor por defecto, el constructor que no necesita argumentos, lo proporciona automáticamente el sistema para todas las clases. A este tipo de constructores se les llama constructores implícitos, porque se crea internamente en el lenguaje Java.

Si no se declaran constructores automáticamente Java invoca al constructor implícito de la clase, al que ya tiene por defecto.

Ejemplo: //constructor implícito

Aquí se tiene a una Clase de Diseño llamada Bicicleta:



Esta es la implementación de la Clase Bicicleta

Código 3.4.1 Ilustración de constructores implícitos.

Y ahora se crea una instancia de la clase Bicicleta desde cualquier otro Objeto

Bicicleta b1 = new Bicicleta();

Se puede observar que la Clase Bicicleta no tiene ningún Constructor. En estos casos se dice que la Clase tiene un Constructor implícito y que el entorno de ejecución Java sólo utilizará el Constructor por defecto.

Constructores Explícitos

Los constructores explícitos son aquellos constructores que el programador declara. Cabe mencionar que los constructores también se pueden sobrecargas como los métodos normales.

Métodos de Constructores Sobrecargados Los métodos de constructores de una clase pueden sobrecargarse. Los métodos constructores sobrecargados permiten a los objetos de una clase inicializarse de distintas



formas. Para sobrecargar métodos constructores simplemente hay que proporcionar varias declaraciones del método constructor con distintas listas de parámetros. Estos Constructores sobrecargados

• Permiten crear Objetos pasándoles diferentes valores • Estarán incluidos tanto en el código de la Clase como en las Clases de diseño de un

Diagrama de Clases de diseño UML 35.

Ejemplo 1: //constructor sobrecargado

Aquí se tiene una Clase de Diseño llamada Bicicleta con un Constructor sobrecargado.

Esta es la implementación de la Clase Bicicleta

Código 3.4.2 Clase Bicicleta con sobrecarga de constructores.

35 Lenguaje Unificado de Modelado



Este constructor sin argumentos tiene que estar escrito dentro de la Clase aunque no tenga contenido. Si no se hace así el compilador se quejará cuando desde otro Objeto se quiera crear una instancia de tipo Bicicleta con un Constructor sin argumentos

Y ahora se crean dos instancias de la clase Bicicleta desde cualquier otro Objeto teniendo en cuenta que en estos momentos la Clase Bicicleta tiene declarado e inicializado de forma explícita un Constructor sobrecargado.

Bicicleta b1 = new Bicicleta(); Bicicleta b2 = new Bicicleta("Cannondale");

Bicicleta b1 = new Bicicleta();

En este caso el entorno de ejecución Java utiliza:

El Constructor por defecto que realiza lo siguiente

- Inicializa la variable de instancia matricula a su valor por defecto que en este caso por ser una Clase lo inicializa a valor null. - Y obtiene una referencia al nuevo Objeto que se guarda en la variable de referencia b1

Bicicleta b2 = new Bicicleta("Cannondale");

En este caso el entorno de ejecución Java utiliza

Primeramente el Constructor por defecto que realiza lo siguiente:

- Inicializa la variable de instancia matricula a su valor por defecto que en este caso por ser una Clase lo inicializa a valor null

- Y seguidamente el Constructor sobrecargado con un argumento de tipo String que realiza lo siguiente: Inicializa la variable de instancia marca en este caso con el valor "Cannondale" y obtiene una referencia al nuevo objeto que se guarda en la variable de referencia b2

Ejemplo2.

En este ejemplo se declaran dos constructores de la clase point, el primero recibe dos parámetros y establece las coordenadas x e y con dichos parámetros. Y el segundo constructor establece en -1 los valores de x e y.



Código 3.4.3 Constructores sobrecargados de la clase Punto. Uno que recibe de parámetros dos valores enteros y el otro no recibe ningún

parámetro.

Primero se crea un objeto Point que llama al segundo constructor. En pantalla apareceran los valores de x = -1 e y = -1.

Después se crea un segundo objeto que manda llamar al primer constructor. En pantalla aparecerá los valores de x = 4 e y = 16.

Nota: Se recomienda siempre declarar un Constructor sin argumentos independientemente de si la clase tiene otro Constructor con argumentos por dos motivos

- Primero, la mayoría de los asistentes de los entornos de desarrollo Java al crear la plantilla de las Clases realizan las declaraciones de los Constructores sin argumentos, simplemente se ahorra tener que borrar el código correspondiente a la declaración del Constructor sin argumentos.

- Segundo, el programador se asegura de posibles errores de compilación si en un futuro desde otro Objeto decido además de crear una instancia de una Clase con su Constructor sobrecargado, también crear una instancia de esa misma Clase con un Constructor sin argumentos



Tipos de Recolectores de Basura (Garbage Collectors)

Java utiliza un modelo de memoria conocido como "administración automática del almacenamiento"36 en el que el sistema en tiempo de ejecución de Java mantiene un seguimiento de los objetos. En el momento que no están siendo referenciados por alguien, automáticamente se libera la memoria asociada con ellos. Existen muchas maneras de implementar recolectores de basura, entre ellas se tienen:

• Contabilizar referencias. La máquina virtual Java asocia un contador a cada instancia de un objeto, donde se refleja el número de referencias hacia él. Cuando este contador es 0, la memoria asociada al objeto es susceptible de ser liberada. Aún cuando este algoritmo es muy sencillo y de bajo costo (en términos computacionales), presenta problemas con estructuras de datos circulares.

• Marcar e intercambiar37. Este es el esquema más común para implementar el manejo de almacenamiento automático. Consiste en almacenar los objetos en un montículo (heap) de un tamaño considerable y marcar periódicamente (generalmente mediante un bit en un campo que se utiliza para este fin) los objetos que no tengan ninguna referencia hacia ellos. Adicionalmente existe un montón alterno, donde los objetos que no han sido marcados, son movidos periódicamente. Una vez en el montículo alterno, el recolector de basura se encarga de actualizar las referencias de los objetos a sus nuevas localidades. De esta manera se genera un nuevo montículo, que contiene únicamente objetos que están siendo utilizados.

36 Automatic Storage Managment. 37 Mark-and-sweep.



3.6 Ejercicios propuestos 3.5.1 Realice un programa para realizar sumas de uno, dos, tres, cuatro o cinco dígitos implementando constructores para inicializar los valores según sea el caso. 3.5.2 Realice un programa que calcule el área de cualquier triangulo, usando constructores para asignar valores a las formulas. 3.5.3 Implemente un programa que calcule la serie de fibonacci entre dos rangos dados previamente desde el teclado (variables ri y rf). Use un constructor para asignar valores a ri y rf. 3.5.3 Escribir un programa que convierta un número romano (en forma de cadena de

caracteres) en número arabigo, utilizando al menos un constructor explicito. 3.5.4 Escribir un programa que usando métodos y un constructor encuentre el valor

mayor, el valor menor, y la suma de n números de entrada. 3.5.5 Escribir un método que calcule cuantos puntos de coordenadas enteras existen

dentro de un triangulo del que se conocen las coordenadas de sus tres vértices. Use constructores.

3.5.6 Escriba un programa que utilice un método llamado CículoArea, que pida al usuario

la radio de un círculo e imprima el área de ese círculo. Declare al menos un constructor explicito.

3.5.7 El máximo común divisor de dos enteros es el entero más grande que puede dividir

a cada uno de dos números. Escriba un método que devuelva el máximo común divisor de dos números enteros. Use constructores.

3.5.8 Las computadoras están tomando un papel cada vez más importante en la

educación. Escriba un programa que ayude a un estudiante de escuela primaria, para que aprenda a multiplicar. Use el método Math.random para producir dos números enteros positivos de un dígito. El programa debe entonces mostrar una pregunta en la barra de estado, como:

¿Cuánto es 6 x 7 ? El estudiante debe escribir la respuesta, si es correcta el programa manda un mensaje de “Muy bien” y si es incorrecta “Vuélvalo a intentar”. Use constructores. 3.5.10. Escribir un programa recursivo que calcule los N primero números naturales. Use constructores.

Unidad IV. Sobrecarga


UNIDAD IV. SOBRECARGA

Conversión de Tipos y Sobrecarga de Métodos



UNIDAD IV. SOBRECARGA

4.1 Conversión de Tipos En Java es posible transformar el tipo de una variable u objeto en otro diferente al

original con el que fue declarado. Este proceso se denomina "conversión", "moldeado" o "tipado". Si se tiene alguna experiencia previa en programación, se sabe que es bastante común asignar un valor de un tipo a una variable de otro tipo.

Si los dos tipos son compatibles, Java realizará una conversión automática. Por ejemplo, siempre es posible asignar un valor int a una variable long. Pero no todos los tipos son compatibles, y en consecuencia, no todas las conversiones son implícitamente posibles. Por ejemplo, no esta definida la conversión de double a byte, aunque, afortunadamente, se puede obtener una conversión entre tipos incompatibles. Para ello, se debe emplear un cast, que realiza una conversión explicita entre tipos incompatibles.

Las normas de conversión entre tipos numéricos son las habituales en un lenguaje de Programación: si en una operación se involucran varios datos numéricos de distintos tipos todos ellos se convierten al tipo de dato que permite una mayor precisión y rango de representación numérica; así, por ejemplo:

• Si cualquier operando es double todos se convertirán en double. • Si cualquier operando es float y no hay ningún double todos se convertirán a float • Si cualquier operando es long y no hay datos reales todos se convertirán en long

Del mismo modo estas normas se extenderán para int, short y byte.

En la conversión de tipos se establece la norma de que "en las conversiones el tipo destino siempre debe ser igual o mayor que el tipo fuente":

Tipo Origen Tipo Destino Byte double, float, long, int, char, shortShort double, float, long, int Char double, float, long, int Int double, float, long Long double, float Float double

Tabla 4.1 Conversiones sin pérdidas de información

Conversiones Automáticas de Java Cuando a un tipo de variable se le asigna un tipo de datos, se realiza una conversión automática de tipo siempre y cuando se cumplan estas dos condiciones:

• Los dos tipos son compatibles. • El tipo de destino es más amplio que el tipo fuente.



Si se cumplen estas dos condiciones, tiene lugar una conversión de ensanchamiento. Por ejemplo, el tipo int siempre es suficientemente grande para guardar todos los valores byte válidos, de manera que no se necesita una sentencia de conversión. Para las conversiones de ensanchamiento, los tipos numéricos, incluyendo los enteros y de coma flotante, son compatibles entre sí. Sin embargo, los tipos numéricos no son compatibles con los char o los boolean; tampoco los char o los boolean son compatibles entre sí. Ejemplo: 1 Por ejemplo se puede asignar un valor de tipo byte a una variable int, Ya que byte e int son compatibles y las variables int tienen un rango mayor que los valores byte. Por lo tanto, no se perderá ningún dato en la conversión de tipos.

Código 4.1.1 Conversiones de tipo byte a tipo int

El compilador de Java no tiene ningún problema con este código y hace la conversión de tipos automáticamente. Este es el resultado del programa

C:\>java app int1 = 1

Este tipo de conversiones, en las que se convierte a un tipo de dato que tiene mayor rango, se llama extensión de conversiones. En ellas, los tipos numéricos, como entero o coma flotante, son compatibles entre sí. Por otro lado, los tipos char y boolean no son compatibles entre sí y tampoco con los tipos numéricos.

Conversión de Tipos Incompatibles Aunque la conversión automática de tipos es útil, o llega a satisfacer todas las necesidades. Por ejemplo, ¿Qué ocurre si se intenta asignar un valor int a una variable byte? Esta conversión no se realizará automáticamente porque un byte es menor que un



int 38. Este tipo de conversiones recibe a menudo el nombre de conversión de estrechamiento, porque se trata de estrechar el valor para que ajuste al tipo destino. Para crear una conversión entre dos tipos incompatibles, ha de utilizarse una cast. Un cast es simplemente una conversión explicita de tipos. Tiene esta forma general: (tipo-de-destino) valor Aquí, tipo-de-destino, especifica el tipo al que se desea convertir el valor determinado. Por ejemplo, el siguiente fragmento convierte un int en un byte. Si el valor del entero es mayor que el rango de un byte, se reducirá al módulo del rango del tipo byte.

Código 4.1.2 Conversión de tipos, de tipo int a tipo byte.

Este es el resultado de ejemplo anterior.

C:\>java app byte1 = 1

Si no se hace explícitamente el cast, el compilador devolverá un error, pero con el cast de tipos, no hay problema, ya que Java decide que se conoce la posibilidad de perder algunos datos cuando se introduce un valor probablemente mayor en un tipo más pequeño. Por ejemplo cuando se pone un número en coma flotante en un long, la parte fraccional del número se truncará, y puede que se pierdan más datos si el valor en coma flotante esta fuera del rango que un long puede gestionar. Hay que tener en cuenta es que el compilador de Java convierte a un tipo de mayor precisión, si es necesario, al evaluar expresiones. Por ejemplo, se va a considerar el siguiente código, en el que parece que sólo hay bytes involucrados:

38 Conversión de estrechamiento.



Código 4.1.3 Conversiones de tipos con perdida precisión. Este código se compila y se ejecuta como se esperaba, pero no sería así sin el cast (byte):

C:\>java app Byte3 = 100

Una conversión diferente tendrá lugar cuando se asigne un valor de coma flotante a un tipo entero, en este caso, se trunca la parte decimal. Como ya se sabe, los enteros no tienen componentes decimales, por lo que cuando a un entero se le asigna un valor en coma flotante, el componente decimal se pierde. Por ejemplo si a un entero se le asigna el valor 1,23, el valor resultante será simplemente 1. el 0,23 será truncado. El siguiente programa es un ejemplo de algunas conversiones de tipo explicitas:

Código 4.1.4 Diferentes tipos de cast.



La salida que produce este programa es: Conversión de int a byte. i y b 257 1 Conversión de double a int. d y i 323.142 323 Conversion de double a byte. d y b 323.142 67 Obsérvese cada una de estas conversiones. Cuando el valor 272 se convierte en una variable byte, el resultado es el resto de la división de 257 entre 256 (el rango de un byte), que es 1 en este caso. Cuando la d se convierte en int, su componente decimal también se pierde, y ese valor se reduce al módulo 256, que en este caso es 67. Promoción Automática de Tipo en Expresiones39 Las conversiones de tipos pueden realizarse, además de en las asignaciones, en las expresiones. Para ver cómo sucede esto, se tiene en cuenta lo siguiente. En una expresión, la precisión necesaria de un valor intermedio a menudo supera el rango de cualquiera de los operándos. Por ejemplo, la siguiente expresión: Byte a = 40; Bye b = 50; Byte c = 100; Int d = a * b / c; El resultado del término intermedio a * b puede superar fácilmente el rango de cualquiera de sus operandos byte. Para tratar este tipo de problemas, Java promueve de una manera automática cada operando byte o short a int. Cuando evalúa una expresión. Esto significa que la subexpresíon a * b se calcula utilizando tipos enteros, no bytes. Por lo tanto, 2,000, que es el resultado de la expresión intermedia 50 * 40, es valido aunque se hayan especificado a y b como tipo byte A pesar de lo útiles que resultan las promociones automáticas, pueden causar errores de confusión en la compilación. Por ejemplo, este código, aparentemente correcto, puede causar un problema: Byte b = 50; b = b * 2; // ¡Error! ! No se puede asignar un int a un byte! Este código intenta almacenar 50 * 2, un valor de tipo byte perfectamente válido, en una variable byte. Sin embargo, cuando se evaluó la expresión, los operandos se promocionaron automáticamente al tipo int. Por lo tn anto, el tipo de la expresión ahora es de tipo int, y no se puede asignar al tipo byte sin utilizar la conversión explícita. Esto se

39 Conversiones Implícitas



verifica incluso en este caso particular, en el que el valor que se intenta asignar se ajusta al tipo de destino. En casos en los que se prevén las consecuencias del desbordamiento, se debería utilizar la conversión explicita. byte b = 50; b = (byte) (b * 2); Que conduce al valor correcto de 100.

4.2 Sobrecarga de Métodos La sobrecarga de métodos es una técnica de la orientación a objetos que permite definir diferentes versiones de un método, todos con el mismo nombre pero con diferente lista de parámetros. Cuando se usa un método sobrecargado, el compilador de Java sabe cual es el que se quiere utilizar por el numero y/o tipo de parámetros que se le pasen, y buscará la versión del método con la lista de argumentos correcta. En java dentro de una misma clase podemos definir dos o más métodos que compartan el mismo nombre, aunque la declaración de sus parámetros sea diferente. Cuando éste es el caso, se dice que los métodos están sobrecargados, y que el proceso es una sobrecarga del método. La sobrecarga de métodos es una de las maneras en que Java implementa el polimorfismo40. El polimorfismo es una de las características más interesantes de Java. Cuando se llama a un método sobrecargado, Java utiliza el tipo y/o número de argumentos como guía para determinar a qué versión del método sobrecargado se debe llamar. Por lo tanto, los métodos sobrecargados han de ser diferentes en el tipo y/o número de parámetros. Mientras que los métodos sobrecargados pueden tener diferentes tipos, el tipo devuelto es por sí solo lo suficiente para distinguir dos versiones de un método. Cuando Java encuentra una llamada a un método de sobrecarga, simplemente se ejecuta la versión del método cuyos parámetros coinciden con los argumentos utilizados en la llamada. Ejemplo 1 Véase el siguiente ejemplo. Para sobrecargar un método, sólo hay que definirlo más de una vez, especificando una nueva lista de parámetros en cada una de ellas. Cada lista de parámetros deber ser diferente de cualquier otra de alguna forma, el número de parámetros o el tipo de uno o más de ellos. Por ejemplo se creara una clase llamada calculador con un método llamado “suma” que se sobrecarga dos veces. En la primera declaración recibe dos números de parámetros y en la segunda declaración recibe tres parámetros.

40 Se explicara detalladamente en los capítulos posteriores.



Código 4.2.1 Sobrecarga de métodos.

Ahora se pueden usar ambos métodos en el código, como sigue:

Código 4.2.1 Sobrecarga de métodos. Uso de los métodos sobrecargados en el código anterior.

Este es el resultado del programa: C:\>java app suma(2,2) = 4 suma(2,2,2) = 6 Como se puede ver, la sobrecarga proporciona una técnica potente, especialmente en el código que se entrega a otros desarrolladores, porque permite pasar diferentes listas de parámetros a un método, haciéndolo más fácil de usar de diferentes formas en el código. Ejemplo 2 Aquí se tiene otro ejemplo sencillo que ilustra la sobrecarga de métodos:



Código 4.2.1 Sobrecarga de métodos. Sobrecarga del método prueba. Este programa genera la siguiente salida: No tiene parámetros a: 10 a y b: 10 20 a double: 123,25 Resultado de ob.prueba(2.67,12.68): = 15.35 Como se puede observar, el método prueba() se sobrecarga en cuatro ocasiones. La primera versión no tiene parámetros, la segunda tiene un parámetro entero, la tercera tiene dos parámetros enteros y la cuarta, dos parámetro double que suma y retorna el valor de dicha suma. El hecho de que la cuarta versión de prueba() tambien devuelva un valor no esta relacionado con la sobrecarga, ya que los tipos devueltos no desempeñan ningún papel en la resolución de la sobrecarga. Cuando se llama a un método sobrecargado, java busca las coincidencias entre los argumentos utilizados para llamar al método y los parámetros del método, sin embargo, esta coincidencia no siempre tiene que ser exacta. En algunos casos, las conversiones automáticas de tipos de Java pueden tener su importancia en la resolución de sobrecarga.



Por ejemplo, véase el siguiente programa:

Código 4.2.3 Aplicación de la conversión automática de tipos en la sobrecarga de métodos.

Este programa genera la siguiente salida: No tiene parametros a y b: 10 20 prueba(double) a: 80 prueba(double) a: 123.2 Esta versión de SobrecargaDemo no se define define(int). Además, cuando se llama a prueba() con un argumento entero dentro de sobrecarga, no se encuentra ninguna coincidencia con los parámetros del método. Sin embargo, Java puede convertir automáticamente un entero en double, y esta conversión puede utilizarse para resolver la llamada. Por este motivo, cuando no se encuentra el método prueba(int), Java eleva i a double y entonces llama a prueba(double). Por supuesto, si prueba (int) se hubiera definido, este método hubiera sido llamado en lugar de prueba (double). Java empleará este tipo de conversiones automáticas únicamente en caso de que no se encuentren coincidencias exactas.



Cuando se sobrecarga un método, cada versión de ese método puede realizar la actividad que desee. No existe ninguna regla que establezca que los métodos de sobrecarga han de relacionarse entre si, pero desde el punto de vista de estilo, la sobrecarga de métodos implica la relación. Por consiguiente, aunque puede utilizarse el mismo nombre para sobrecargar métodos que no están relacionados es mejor no hacerlo. Por ejemplo, podría utilizarse el nombre sqr para crear métodos que devuelvan el cuadrado de un entero y la raíz cuadrada de un valor en coma flotante, pero estas dos operaciones son muy distintas y esto va en contra de un propósito original de la sobrecarga de métodos. En la práctica, sólo se han de sobrecargar operaciones estrechamente relacionadas. Sobrescritura de Métodos En una jerarquía de clases, cuando un método de una subclase tiene el mismo nombre y tipo que un método de superclase, se dice que el método de la subclase sobrescribe al método de la superclase. Cuando se llama a un método sobrescrito desde una subclase, esta llamada siempre se refiere a la versión de ese método definida por la subclase. La versión del método definido por la superclases quedaría oculta. Véase el siguiente ejemplo:

Código 4.2.4 Sobrescritura de métodos. Sobrecritura del método mostrar de

la subclase B sobre la superclase A.



La salida que produce el programa es: K = 3 Cuando se llama a mostrar() en un objeto del tipo B, se utiliza la versión de mostrar() definida en B; es decir, la versión mostrar() dentro de B domina sobre la versión declarada en A. si se quiere acceder a la versión de la superclase de una función sobrescrita, se utilizará el método super. Por ejemplo, en esta versión de la subclase. Esto permite imprimir todas las variables de instancia:

Código 4.2.5 En este caso no se da sobrescritura del método “mostrar” debido a que al llamarse se hace referencia al método de la superclase A

con la cláusula super. La salida del código anterior es la siguiente: i and j: 1 2 k : 3 Aquí super.mostrar() llama a la versión de show de la superclase(). La sobrescritura de métodos tan sólo se da cuando los nombres y el tipo de dos métodos son idénticos, si no lo son, entonces los métodos simplemente están sobrecargados. Por ejemplo, véase esta versión modificada del ejemplo anterior.



Código 4.2.6 Los métodos con diferentes tipo de parámetros se sobrecargan, no se sobrescriben.

La salida generada por este programa es la siguiente: Este es k: 3 i y j: 1 2 La versión de mostrar() en B toma un parámetro de tipo string. Esto hace que su tipo sea diferente al de A, que no toma parámetros. En consecuencia, no se la sobrescritura u ocultamiento de nombre.



4.3 Sobrecarga de Operadores 41 La sobrecarga de operadores permite redefinir ciertos operadores, para usarlos con las clases que se definen. Se llama sobrecarga de operadores porque se están utilizando el mismo operador con un número de usos diferentes, y el compilador decide cómo usar ese operador dependiendo sobre qué opera.

La sobrecarga de operadores sólo se puede utilizar con objetos de clases, no se pueden redefinir los operadores para los tipos simples predefinidos.

El Método toString()42

A veces es conveniente o necesario convertir un objeto a una cadena o String porque se necesitará pasarlo a un método que sólo acepta Strings. Todas las clases heredan toString() desde la clase Object y muchas clases del paquete java.lang sobreescriben este método para proporcionar una implementación más acorde con la propia clase. Por ejemplo, las clases Character, Integer, Boolean, etc.. sobreescriben toString() para proporcionar una representación en String de los objetos.

41 La sobrecarga de operadores no se da en Java. 42 El método toString() como método de clase permite el uso implicito del operador sobrecargado de concatenación ‘+’.



4.4. Ejercicios resueltos 4.4.1 Implementar un programa que sume dos valores enteros y dos valores flotantes implementando sobrecarga de métodos.

4.4.2 Implementar un programa que calcule el área de dos rectángulos utilizando sobrecarga de constructores.



4.4.3 Implementar un programa que reciba dos valores enteros a y b. Si a > b hacer a/b, si a < b hacer suma de a+b y si son iguales, mandar el mensaje de igualdad. Usar sobrecarga de métodos.



4.5 Ejercicios Propuestos 4.5.1 Escribir las sentencias de asignación que permitan intercambiar los contenidos de los valores de dos variables. 4.5.2 Escriba un programa que lea dos enteros en la variables x e y, y a continuación obtenga los valores de 1: x /y, 2: x % y. ejecutar el programa varias veces con diferentes pares de enteros como entrada. 4.5.3 Escribir un programa que convierta un número dado en segundos en equivalente de minutos y segundos. 4.5.4 Determinar si el carácter asociado a un código introducido por teclado corresponde a un carácter alfabético, dígito, de puntuación, especial o no imprimible. Usar sobrecarga de métodos. 4.5.5 Escribir un programa que mediante métodos determine el área del circulo correspondiente a la circunferencia circunscrita de un triangulo del que se conoce las coordenada de los vértices. 4.5.6 Construir un programa que calcule y escriba el producto, cociente entero y resto de dos números de tres cifras. 4.5.7 La fuerza de atracción entre dos masas, m1 y m2, separadas por una distancia d, está dada por la formula: F= G * m1 * m2 / d2 Escribir un programa que lea la masa de dos cuerpos y la distancia entre ellos y a continuación obtenga la fuerza gravitacional entre ella. La salida debe ser en dinas. Una dina es igual a gr.cm/seg2. 4.5.8 la realción entre los dos lados (a,b) de un triángulo y la hipotenusa (h) viene dada por la formula a2 + b2 = h2. Escribir un programa que lea la longitud de los lados y calcule la hipotenusa. 4.5.9 Escribir un programa que determine si un año es bisiesto. Un año es bisiesto si es múltiplo 4 por ejemplo, 1984. sin embargo, los años múltiplos de 100 sólo son bisiestos cuando a la vez son múltiplos de 400. por ejemplo, 1800 no es bisiesto, mientras que 200 si lo será. 4.5.10 Usando sobrecarga de métodos, mplementar un programa que realice todas las operaciones básicas (suma, resta, multiplicación y división) con dos números dados.

Unidad V. Herencia


UNIDAD V. HERENCIA

Herencia Simple, Herencia Múltiple, Clases Base, Clase Derivada, Miembros de las Clases Derivadas y Aplicaciones de Herencia

Unidad V. Herencia


UNIDAD V. HERENCIA

5.1 Introducción a la Herencia En la programación orientada existe la herencia, una de las características principales de programación orientada a objetos43. La herencia es una forma de reutilización del software en la que las clases, se crean absorbiendo los datos (atributos) y métodos (comportamientos) de una clase existente, y se mejoran con nuevas capacidades, o con modificaciones en las capacidades ya existentes. La reutilización de software ahorra tiempo durante el desarrollo de programas. También fomenta la reutilización de software probado y depurado de alta calidad, el cual aumenta la probabilidad de que un sistema se implemente con efectividad. La herencia es una de las piedras angulares de la programación orientada a objetos porque permite la creación de clasificaciones jerárquicas. Mediante la herencia el programador puede crear una clase general que defina los rasgos comunes de un conjunto de términos relacionados. Esa clase puede ser heredada por otras clases mas especificas, cada unas de las cuales añadirá aquellos rasgos que las hace únicas. Al crear una clase, en vez de declarar miembros (variables y métodos) completamente nuevos, el programador puede designar que la nueva clase herede los miembros de una clase existente. Esta clase existente se conoce como superclase, y la nueva clase se conoce como subclase. Una vez creada cada subclase puede convertirse en superclase de futuras subclases. Una subclase generalmente agrega sus propias variables y métodos, por lo tanto una subclase es más específica que una superclase y representa a un grupo mas especializado de objetos. Generalmente la subclase exhibe los comportamientos de su superclase junto los comportamientos específicos de esta subclase. La superclase, es la superclase directa a partir de la cual la subclase hereda en forma explicita. Una superclase indirecta se hereda de dos o más niveles arriba en la jerarquía de clases, la cual define las relaciones de herencia entre las clases. La experiencia en la creación de sistemas de software indica que algunas cantidades considerables de código tratan con casos especiales, estrechamente relacionados. Cuando los programadores se preocupan con casos especiales, los detalles pueden oscurecer el panorama general. Con la programación orientada a objetos, los programadores se enfocan en los elementos comunes entre los objetos en el sistema, en vez de enfocarse en los casos especiales. A este proceso se conoce como abstracción. En Java existen los términos comunes “tiene un” y “es un”. Es necesario hacer una diferencia entre la relación “es un” y la relación “tiene un”. La relación “es un” representa la Herencia; en este tipo de relación, un objeto de una subclase puede tratarse también como un objeto de sus superclases. Por ejemplo un auto es un vehiculo. En contraste, la relación “tiene un” identifica a la composición; en este tipo de relación, un objeto contiene

43 POO.

Unidad V. Herencia


una o más referencias a objetos como miembros. Por ejemplo, un auto tiene un volante de dirección. Las clases nuevas pueden heredar de las clases en diversas bibliotecas de clases. Las organizaciones desarrollan sus propias bibliotecas de clases y pueden aprovechar las que ya están disponibles en todo el mundo. En la siguiente figura 9, se tiene una clase bicicleta que es superclase de bicicleta de montaña, bicicleta de camino y bicicleta de dos asientos.

Figura 9: Clase bicicleta

5.2 Herencia Simple La herencia simple es uno de los aspectos de la programación orientada a objetos que se ha definido formalmente. La herencia simple, se puede definir como la herencia en la cual una clase hereda los métodos y atributos de solo una clase superior. En éste tipo de herencia una clase se extiende a partir de una sola superclase. La herencia múltiple, es la posibilidad de que un objeto tenga la herencia de más de una clase; esta ventaja fue considerada por los desarrolladores pero al final no la incluyeron por lo cual Java no lo contempla. Utilizando la herencia simple, se puede derivar una nueva clase a partir de la base. La clase nueva se llama clase derivada y la clase original, clase base. La idea es añadir lo que se quiera a la nueva clase para darle más funcionalidad que a la clase base. A menudo un objeto de una clase “es un” objeto de otra clase también. Por ejemplo, en la geometría un rectángulo es un cuadrilátero (al igual que los cuadrados, los paralelogramos

Bicicleta

Bicicleta de

montaña

Bicicleta de camino

Bicicleta tandem

Unidad V. Herencia


y los trapezoides). Por lo tanto en Java puede decirse que la clase Rectángulo hereda de la clase Cuadrilátero. En este contexto la clase Cuadrilátero es una superclase, y la clase Rectángulo es una subclase. Un rectángulo es un tipo específico de cuadrilátero, pero es incorrecto decir que todo cuadrilátero es un rectángulo; el cuadrilátero podría ser un paralelogramo o alguna otra figura. En la siguiente tabla se muestran ejemplos sencillos de superclases y subclases.

Superclase Subclases Estudiante Figura Prestamo Empleado CuentaBancaria

EstudianteGraduado,EstudianteNoGraduado Circulo, Triangulo, Rectangulo PrestamoAutomovil, PrestamoMejoraCasa, PrestamoHiopotecarioDocente, Administrativo CuentaDeCheques, CuentaDeAhorros

Como todo objeto de una subclase “es un” objeto de su superclase, y como una superclase puede tener muchas subclases, el conjunto de objetos representados por una superclase generalmente es mas grande que el conjunto de objetos representado por cualquiera de sus subclases. Por ejemplo la superclase Vehiculo representa a todos los vehículos, incluyendo autos, camiones, barcos, bicicletas, etc. En contraste, la clase Auto representa a un subconjunto más pequeño y específico de todos los vehículos. Las relaciones de herencia forman estructuras jerárquicas en forma de árbol. Una superclase existe en una relación jerárquica con sus subclases. Aunque las clases pueden existir de manera independiente, cuando participan en relaciones de herencia se afilian con otras clases. Una clase se convierte ya sea en una superclase, proporcionando datos y comportamientos a otras clases, o en una subclase, heredando sus datos y comportamientos de otras clases. Es posible tratar a los objetos de superclases y a los objetos de subclases de manera similar; sus similitudes se expresan en los miembros de la superclase. Los objetos de todas las clases que extienden a una superclase común pueden tratarse como objetos de esa superclase (es decir, dichos objetos tienen una relación “es un” con la superclase). Sin embargo, los objetos de una superclase no pueden tratarse como objetos de sus subclases. Por ejemplo, todos los autos son vehículos pero no todos los vehículos son autos. Un problema con la herencia es que una subclase puede heredar métodos que no necesita, o que no debe tener. A pesar de que en un método de superclase sea apropiado para una subclase, a menudo esa subclase requiere que el método realice su tarea de una manera específica para la subclase. En dichos casos, la subclase puede sobrescribir44 el método de la superclase con una implementación apropiada.

44 Redefinir.

Unidad V. Herencia


Ejemplo 1

Se tiene la clase Ave, se puede crear la subclase Pato, que es una especialización de Ave.

class Pato extends Ave { int numero_de_patas; }

La palabra clave extends 45 se usa para generar una subclase (especialización) de un objeto. Una Pato es una subclase de Ave. Cualquier cosa que contenga la definición de Ave será copiada a la clase Pato, además, en Pato se pueden definir sus propios métodos y variables de instancia. Se dice que Pato deriva o hereda de Ave.

Además, se pueden sustituir los métodos proporcionados por la clase base En Java no se puede hacer herencia múltiple 46. Por ejemplo, de la clase aparato con motor y de la clase animal no se puede derivar nada, sería como obtener el objeto toro mecánico a partir de una máquina motorizada (aparato con motor) y un toro (animal). En realidad, lo que se pretende es copiar los métodos, es decir, pasar la funcionalidad del toro de verdad al toro mecánico, con lo cual no sería necesaria la herencia múltiple sino simplemente la comparación de funcionalidad. Ejemplo 2

La herencia simple se puede ilustrar con un ejemplo sencillo como el siguiente:

Código 5.1.1 Ilustración de herencia simple.

Esta clase no está muy completa así, pero da una idea… Es una clase heredera de la clase Frame (un tipo de ventana) que tiene un par de botones y un texto. Contiene los atributos

45 Extender de 46 En Java se solucionan esos problemas con la implementación de Interfaces.

Unidad V. Herencia


("si" y "no"), que es dos objetos del tipo Button, y un constructor llamado Muestra (igual que la clase, por lo que es lo que se llama un constructor). Ejemplo 3 Cuando en Java se indica que una clase “extends” otra clase se esta indicando que es una clase hija de esta y que, por lo tanto, hereda todos sus métodos y variables.

Código 5.1.2 Herencia. La clase Perro hereda métodos y

características de la superclase Animal.

Unidad V. Herencia


Se puede observar un objeto de tipo perro creado invocando al constructor por defecto perro(). Se puede observar como la variable edad se ha inicializado a 0, y la variable nombre a “Tobi”, como se indicó en el constructor. Así mismo se ve como el objeto perro ha heredado todos los métodos definidos en la clase animal.

5.3 Herencia Múltiple La herencia múltiple es una de las oportunidades que ofrece el lenguaje c++ y es la posibilidad de que un objeto tenga la herencia de más de una clase; esta ventaja fue considerada por los desarrolladores de Java como una pega y la quitaron, e incluso hay desarrolladores de c++ que prefieren evitar este tipo de herencia ya que puede complicar mucho la depuración de programas Para ilustrar un caso de herencia múltiple se ha definido la superclase Animal de ella heredan dos clases distintas: Mamífero y Vertebrado . Ahora se quiere definir un objeto que tiene propiedades de esas dos clases: Hiena, ya que es un animal mamífero y además es vertebrado.

5.4 Clase Base y Clase Derivada

5.4.1 Definición de la Clase Base Clase base. También se le llama superclase, es la clase que hereda los métodos y atributos a la clase derivada o clase base.

Código 5.1.3 Declaración de una clase base o superclase.

5.4.1.2 Declaración de la Clase Base La declaración de una clase base o superclase es una declaración normal. La siguiente es la definición más simple de una clase: Como se puede observar, la definición de una superclase consta de dos partes fundamentales: * La declaración de la superclase Indica el nombre de la superclase precedido por la palabra clave class.

Unidad V. Herencia


* El cuerpo de la superclase

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

5.4.2 Definición de Clase Derivada Clase derivada. También se le conoce como “subclase” es aquella que hereda los métodos y atributos de la superclase o clase base.

5.4.2.2 Declaración de la Clase Derivada En la declaración de la subclasese utiliza la palabra reservada extends para especificar que dicha clase heredera los métodos de la superclase:

Código 5.1.4 Declaración de una subclase.

La extensión de clases se lleva a cabo mediante la cláusula extends. Extends establece una relación de especialización –generalización entre clases. La clase extendida es la superclase. La clase que se extiende es la subclase. Una clase puede tener, a lo sumo, una superclase47. La subclase puede introducir nuevos métodos. Así mismo, la subclase puede redefinir métodos de la superclase Ejemplo: Supóngase que se tiene una clase llamada “numeros_imaginarios” que hereda métodos o que es subclase de “numeros”, la declaración de dicha clase sería:

47 De hecho en Java toda clase tiene su superclase.

Unidad V. Herencia


5.5 Parte Protegida48

5.5.1 Propósito de la Parte Protegida Intuitivamente, protected49 se utiliza para aquellos atributos y métodos que pueden ser únicamente accedidos a nivel de subclase. De esta forma, la parte protegida de una clase es aquella parte que se publica únicamente a los implementadores que extienden la clase. No obstante, su significado es más sutil. Un miembro protegido puede ser referido desde el código de una clase a través de referencias a objetos que son, al menos, del mismo tipo que dicha clase. Los identificadores creados en la parte protegida no serán accesibles desde otros programas o módulos, pero sí tendrán acceso a ellos aquellos objetos que sean derivados del nuestro También pueden ser accedidos desde cualquier clase que pertenece al paquete de la clase que lo declara. Constructores en las clases Derivadas El constructor de una clase derivada puede llamar al constructor de su clase base mediante la palabra super. Subclase(lista_parámetros){ super(lista_parámetros); // sentencias adicionales } Si no se llama explícitamente al constructor de la clase base, se llama automáticamente al constructor por defecto de la clase base.

5.5.1.1 Llamada a constructor por defecto.

48 Protected 49 Protegido(a).

Unidad V. Herencia


5.6 Redefinición de los miembros de las clases derivadas El uso de super

Además se podría pensar en redefinir algunos métodos de la clase base pero haciendo que métodos con el mismo nombre y características se comporten de forma distinta. Por ejemplo se podría pensar en rediseñar el método toString de la clase Empleado añadiendo las características propias de la clase Ejecutivo. Así se podría poner:

5.6.1. Redefinición de métodos utilizando “super”.

De esta forma cuando se invoque jefe.toString() se usará el método toString de la clase Ejecutivo en lugar del existente en la clase Empleado.

Obsérvese en el ejemplo el uso de super, que representa referencia interna implícita a la clase base (superclase). Mediante super.toString() se invoca el método toString de la clase Empleado

Inicialización de clases derivadas

Cuando se crea un objeto de una clase derivada se crea implícitamente un objeto de la clase base que se inicializa con su constructor correspondiente. Si en la creación del objeto se usa el constructor no-args 50, entonces se produce una llamada implícita al constructor no-args para la clase base. Pero si se usan otros constructores es necesario invocarlos explícitamente.

Ejemplo:

50 Constructor por defecto.

Unidad V. Herencia


Código. 5.6.2 Uso de “super” en la inicialización de clases derivadas.

Observe que el constructor de Ejecutivo invoca directamente al constructor de Empleado mediante super(argumentos). En caso de resultar necesaria la invocación al constructor de la superclase debe ser la primera sentencia del constructor de la subclase.

5.7 Clases Virtuales y Visibilidad Virtual es una palabra clave que tiene dos acepciones completamente diferentes dependiendo del contexto de su utilización. Utilizada con nombres de clase sirve para controlar aspectos del mecanismo de herencia; utilizada con nombres de funciones-miembro, controla aspectos del polimorfismo y del tipo de enlazado que se utiliza para tales funciones51

5.8 Constructores en Clases Derivadas En el tema de la herencia, los constructores no se heredan, por ejemplo:

Código. 5.8.1 Los constructores no se heredan.

51 Java no soporta las clases virtuales.

Unidad V. Herencia


B b = new B(1,2); // error, los constructores no se heredan

Código. 5.8.2. Invocación del constructor de la clase base utilizando

“super”. La invocación del constructor de A siempre debe ser la primera instrucción del constructor de B. El principio es que en B las componentes de la clase base (A) deben inicializarse antes que las componentes que se agregan en la clase B.

5.9 Aplicaciones Aplicación 1. Ejemplo Práctico de Herencia Véase ahora un ejemplo más práctico que ayudará a ilustrar el poder de la herencia utilizando la clase box.

Unidad V. Herencia


Unidad V. Herencia


Código. 5.9.1. Se extiende la clase box para agregarle un cuarto

componente que es peso. Por lo tanto, la nueva clase contiene el largo, el ancho, el alto y el peso de la caja.

La salida de este programa es: El voulmen de micaja1 es 3000.0 El peso de micaja1 es 34.3 El volumen de micaja2 es 24.0 El peso de micaja2 es 0.076 BoxPeso hereda todas las características de Box y añade el componente peso. No es necesario que BoxPeso vuelva a crear todas las características de Box, le basta con ampliar la clase Box. La principal ventaja de la herencia es que, una vez se ha creado una superclase que define los atributos comunes a un conjunto de objetos, puede utilizarse para crear cualquier número de subclases más específicas. Cada subclase puede adoptar de forma mas precisa su propia clasificación. Por ejemplo:

Unidad V. Herencia


Código. 5.9.2. La clase ColorCaja hereda de Box y añade un atributo del color.

Hay que recordar que una vez se ha creado la superclase que define los aspectos generales de un objeto, esta superclase puede heredarse para formar clases especializadas. Cada subclase simplemente añade sus propios atributos. Ésa es la esencia de la herencia. Aplicación 2. Herencia derivando la clase figura.

La clase base es Figura, y de ella van a heredar las clases Poligono y Circulo. A su vez, de Poligono heredarán las clases Cuadrado y Triangulo. El diagrama esquemático de clases es el siguiente:

La clase base Figura solo tiene dos atributos: nombre de la figura y perímetro (longitud total de su borde exterior) y, aparte del constructor, un único método llamado imprimirInformacion que imprime por pantalla la información de la figura.

Aquí está la clase como se muestra en el código 5.9.3.

Código. 5.9.3. Clase Figura programada. En el método main, crea tres objetos y luego imprime la información de cada uno de ellos: un cuadrado de lado 2 metros, un círculo de radio 2 metros y un triángulo de lado 3 metros.

Unidad V. Herencia


Compila y ejecuta el programa. La salida por pantalla debe ser la siguiente: Soy un cuadrado y mi perímetro es 8.0 m Soy un círculo y mi perímetro es 12.5663704 m Soy un triángulo y mi perímetro es 9.0 m Aplicación 3 Clase Circulo. Ahora se va a programar la clase Circulo, que hereda de la clase anterior Figura. Esta nueva clase tiene un atributo más (aparte de los heredados), de tipo double, que almacena el radio del círculo, que se le pasa en el constructor. El radio sirve para calcular el perímetro del círculo (2*pi*radio). Además esta clase sobre escribe el método anterior imprimirInformacion para añadir un mensaje más explicativo con el valor del radio. El código de la clase Circulo se muestra en el código 5.9.4:

Código 5.9.4. Clase circulo.

Modifica el método main, y crea dos objetos de la clase Circulo, uno de radio 2 metros y otro de radio 3 metros, e imprime su información. Tras compilar y ejecutar el programa, la salida por pantalla debe ser la siguiente: Soy un círculo y mi radio es 2.0 m, con lo que mi perímetro es 12.5663704 m Soy un círculo y mi radio es 3.0 m, con lo que mi perímetro es 18.849555600000002 m Aplicación 4. Clase polígono. Ahora toca la clase Poligono, muy parecida a la clase Circulo anterior. La diferencia es que en vez de radio los atributos del polígono son el número de lados y la longitud de cada lado, con los que podemos calcular el valor del perímetro.

Unidad V. Herencia


Este ejercicio consiste en programar la clase Poligono. En el método main crea dos polígonos, uno de 3 lados con longitud 3 (triángulo) y otro de 4 lados con longitud 4 (cuadrado). El esqueleto de la clase se muestra en el código 5.9.5:

Código 5.9.5 Clase polígono.

La salida en pantalla debe ser la siguiente: Soy un polígono cuadrado, tengo 4 lados de longitud 2.0 m, con lo que mi perímetro es 8.0 m Soy un polígono triángulo, tengo 3 lados de longitud 3.0 m, con lo que mi perímetro es 9.0 m Aplicación 5. Clase cuadrado y triangulo. Sólo quedan las clases Cuadrado y Triangulo, que derivan de la clase Poligono. Estas dos clases no tienen atributos nuevos y ni siquiera sobreescriben el método imprimirInformacion. Programa las dos clases. En cada una de ellas, añade un main que cree dos objetos. Los esqueletos de las clases son los siguientes:

Unidad V. Herencia


Código 5.9.6 Clase cuadrado.

Código 5.9.7 clase triangulo.

Aplicación 7. Creación de una jerarquía multinivel Se pueden construir jerarquías que contengan tantos niveles de herencia como se quiera. Es totalmente aceptable utilizar una subclase como una superclase de otra. Por ejemplo, en las clases A, B y C, C puede ser la subclase de B, que a su vez es una subclase de A. cuando se da esta situación, cada subclase hereda todos los rasgos de sus superclases. En este caso, C hereda todos los aspecto de B y A, para ver la utilidad de una jerarquía multinivel, observe el siguiente ejemplo:

Unidad V. Herencia


Unidad V. Herencia


Código. 5.9.8 En las tres secciones de código anteriores, la subclase BoxPeso se utiliza como una superclase para crear la subclase llamada

Transporte. transporte hereda todas las características de BoxPeso y Box, y añade un campo llamado costo, que contiene el coste del envió del

paquete. La salida del programa es: El Volumen de transporte1 es 3000.0 El peso de transporte1 10.0 Costo de Transporte1: $3.41 El volumen del transporte2 es 24.0 El peso de transporte2 es 0.76 Costo de transporte2: $1.28 Gracias a la herencia, Transporte 52 puede utilizar las clases Box y BoxPeso definidas previamente, añadiendo sólo la información adicional que necesita para su aplicación especifica. La reutilización del código es una de las ventajas de la herencia. Este ejemplo pode de relieve otro aspecto importante: super() siempre hace referencia al constructor de la superclase más próxima. El método super() en Transporte llama al constructor de Box. En una jerarquía de clases, si el constructor de una superclase necesita parámetros, entonces todas las subclases han de pasar esos parámetros en línea ascendente. Esto es así tanto si la subclase necesita esos parámetros como si no.

52 Transporte.

Unidad V. Herencia


ORDEN DE EJECUCION DE LOS CONSTRUCTORES Cuando se crea una jerarquía ¿En qué orden se ejecutan los constructores de las clases que forman esa jerarquía? Por ejemplo, con una subclase llamada B y una superclase llamada A. ¿Se ejecutará el constructor A antes que el B, o a la inversa? La respuesta es que en la jerarquía de clases, los constructores se ejecutan en el orden en que se derivan, es decir, desde la superclase a la subclase. Además, dado que super() tiene que ser la primera sentencia que se ejecute en el constructor de una subclase, este orden es el mismo tanto si se usa super() como si no. En el caso de que no se utilice super(), se ejecutará el constructor por defecto o el constructor sin parámetros de cada superclase. El siguiente ejemplo muestra el momento en que se ejecutan los constructores:

Código 5.9.9. Orden de ejecución de constructores en una jerarquía de clases.

La salida de este programa es:: Dentro del constructor A Dentro del constructor B Dentro del constructor C Como se ve, los constructores se ejecutan en el orden en que se derivan. Esto es lógico, ya que una superclase no conoce sus subclases y cualquier inicialización que necesite realizar es independiente, y posiblemente un requisito previo para cualquier inicialización realizada por la subclase, por lo que se debe ejecutar en primer lugar.

Unidad V. Herencia


5.10 Ejercicios propuestos. 5.10.1 Implementar una clase Automóvil (carro) dentro de una jerarquía de herencia. Considere que además de ser un vehiculo, un automóvil es también una comodidad, un símbolo de estado social, un modo de transporte etc. 5.10.2 Implementar una jerarquía de herencia de animales tal que contenga al menos seis niveles de derivación y doce clases. 5.10.3 Deducir las clases necesarias para diseñar un programa de ordenador que permita jugar a diferentes juegos de cartas. 5.10.4 Confeccionar una clase Persona que tenga como atributos el nombre y la edad. Definir como responsabilidades un método que cargue los datos personales y otro que los imprima. Plantear una segunda clase Empleado que herede de la clase Persona. Añadir un atributo sueldo y los métodos de cargar el sueldo e imprimir su sueldo. Definir un objeto de la clase Persona y llamar a sus métodos. También crear un objeto de la clase Empleado y llamar a sus métodos. 5.10.5 Elaborar una jerarquía de herencia que modele los seres vivos capaces de hablar. Las clases deben modelar al menos a los loros, los profesores y los alumnos. Todas las clases elaboradas deben disponer de un método habla sin argumentos que proporcione una salida por pantalla similar a la siguiente: Hola, me llamo Pedro y se hablar. Soy racional. Tengo 40 años. Nací el 1 de enero de 1965 Soy profesor. Para que el ejercicio sea interesante es necesario que todos los objetos habladores tengan un conjunto de características que les diferencian de los demás, por ejemplo, que los loros no sean conscientes de su edad o su fecha de nacimiento. 5.10.6 Los loros del ejercicio anterior no pueden ser universitarios simultáneamente, pero un profesor puede ser también alumno. Elaborar un conjunto de clases que permitan modelar esta situación de forma que un objeto pueda cambiar su forma de hablar en tiempo de ejecución en función de la recepción de algún mensaje adecuado. 5.10.7 Escribir un programa que lea del dispositivo estándar de entrada los datos para crear una lista de personas: a) general; b) estudiantes; c) empleados; d) estudiantes empleados. El programa debe permitir ordenar alfabéticamente por el primer apellido. 5.10.8 implementar una jerarquía Librería que tenga al menos una docena de clases. Considérense una librería que tenga colecciones de libros de literatura, humanidades, tecnología, etc.

Unidad V. Herencia


5.10.9 Implementar una jerarquía de tipos datos númericos que extienda los tipos de datos fundamentales tales como int y float, disponibles en Java. Las clases a diseñar pueden ser complejo, vector, matriz, etc.

Unidad VI. Polimorfismo


UNIDAD VI. POLIMORFISMO Y REUTILIZACION

Concepto de Polimorfismo, Clases Abstractas, Definición e Implementación de una Interfaz, Definición y creación de Paquetes.



UNIDAD VI. POLIMORFISMO

6.1 Concepto de polimorfismo

El concepto de Polimorfismo es uno de los fundamentos para cualquier lenguaje orientado a Objetos, las mismas raíces de la palabra pueden ser una fuerte pista de su significado: Poli = Multiple, morfismo= Formas , esto implica que un mismo Objeto puede tomar diversas formas. A través del concepto de Herencias 53 es posible ilustrar este comportamiento:

Figura 10: Ilustración del polimorfismo. El poder manipular un Objeto como si éste fuera de un tipo genérico otorga mayor flexibilidad al momento de programar con Objetos, el término Polimorfismo también es asociado con un concepto llamado Late-Binding54, obsérvese el siguiente fragmento de código: Figura a = new Circulo(); Figura b = new Triangulo(); Inicialmente se puede pensar que este código generaría un error debido a que el tipo de referencia es distinta a la instancia del objeto, sin embargo, el fragmento anterior es correcto y demuestra el concepto de Polimorfismo. El polimorfismo permite “programar en forma general”, en vez de “programar en forma específica”. En especial, el polimorfismo nos permite escribir programas que procesen

53 Inheritance. 54 Ligamiento Tardío.



objetos de clases que formen parte de la misma jerarquía de clases, como si todos fueran objetos de sus superclases. El polimorfismo en java consiste en declarar y definir varios métodos con el mismo nombre, pero con diferente número y/o tipo de argumentos y que realizan diferentes operaciones. Sin embargo, el tipo que devuelven los métodos debe coincidir. Java es un lenguaje totalmente orientado a objetos, y como tal podemos utilizar las propiedades que este tipo de programación ofrece. Una de estas propiedades es el polimorfismo, pero ¿Qué es el polimorfismo?. La palabra polimorfismo significa múltiples formas y es la propiedad que tiene un lenguaje de programación de que una clase (conjunto de objetos con características en común), pueda tener diferentes comportamientos. Imagínese que es responsable de programar un editor de facturas, el cual tendrá dos salidas, una es el envió de la factura por fax y la otra es la impresión de la factura. Si el programa encargado enviar faxes y el de impresión ya están elaborados, y solo pueden ser utilizados por documentos que puedan ser faxeados y documentos que puedan ser impresos respectivamente, como se puede adicionarlos al editor para faxear e imprimir las facturas. Para el problema descrito anteriormente una buena opción es aplicar polimorfismo, para que la clase Factura pueda tener el comportamiento adicional que necesita, es decir, pueda ser de tipo documento faxeable o documento imprimible y los módulos de envió de fax e impresión se utilicen sin hacerles ningún cambio. La figura 11 muestra como la clase cliente Factura hace uso de los servicios de la clase Fax e Impresora implementando las interfaces DocumentoFaxeable y DocumentoImprimible respectivamente, por lo tanto la clase Factura se puede comportar como un objeto de la clase DocumentoFaxeable y/o DocumentoImprimible, y son estos tipos de objetos los únicos que son aceptados por las clases Impresora y Fax.

Figura 11: Polimorfismo y reutilización



Existe otra forma de utilizar polimorfismo sin tener que implementar un contrato, es por medio de herencia, la herencia permite que una clase padre “herede” sus características a una clase hija, y establece que clase hija será del tipo de la clase padre y tendrá sus características55 y comportamientos56. Una de las utilidades de la herencia es que se puede crear una clase General (propiedades y características en común) y clases hijas que solo modificarán la parte que ellas requieren, permitiendo así que tengan el comportamiento de la clase padre con sus propias características, y como valor agregado la reutilización de código. Supóngase que ahora se esta encargado de programar la parte de administración de clientes de una aplicación de ventas, y se sabe que existen dos tipos de clientes candidatos a clases, el cliente que tiene las características de un cliente común, y el cliente preferencial que tiene todas las propiedades del cliente común pero además se le aplican descuentos, ¿Es necesario programar cada tipo de cliente por separado? ¿Si aparece otro tipo de cliente se programará desde cero?....No. Utilizando herencia la clase Cliente puede ser nuestra clase padre y la clase ClientePreferencial la clase hija de Cliente que en cada compra se le aplicará un descuento y si apareciera otro tipo de cliente, solo heredaría de Cliente y modificaríamos la parte que lo hace diferente. La figura 12 muestra como a través de herencia la clase Cliente (clase padre) hereda sus características a la clase ClientePreferencial (clase hija), y esta modifica un método para adicionar su propia implementación.

Figura 12 Ilustración de la herencia

55 Propiedades. 56 Métodos.



Ahora se sabe, que la próxima vez que se tenga la necesidad de crear programas donde las clases tengan diferentes comportamientos para realizar diferentes acciones, donde sea indispensable crear un conjunto de clases que compartirán una serie de características y además se demande la reutilización de código. Una buena opción en un lenguaje orientado a objetos, es la utilización del polimorfismo.

Ejemplo: Una sintaxis algo genérica puede ser la que sigue:

Código 6.1.1. Ejemplo de polimorfismo

6.2 Clases abstractas

6.2.1 Definición

Una de las características más útiles de cualquier lenguaje orientado a objetos es la posibilidad de declarar clases que definen como se utiliza solamente, sin tener que implementar método. Esto en Java se hace mediante interfaces y con clases abstractas.

Una clase abstracta es una clase de la que no se puede crear objetos. La utilidad de estas clases estriba en que otras clases hereden de ésta, por lo que con ello se conseguirá reutilizar código. Para declarar una clase como abstracta se utiliza la palabra clave abstract.

Los métodos para los que no aporte una implementación serán declarados a su vez abstractos. Si una clase tiene un método abstract es obligatorio que la clase sea abstract. Todas las subclases que hereden de una clase abstracta tendrán que redefinir los métodos abstractos dándoles una implementación. En el caso de que no implementen alguno de esos métodos la clase hija también será abstracta y tendrá que declararse como tal (tanto la clase como los métodos que siguen siendo abstractos).

En método abstract no puede ser static, ya que estos no pueden ser redefinidos por las subclases.



Hay ocasiones, cuando se desarrolla una jerarquía de clases en que algún comportamiento está presente en todas ellas pero se materializa de forma distinta para cada una. Por ejemplo, supóngase una estructura de clases para manipular figuras geométricas. Se podría pensar en tener una clase genérica, que podría llamarse FiguraGeometrica y una serie de clases que extienden a la anterior que podrían ser Circulo, Poligono, etc. Podría haber un método dibujar dado que sobre todas las figuras puede llevarse a cabo esta acción, pero las operaciones concretas para llevarla a cabo dependen del tipo de figura en concreto (de su clase). Por otra parte la acción dibujar no tiene sentido para la clase genérica FiguraGeometrica, porque esta clase representa una abstracción del conjunto de figuras posibles.

Código 6.2.1.1. Ilustración de clases abstractas.

Para resolver esta problemática Java proporciona las clases y métodos abstractos. Un método abstracto es un método declarado en una clase para el cual esa clase no proporciona la implementación (el código). Una clase abstracta es una clase que tiene al menos un método abstracto. Una clase que extiende a una clase abstracta debe implementar los métodos abstractos (escribir el código) o bien volverlos a declarar como abstractos, con lo que ella misma se convierte también en clase abstracta.

Caracteristicas de las clases Abstractas en Java

a) Una clase que tiene al menos un método abstracto, es una clase abstracta. b) Para declarar un método o una clase abstracta se usa la palabra abstract. c) Cuando en una clase derivada no se (re)define un método abstracto mediante una

implementación, el método continúa siéndolo en la clase derivada. d) Se exige que todas las clases abstractas sean declaradas como tales. e) No se permite la creación de objetos de clases abstractas.

Como ya se dijo anteriormente para declarar una clase o un método como abstractos, se utiliza la palabra reservada abstract.



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

Ejemplo

Se diseñará una clase con un método abstracto f(double x) que representa una función de parámetro x cualquiera. Se observa que por lógica esta función se debe implementar en alguna clase derivada para que tenga sentido.

Además de este método abstracto, se implementara un método llamado evaluar que llama al método f, retornando su valor.

Código 6.2.1.2. Clases abstractas.

Con esto se puede comprobar que no se puede crear un objeto de una clase abstracta.

Ejemplo : Funcion func = new Funcion( ); double v = func.evaluar(0.6); /* error logico!! */

6.2.2 Redefinición

La redefinición de una clase abstracta consiste en extenderla y redefinir sus miembros para dicha clase puede ser utilizada y generar resultados.

Continuando con el ejemplo anterior:

Ahora se extenderá la funcionalidad de clase abstracta Funcion creando la clase derivada FuncionExp que representa a la función exponencial.

En esta clase se implementa el método abstracto f.

57 No se pueden crear objetos directamente de ella.



Código 6.2.2.1. Implementación de un método abstracto.

Usando las características de herencia, se tiene el siguiente ejemplo :

Código 6.2.2.2 Llamado a métodos implementados de clases abstracta.

Al igual que la clase FuncionExp, se crea a continuación una clase que representa a una función lineal, y se redefinen los métodos.

Código 6.2.2.3 Redefinición de métodos.

Y a continuación se crea un programa de prueba para los ejemplos anteriores:



Programa de prueba

Código 6.2.2.4 Programa de prueba para los dos ejemplos anteriores.

6.3 Definición de una Interfaz Las interfaces Java son expresiones puras de diseño. Se trata de auténticas conceptualizaciones no implementadas que sirven de guía para definir un determinado concepto (clase) y lo que debe hacer, pero sin desarrollar un mecanismo de solución58. Se trata de declarar métodos abstractos y constantes que posteriormente puedan ser implementados de diferentes maneras según las necesidades de un programa.

En otras palabras, una interfaz es un conjunto de declaraciones de funciones. Si una clase implementa una interfaz, debe definir todas las funciones especificadas por la interfaz. Las interfaces pueden definir también variables finales (constantes). Una clase puede implementar más de una interfaz, representando una alternativa a la herencia múltiple. En algunos aspectos los nombres de las interfaces pueden utilizarse en lugar de las clases. Por ejemplo, las interfaces sirven para definir referencias a cualquier objeto de cualquiera de las clases que implementan esa interfaz. Con ese nombre o referencia, sin embargo, sólo se pueden utilizar los métodos de la interfaz. Éste es un aspecto importante del polimorfismo. Una interfaz puede derivar de otra o incluso de varias interfaces, en cuyo caso incorpora las declaraciones de todos los métodos de las interfaces de las que deriva (a diferencia de las clases, las interfaces de Java sí tienen herencia múltiple). Utilizando la palabra clave interfaz, se puede abstraer completamente la interfaz de una clase de su implementación. Es decir, con interfaz se puede especificar lo que una clase debe hacer, pero no cómo ha de hacerlo. Las interfaces tienen una sintaxis parecida a la de las clases, pero les faltan las variables de instancia, y sus métodos se declaran sin cuerpo. En la práctica, esto significa que se pueden definir las interfaces que no hagan 58 Es la alternativa que Java otorga a la herencia múltiple.



suposiciones sobre cómo se implementan. Una vez que está definida, cualquier número de clases puede implementar una interfaz. Asimismo, una clase puede implementar cualquier número de interfaces. Para implementar una interfaz, una clase ha de crear el conjunto completo de métodos definidos por la interfaz. Sin embargo, cada clase tiene libertad de determinar los detalles de su propia implementación. Con la palabra clave interfaz Java permite la utilización completa del aspecto del polimorfismo, “una interfaz, múltiples métodos”. Las interfaces están diseñadas para dar soporte a la resolución dinámica de métodos durante la ejecución. Normalmente, para que un método de una clase pueda ser llamado desde otra clase, es necesario que las dos clases estén presentes durante la compilación para que el compilador java pueda comprobar que el formato de los métodos es compatible. Este requisito da lugar por si sólo a un entorno de clase no estático y extensible. Inevitablemente, en un sistema así, las clases, de forma que los mecanismos estarán disponibles para más y más subclases. Las interfaces, desconectando la definición de un método o de un conjunto de métodos de la herencia jerárquica, eliminan ese problema. Como las interfaces tienen una jerarquía distinta de la de las clases, es posible que clases que no están relacionadas en términos de jerarquía implementen la misma interfaz, lo que pone de manifiesto la verdadero potencia de las interfaces.

6.4 Implementación de la Definición de una Interfaz Una interfaz se define como una clase. La forma general de definir una interfaz es ésta:

Código 6.4.1 Implementación de la de definición de una interfaz.

En este ejemplo el acceso o es público o no se usa. Cuando no se incluye el especificador de acceso, se utiliza el acceso por defecto, y la interfaz está disponible sólo para otros miembros del paquete en que se declara. Cuando se declara como public, la interfaz puede utilizarse por otro código. Nombre es el nombre de la interfaz, y debe ser un identificador válido. Obsérvese que los métodos que se declaran no tienen cuerpos y terminan con un punto y coma después de la lista de parámetros. Son esencialmente métodos abstractos, ya que no puede haber implementación por defecto de un método



declarado dentro de una interfaz. Cada clase que incluya una interfaz ha de implementar todos los métodos. Las variables pueden declararse dentro de las declaraciones de la interfaz y son, implícitamente, final y static: esto significa que no pueden ser alteradas por la implementación de la clase y que deben inicializarse con un valor constante. Todos los métodos y variables son implícitamente public si la interfaz se declara public. Un ejemplo de definición de una interfaz sencilla, que contiene un método llamado callback() que toma un solo parámetro entero. interface Callback( void callback(int param); } Implementación de una Interfaz Una vez definida una interfaz una o más clases pueden implementarse. Para implementar una interfaz, se ha de incluir la cláusula implements en una definición de clase, y luego crear los métodos definidos por la interfaz. La forma general de una clase que incluye la cláusula implements es esta:

Código 6.4.2 Implementación de una interfaz.

El acceso es public o no se usa. Si una clase implementa más de una interfaz, las interfaces se separan con comas. Si una clase implementa dos interfaces, entonces los clientes de las dos interfaces deberán usar el mismo método. Los métodos que implementan una interfaz deben declararse como public. Además, el formato del método implementado debe coincidir exactamente con el formato especificado en la definición de la interfaz. A continuación, un pequeño ejemplo de una clase que implementa la interfaz DevolverLllamada.:

Código 6.4.3 Implementación de la interfaz DevolverLlamada.



Obsérve que DevolverLlamada() se declara por medio del especificador de acceso public. Es habitual y además permitido que las clases que implementen interfaces definan miembros adicionales propios. Por ejemplo, la siguiente versión de Cliente implementa DevolverLlamada y añade el método NoMetododeInterfaz( );

Código 6.4.4 Definición de miembros adicionales en clases que implementan interfaces.

6.5 Reutilización de la definición de una Interfaz Se pueden declarar variables como referencias a objetos que usan una interfaz en lugar de un tipo de clases. Se puede hacer referencia a cualquier instancia de cualquier clase que implementa una interfaz declarada por medio de tales variables. Cuando se llama a un método por medio de estas referencias se llamará a la versión correcta que se basa en la instancia actual de la interfaz que esta siendo referenciada. Está es una de las característica clave de las interfaces. El método que se va ejecutar se determina dinámicamente durante la ejecución y se permite que las clases en las que se encuentra ducho método se creen después del código llamante, que puede seleccionar una interfaz sin tener ningún conocimiento sobre el método al que se ha llamado. Este proceso es similar al que se seguía cuando se utilizaba una referencia de una superclase para acceder a un objeto de una subclase. El siguiente ejemplo llama al método DevuelveLlamada() por medio de una variable de referencia:

Código 6.5.1. Llamada al método DevuelveLlamada() por medio de una variable de referencia.

La salida es:



DevuelveLlamada llamada con 42 Observe que la variable c se ha declarado como el tipo de la interfaz DevuelveLlamada, aunque se le ha asignado una instancia de Clienet. A pesar de que c se puede utilizar para acceder al método DevuelveLlamada (), no sirve para acceder a otros miembros de la clase Cliente. Una variable de referencia a una interfaz solo tiene conocimiento de los métodos que figuran en la declaración de su interfaz. Por lo tanto, c no podría utilizarse para acceder al método NoMetododeInterfaz() debido a que está definido por Cliente, pero no por DevuelveLlamada. El ejemplo anterior mostraba, de forma mecánica, como una variable de referencia a una interfaz puede acceder a la implementación de un objeto, pero no demostraba la potencia del polimorfismo. Como ejemplo se creará una segunda implementación de DevuelveLlamada:

Ahora, se probará con la siguiente clase:

Código 6.5.2 Demostración del potencial del polimorfismo implementando la clase OtroCliente.

La salida del programa es la siguiente: DevuelveLlamada llamado con 42 otra version de DevuelveLlamada



p al cuadrado es 1764 Como se observa la versión del método DevuelveLlamada() al que se ha llamado está determinada por el tipo de objeto al que c hace referencia durante la ejecución. Aunque el ejemplo que ahora se muestra es demasiado sencillo, enseguida se muestra otro más práctico. Implementación parcial Si una clase incluye una interfaz pero no se implementa completamente los métodos definidos por esa interfaz, entonces debe ser declarada como abstract. Por ejemplo:

Código 6.5.3. La implementación parcial de una interfaz la convierte en una clase abstracta.

En este caso, la clase Incompleta no implementa el método DevuelveLlamada() y ha de ser declarada como abstracta. Cualquier clase que herede Incomplete ha de implementar DevuelveLlamada(), o bien declararse como abstract. Aplicación de las Interfaces Para comprender la potencia de las interfaces, véase ahora un ejemplo más práctico. Existen varias formas de implementar una pila 59, por ejemplo, la pila puede ser de tamaño fijo o de tamaño creciente. La pila también puede estar contenida dentro de una matriz, una lista, un árbol binario, etc. No importa de qué manera se implemente la pila, su interfaz permanece inalterable. Es decir, los métodos push()60y pop()61 definen la interfaz a la pila independientemente de los detalles de la implementación. Así, es fácil definir dicha interfaz y dejar para cada implementación los detalles más específicos. Véanse dos ejemplos. El primero de ellos presenta una interfaz que define una pila de enteros y se guarda en un archivo llamado pila.java. Esta interfaz se utilizará para las dos implementaciones de la pila.

59 Stack. 60 Insertar un elemento a la pila. 61 Eliminar un elemento de la pila.



Código 6.5.4. Declaración de una interfase pila para almacenar y recuperar un elemento.

El siguiente programa crea una clase llamada PilaFija y que implementa una versión de una pila de enteros de longitud fija:



Código 6.5.3. Programa que crea una clase llamada PilaFija y que implementa una versión de una pila de enteros de longitud fija.

A continuación se muestra otro ejemplo de la implementación de Pila que crea una pila dinámica utilizando la misma definición de la interfaz. En esta implementación, cada pila se construye partiendo de una longitud inicial. Si se sobrepasa esa longitud, se incrementa el tamaño de la pila. Cada vez que se necesite más espacio, se doblará el tamaño de la pila.



Código 6.5.4. Programa que crea una clase llamada PilaDnamica y que implementa una versión de una pila de enteros de longitud dinámica.

La siguiente clase utiliza las implementaciones PilaFija y PilaDinamica, por medio de una referencia a la interfaz. Esto significa que las llamadas a los métodos push() y pop() se resuelven durante el tiempo de la ejecución y no en el de compilación.



Código 6.5.5. Implementación de PilaFija y PilaDinamica.

En este programa, mipila es una referencia a la interfaz Pila. Por lo tanto, cuando se refiere a ds, utiliza las versiones de push() y pop() definidas por la implementación PilaDinamica. Cuando se refiere a fs, utilza las versiones de push() y pop() definidas por PilaFija. Como ya se ha explicado, estas decisiones se toman durante la ejecución. El acceso a múltiples implementaciones de una interfaz a través de una variable de referencia de la interfaz es la forma más eficaz de que dispone Java para lograr el polimorfismo en el tiempo de ejecución.

6.6 Definición y Creación de Paquetes Conforme empieza a crecer un desarrollo de software surge la necesidad de reutilizar ciertos componentes que ya han sido escritos, así como dar cierta estructura para mantener una organización de código; al igual que otros lenguajes, esta organización se lleva acabo mediante librerías, denominadas "packages" en el mundo Java .

Java toma una perspectiva nueva respecto a otros lenguajes, adoptando una convención a partir de dominios en Internet, esto es, los programas y por ende librerías ("packages") estarán basados en el nombre de la empresa/dominio para la cual son diseñados, lo anterior permite evitar la tan conocida Colisión de Nombres en Software.



Esta colisión de nombres se da cuando dos clases llevan el mismo nombre y ambas requieren ser utilizadas dentro de un programa en particular, empleando Dominios en Internet se garantiza que el nombre de la clase/librería sea única , puesto que es una característica de Dominios en Internet.

Para que puedan ser asignadas clases a determinadas librerías es necesario indicar dicha Librería("Package") en la definición inicial de un programa, además de esto, es necesario crear una estructura de directorios para generar las determinadas Clases; lo anterior se ilustra mejor a través de un ejemplo:

Creación de Librerías

Estructura de Directorios para utilizar Librerías ("Paquetes") Para utilizar "paquetes" en Java es necesario generar una estructura de directorios que lleven la misma secuencia de las librerías que desean diseñarse, observe:

+-com+- | +-osmosislatina+- | +-escritura+- | +-graficas+- | +-correo+- | +-errores+- | +-auxiliares+-

L

o anterior demuestra una estructura para las librerías del dominio com.osmosislatina, se debe mencionar que no existe ninguna restricción en el número de directorios anidados, de tal forma, es posible que existan librerías de 5 o 10 niveles de profundidad, esta sub-clasificación se va realizando en base a los requerimientos de las librerías y es dentro de cada sub-directorio donde son colocadas las distintas Clases.

Además de la generación de estos directorios, se debe incluir un calificador de la librería en el código fuente de cada Clase:

package com.osmosislatina.escritura;

Lo anterior sería incluido en todos los programas pertenecientes a la librería ("Package") com.osmosislatina.escritura, debe mencionarse que este calificador debe ser la primer declaración en todo programa; recuérdese que además de este calificador el programa debe estar colocado en la estructura de directorios correspondiente, lo anterior es sumamente importante al llevarse acabo la compilación para la generación de Byte-Code



Código Fuente Pantalla.java La siguiente Clase define dos métodos que pueden ser utilizados para imprimir resultados a pantalla:

La siguiente Clase debe ser colocada bajo la estructura de directorios com/osmosislatina/escritura, en base a su ambiente (Linux o Windows). Por favor genérese dicha estructura para colocar esta clase

package com.osmosislatina.escritura; public class Pantalla { public static void sinSalto(String s) { System.out.print(s); } public static void conSalto(String s) { System.out.println(s); } }

• Primeramente se declara la librería ("package") a la que será asignada el programa a través del vocablo package.

• Se define la Clase con los respectivos métodos sinSalto y conSalto.

• NOTA: Recuerde que este programa debe residir dentro del directorio com/osmosislatina/escritura/.

• NOTA 2: Obsérvese que esta Clase no posee el método principal main.

Para compilar esta Clase basta ejecutar el comando:

$ javac Pantalla.java

Lo anterior genera el archivo de ByteCode : Panatalla.class. En la siguiente sección será diseñado un programa que haga uso de esta librería ("package").



6.7 Reutilización de las clases de un Paquete / Librería Para emplear librerías 62 en un programa es necesario importarlas, esto es llevado acabo mediante el calificativo import como se demuestra a continuación:

import com.osmosislatina.graficas.Recuadro;

La declaración anterior permite que la clase Recuadro de la librería com.osmosislatina.graficas este disponible en el programa en cuestión, las características del uso de import son las siguientes:

• Se debe declarar al inicio de un programa, antes de la definición de la clase, aunque posterior a la definición de package (si existiese) .

• Se pueden utilizar un número ilimitado de import. • Es posible importar todas las clases de una librería a través de un asterisco (*).

Código Fuente MandaPantalla.java La siguiente Clase manda llamar métodos definidos en la Clase Pantalla.java.

Código 6.7.1. Código Fuente MandaPantalla.java

• Primeramente se declara la librería a la que será asignada el programa a través del vocablo package.

• Posteriormente se importan las clases que serán utilizadas en el programa a través del vocablo import.

62 Conocidas como package.



• Se define el método main dentro del cual se genera una instancia de la case Pantalla (aquella importada) y sobre la que posteriormente se mandan llamar los distintos métodos a través de su referencia.

La compilación (generación de bite-code) de esta Clase requiere que, esta sea llevada a cabo bajo el directorio raíz de la estructura de Clases, esto es, aunque esta Clase radique dentro del directorio com/osmosislatina/auxiliares es necesario llevar acabo la compilación desde la raíz (./com), lo anterior se debe a que esta Clase requiere ubicar (importar) las clases de la librería com/osmosislatina/escritura; los detalles de esta rutina serán descritos en la sección de CLASSPATH.

Para ejecutar este programa también se requiere descender al directorio raíz de la librería ("Package).

El paquete (package)

• Los paquetes son una forma de organizar grupos de clases. Un paquete contiene un conjunto de clases relacionadas bien por finalidad, por ámbito o por herencia.

• Los paquetes resuelven el problema del conflicto entre los nombres de las clases. Al crecer el número de clases crece la probabilidad de designar con el mismo nombre a dos clases diferentes.

• Las clases tienen ciertos privilegios de acceso a los miembros dato y a las funciones miembro de otras clases dentro de un mismo paquete.

Cuando se crea un proyecto nuevo se crea en un subdirectorio que tiene el nombre del proyecto. A continuación, se crea la aplicación, un archivo .java que contiene el código de una clase cuyo nombre es el mismo que el del archivo. Se pueden agregar nuevas clases al proyecto, todas ellas contenidas en archivos .java situadas en el mismo subdirectorio. La primera sentencia que se encuentra en el código fuente de las distintas clases que forman el proyecto es package o del nombre del paquete.



6.8 Clases Genéricas (Plantillas) 63 Las clases plantilla, clases genéricas, o generadores de clases, son un artificio que permite definir una clase mediante uno o varios parámetros. Este mecanismo es capaz de generar la definición de clases (instancias o especializaciones de la plantilla) distintas, pero compartiendo un diseño común. Se puede imaginar que una clase genérica es un constructor de clases, que como tal, acepta determinados argumentos (no confundir con el constructor de-una-clase, que genera objetos).

6.9 Ejercicios Resueltos 6.9.1 Crear una clase abstracta denominada Animal de la cual se derivan las clases Gato y Perro. Ambas clases redefinen la función habla declarada abstracta en la clase base Animal.

El polimorfismo permite pasar la referencia a un objeto de la clase Gato, Perro o Pajaro a una función hazleHablar que conoce al objeto por su clase base Animal.

63 Este mecanismo no es implementado por java



El compilador no sabe exactamente que objeto se le pasará a la función hazleHablar en el momento de la ejecución del programa. Si se pasa un objeto de la clase Gato se imprimirá ¡Miau!, si se pasa un objeto de la clase Perro se imprimirá ¡Guau!. Y si se le pasa un objeto de la clase Pajaro imprimirá ¡pió! El compilador solamente sabe que se le pasará un objeto de alguna clase derivada de Animal. Por tanto, el compilador no sabe que función habla será llamada en el momento de la ejecución del programa.

El polimorfismo ayuda a hacer el programa más flexible, por que en el futuro se pueden añadir nuevas clases derivadas de Animal, sin que cambie para nada el método hazleHablar.

6.9.2 Crear una interface denominado Parlanchin que contenga la declaración de una función denominada habla.

Se desarrolla la jerarquía de clases que deriva de Animal implemente la interface Parlanchi.



Ahora véase otra jerarquía de clases completamente distinta, la que deriva de la clase base Reloj. Una de las clases de dicha jerarquía Cucu implementa el interface Parlanchin y por tanto, debe de definir obligatoriamente la función habla declarada en dicho interface.

Se define la función hazleHablar de modo que conozca al objeto que se le pasa no por una clase base, sino por el interface Parlanchin. A dicha función se le puede pasar cualquier objeto que implemente el interface Parlanchin, este o no en la misma jerarquía de clases.



Al ejecutar el programa, se vera que se imprime en la consola ¡Miau!, por que a la función hazleHablar se le pasa un objeto de la clase Gato, y después ¡Cucu, cucu, ..! por que a la función hazleHablar se le pasa un objeto de la clase Cucu.

Si solamente hubiese herencia simple, Cucu tendría que derivar de la clase Animal (lo que no es lógico) o bien no se podría pasar a la función hazleHablar. Con interfaces, cualquier clase en cualquier familia puede implementar el interface Parlanchin, y se podrá pasar un objeto de dicha clase a la función hazleHablar. Esta es la razón por la cual los interfaces proporcionan más polimorfismo que el que se puede obtener de una simple jerarquía de clases.

6.9.3 Implemente una llamada Forma de la cual se deriven la clase Círculo, la clase Cuadrado y la Clase Triangulo. Implemente el método de Dibujar y el Método de borrar en cada una. Utilice polimorfismo.



6.10 Ejercicios Propuestos 6.10.1 Modificar el ejercicio 6.9.3 en el apartado de problemas resueltos, creando una nueva clase denominada pentágono que herede de Forma y que sobrecargue los métodos dibujar y borrar. Compilar y ejecutar. 6.10.2 Crear una interfaz llamado Manejo que contenga los métodos dibujar y borrar y modificar el ejercicio anterior para que la clase Forma implemente el interfaz manejo. 6.10.3 Implementar una clase que se llame Perro y que tenga un método sobrecargado llamado ladrido. Sobrecárgalo de tal manera que el tipo de parámetro determine el tipo de ladrido. Exteriorizar el tipo de ladrido con un mensaje. Dentro del programa principal llamar al método ladrido con diferentes parámetros. 6.10.4 Implementar una jerarquía Empleado de cualquier tipo de empresa que le sea familiar. La jerarquía debe tener al menos cuatro niveles, con herencia de miembros de dato, y métodos. Los métodos deben poder calcular salarios, despidos, promoción, dar de alta jubilación etc. Los métodos también deben poder calcula aumentos salariales y primas para Empleados de acuerdo con su categoría y productividad. La jerarquía de herencia debe poder ser utilizada para proporcionar diferentes tipos de acceso a Empleados. 6.10.5 Se requiere realizar una aplicación para que cada profesor de la universidad gestione las fichas de sus alumnos. Un profesor puede impartir una o varias asignaturas y dentro de cada asignatura puede tener distintos grupos de alumnos. Los alumnos pueden ser presénciales o a distancia. Al comenzar las clases, se entrega al profesor un listado con los alumnos por cada asignatura. Escribir un programa de tal forma que el listado de alumnos se introduzca por el teclado y se den de alta calificaciones de exámenes y prácticas realizadas. Se podrán obtener listados de calificaciones una vez realizados los exámenes y porcentajes de aprobados. 6.10.6 Implementar un programa que utilizando polimorfismo implemente la forma de hablar de un ladrón, un ingeniero, un político y un abogado. 6.10.7 Implementar que imprima los diferentes sonidos de los instrumentos musicales: Guitarra, saxogon, piano, Guzla y Ukele. Asígnele una frase a cada instrumento que represente el sonido. Utilice polimorfismo.

Unidad VII. Excepciones


UNIDAD VII. EXCEPCIONES

Definición, Gestión, Tipos, Manejo y Lanzamiento de Excepciones Definidas por el

Lenguaje y Definidas por el Usuario



UNIDAD VII. EXCEPCIONES

7.1 Definición

7.1.1 ¿Qué son las Excepciones? Una excepción es la indicación de un problema que ocurre durante la ejecución de un programa. El nombre “excepción” viene del hecho del que, aunque puede ocurrir un problema, este ocurre con poca frecuencia, si la “regla” es que una instrucción generalmente se ejecuta en forma correcta, entonces la “excepción a la regla” es cuando ocurre un problema. El manejo de excepciones permite a los programadores crear aplicaciones que puedan resolver (o manejar) las excepciones. En muchos casos, el manejo de una excepción permite que el programa continúe su ejecución como si no se hubiera encontrado el problema. Un problema más grave podría evitar que el programa continuara su ejecución normal en vez de requerir al programa que notifique al usuario sobre el problema antes de terminar de una manera controlada. A diferencia de otros lenguajes de programación orientados a objetos como C/C++, Java incorpora en el propio lenguaje la gestión de errores. El mejor momento para detectar los errores es durante la compilación. Sin embargo prácticamente sólo los errores de sintaxis son detectados durante este periodo. El resto de problemas surgen durante la ejecución de los programas. En el lenguaje Java, una Exception es un cierto tipo de error o una condición anormal que se ha producido durante la ejecución de un programa. Algunas excepciones son fatales y provocan que se deba finalizar la ejecución del programa. Algunos ejemplos de datos anormales son; Intentar manejar archivos que no existen, accesos no legales en arrays y operaciones aritméticas ilegales como una división por cero. Cuando surge una condición excepcional, se crea un objeto que representa esta excepción y se lanza método que ha causado el error. Este método puede escoger entre gestionar el mismo la excepción o pasarla. De cualquiera de las dos maneras, en un punto determinado, se cazará la excepción y se procesará. Las excepciones pueden generarse por el intérprete de Java o de forma manual por el propio código. Normalmente, las excepciones generadas por Java están relacionadas con errores fundamentales que violan las reglas del lenguaje Java o las restricciones del entorno de ejecución Java. Las excepciones generadas de forma manual se utilizan, generalmente, para informar acerca de alguna condición de error en la parte del código que llama al método. En todos los casos donde surgen excepciones es recomendable terminar ordenadamente y dar un mensaje explicando el tipo de error que se ha producido. Otras, como por ejemplo no encontrar un fichero en el que hay que leer o escribir algo, pueden ser recuperables. En este caso el programa debe dar al usuario la oportunidad de corregir el error(indicando una nueva localización del archivo no encontrado). Un buen programa debe gestionar correctamente todas o la mayor parte de los errores que se pueden producir.



7.1.2 Clases de Excepciones Predefinidas por el Lenguaje Todos los tipos de excepciones son subclases de la clase Throwable64, incorporada en Java. Por lo tanto, Throwable ocupa el primer puesto en la jerarquía de clases de excepciones. Inmediatamente después se encuentran dos subclases que dividen las excepciones en dos grupos. Uno de estos grupos están encabezados por Exception, esta clase se utiliza para las condiciones excepcionales que los usuarios de los programas deben capturar, también es la clase de la que derivan las subclases necesarias para crear los tipos propios de las excepciones, existe una importante subclase de Exception, llamada RuntimeException. Las excepciones de este tipo se dignen se definen de forma automática por los programas que se escriben e incluyen aspectos como la división por cero, la utilización de un índice un arreglo no válido. El otro grupo esta encabezado por Error, que define las excepciones que no se espera que el programa pueda capturar en circunstancias normales. En intérprete Java utiliza las excepciones de tipo Error para indicar los errores relacionados con el momento de la ejecución, el desbordamiento de la pila es un ejemplo de este tipo de error.

Las excepciones predefinidas por la implementación actual del lenguaje Java y su jerarquía interna de clases son las que se representan en el esquema de la figura 13 que aparece a continuación:

Figura 13 Jerarquía de las clases de excepciones.

64 La clase Throwable es la clase base de las excepciones.



Los nombres de las excepciones indican la condición de error que representan. Las siguientes son las excepciones predefinidas más frecuentes que se pueden encontrar:

ArithmeticException

Las excepciones aritméticas son típicamente el resultado de división por 0:

int i = 12 / 0;

NullPointerException

Se produce cuando se intenta acceder a una variable o método antes de ser definido:

IncompatibleClassChangeException

El intento de cambiar una clase afectada por referencias en otros objetos, específicamente cuando esos objetos todavía no han sido recompilados.

ClassCastException

El intento de convertir un objeto a otra clase que no es válida.

y = (Prueba)x; // donde x no es de tipo Prueba

NegativeArraySizeException

Puede ocurrir si hay un error aritmético al cambiar el tamaño de un array.

OutOfMemoryException

¡No debería producirse nunca! El intento de crear un objeto con el operador new ha fallado por falta de memoria. Y siempre tendría que haber memoria suficiente porque el garbage collector se encarga de proporcionarla al ir liberando objetos que no se usan y devolviendo memoria al sistema.

NoClassDefFoundException

Se referenció una clase que el sistema es incapaz de encontrar.

ArrayIndexOutOfBoundsException

class Hola extends Applet { Image img; paint( Graphics g ) { g.drawImage( img,25,25,this ); } }



Es la excepción que más frecuentemente se produce. Se genera al intentar acceder a un elemento de un array más allá de los límites definidos inicialmente para ese array.

UnsatisfiedLinkException

Se hizo el intento de acceder a un método nativo que no existe. Aquí no existe un método

y se llama a a.kk(), cuando debería llamar a A.kk().

InternalException

Este error se reserva para eventos que no deberían ocurrir. Por definición, el usuario nunca debería ver este error y esta excepción no debería lanzarse.

El compilador Java obliga al programador a proporcionar el código de manejo o control de algunas de las excepciones predefinidas por el lenguaje. Por ejemplo, el siguiente programa, no compilará porque no se captura la excepción InterruptedException que puede lanzar el método sleep() 65.

Código 7.1.2.1 En el ejemplo no se captura la Excepción InterruptedException, por lo tanto no se compilará.

Este es un programa muy simple, que al intentar compilar, producirá el siguiente error de compilación que se visualizará en la pantalla tal como se reproduce a continuación:

65 Dormir.



% Javac Java701.java Java701.java:41: Excepcion java.lang.InterruptedException debe ser tomada, o debe ser debe ser declarada en la cláusula throws de este método. Thread.currentThread().sleep( 1000 ); // currentThread() genera

Como no se ha previsto la captura de la excepción, el programa no compila. El error identifica la llamada al método sleep() como origen del problema. Así que, la siguiente versión del programa, Java903.java, soluciona el problema generado por esta llamada.

Código 7.1.2.1 En este programa se resuelve el problema del código anterior, se implementa la excepción por lo tanto ya se compilará.

Lo único que se ha hecho es indicar al compilador que el método miMetodo() puede lanzar excepciones de tipo InterruptedException. Con ello se consigue propagar las excepción que genera el método sleep() al nivel siguiente de la jerarquía de clases. Es decir, en realidad no se resuelve el problema sino que se está pasando a otro método para que lo resuelva él.

En el método main() se proporciona la estructura que resuelve el problema de compilación, aunque no haga nada, por el momento. Esta estructura consta de un bloque try y un bloque catch, que se puede interpretar como que intentará ejecutar el código del bloque try y si hubiese una nueva excepción del tipo que indica el bloque catch, se ejecutaría el código de este bloque.

La transferencia de control al bloque catch no es una llamada a un método, es una transferencia incondicional, es decir, no hay un retorno de un bloque catch.



7.1.3 Propagación de Excepciones Cuando un método lanza una excepción, quiere decir que detecta que se ha producido una situación anómala, pero no sabe que hacer con ella. En ese caso, el método lanza la excepción y termina, propagando la excepción al método que le llamó, que quizá sepa qué hacer en ese caso. Las excepciones se propagan por todos los métodos de la pila de llamadas, hasta que se encuentre un método que la gestione.

Código 7.1.3.1 Propagación de excepciones.

La propagación de excepciones se da como lo muestra la figura 14.

Figura 14: Propagación de excepciones.



main (de PedirNumero) readLine (de BufferedReader) Lanza IOException Se produce la excepción Termina la ejecución Se relanza (se podría haber capturado)

7.2 Gestión de Excepciones Excepciones No Capturadas Antes de aprender a gestionar las excepciones en el programa, será útil ver que ocurre cuando no se gestiona en absoluto. Este programita incluye una excepción que, de forma intencionada provoca un error debido al la división entre ceo.

Código 7.2.1 Se provoca una excepción intencional debido a la división

entre cero. Cuando el intérprete Java detecta un intento de división entre cero, construye un nuevo objeto de excepción y luego lanza esa excepción, esto provoca que la ejecución de Exc0 se detenga. Porque una vez que la excepción se ha lanzado, ha de cazarse con un gestor de excepciones y tratarse de forma inmediata., en este ejemplo no se han proporcionado gestores de excepciones, de manera que la excepción se ha capturado por el gestor por defecto que proporciona el intérprete Java, cualquier excepción que no el programa cace, será, en última instancia, procesada por el gestor por defecto, que representa un mensaje que describe la excepción, imprime el trazado de la pila y concluye el programa. Aquí se tiene la excepción que se genera cuando el programa se ejecuta. Java.lang.ArithmeticException: //por cero en Exc0.main(Exc0.java 4) Obsérvese como el nombre de clase, Exc0; el nombre de método, main; el nombre del archivo, exc0.java; y el número de línea 4, se incluye en el trazado simple de la pila. Obsérvese también, que el tipo de excepción lanzada, denominada ArithmeticException, describe de manera más específica el tipo de error que se ha producido. Java proporciona bastantes tipos de excepciones que se ajustan a las distintas clases de errores de momento de ejecución que se pueden generar. El trazado de la pila siempre mostrará la secuencia de llamadas a métodos que preceden al error. Por ejemplo, aquí se presenta otra versión del programa anterior que introduce el mismo error pero en un método distinto de main():



El trazado de la pila que resulta del gestor de excepciones por defecto muestra la pila de llamadas completa: java.lang.ArithmeticException: / by zero at Exc1.subroutine(Exc1.java:4) at Exc1.main(exc1.java:7) Como puede verse, el final de la pila es línea 7 de main, que es donde se llama al método subroutine(), que provoca la excepción en la línea 4. La pila de llamadas es muy útil para la depuración porque muestra la secuencia exacta de pasos que condujo al error.

7.2.1 Manejo de Excepciones La lógica del programa evalúa frecuentemente condiciones que determinan cómo debe proceder la ejecución del programa. Considérese el siguiente seudocódigo.

Figura 15 Manejo de Excepciones. En este seudocódigo se empieza realizando una tarea; después, se evalúa si esa tarea se ejecutó correctamente. Si no lo hizo, se realiza el procesamiento de los errores. De otra manera, se continúa con la siguiente tarea. Aunque esta forma de manejo de errores funciona, al entremezclar la lógica del programa con la lógica del manejo de errores podría ser difícil de leer, mantener y depurar; especialmente en aplicaciones extensas. De hecho si los problemas potenciales ocurren con poca frecuencia, al entremezclar la lógica del



programa y la lógica del manejo de errores se puede degradar el rendimiento del programa, ya que este debe evaluar la lógica del manejo de errores para determinar si se puede llevar acabo la siguiente tarea. El manejo de excepciones permite al programador remover el código para el manejo de errores de la “línea principal” de ejecución del programa, lo cual mejora la claridad y capacidad de modificación del mismo. Los programadores pueden optar por manejar las excepciones que elijan: todas las excepciones, todas las excepciones de cierto tipo o todas las excepciones de un grupo de tipos relacionados 66. Esta flexibilidad reduce la probabilidad de que los errores se pasen por alto y, por consecuencia, hace que un programa sea más robusto. El manejo de excepciones está diseñado para procesar errores sincrónicos, que ocurren cuando se ejecuta una instrucción. Ejemplos comunes de estos errores son los índices fuera de rango, el desbordamiento aritmético (es decir, un valor fuera de rango representable de valores), la división entre cero, los parámetros inválidos de método, la interrupción de subprocesos y la asignación fallida de memoria (debido a la falta de ésta). El manejo de excepciones no esta diseñado para procesar los problemas asociados con los eventos asíncronos 67. los cuales ocurren en paralelo con, y en forma independiente de flujo de control del programa. Con lenguajes de programación que no soportan el manejo de excepciones, los programadores a menudo retrasan la escritura de código de procesamiento de errores, o algunas veces olvidan incluirlo. Esto hace que los productos de software sean menos robustos. Java permite al programador tratar con el manejo de excepciones fácilmente, desde el comienzo de un proyecto. Sin embargo, el programador debe incorporar una estrategia de manejo de excepciones en los proyectos de software. El mecanismo de manejo excepciones también es útil para procesar los problemas que ocurren cuando un programa invoca a los métodos de otras clases. En vez de manejar los problemas internamente, dichos métodos utilizan por lo común excepciones para notificar a los métodos que hacen las llamadas cuando ocurren los problemas. Esto permite a los programadores implementar un manejo de errores personalizado para cada aplicación. Las aplicaciones complejas normalmente consisten de componentes predefinidos de software y de componentes específicos para cada aplicación. Cuando un componente predefinido se encuentra con un problema, ese componente necesita de un mecanismo para comunicar el problema al componente específico de la aplicación: el componente predefinido no puede saber de antemano cómo procesa cada aplicación cierto problema ocurrido. El manejo de excepciones simplifica la combinación de componentes de software y les permite trabajar efectivamente, al permitir que los componentes predefinidos comuniquen los problemas a los componentes específicos de la aplicación, los cuales podrán entonces procesar los problemas de una manera especifica para cada aplicación. El manejo de excepciones esta dirigido a situaciones en las que el método que detecta un problema es incapaz de manejarlo. Dicho método lanza una excepción. No hay garantía de que habrá un manejador de excepciones (código que se ejecuta cuando el programa

66 Por ejemplo, los tipos de excepciones que pertenecen a una jerarquía de herencia. 67 Por ejemplo, completar las operaciones de E/S de disco, la llegada de mensajes de red, clics del ratón y pulsaciones de teclas.



detecta una excepción) para procesar este tipo de excepción. Si existe, el manejador de excepciones atrapa y maneja a esa excepción. El resultado de una excepción no atrapada a menudo produce efectos adversos y podría terminar con la ejecución del programa. Java proporciona las instrucciones try para permitir el manejo de excepciones. Una instrucción try consiste de la palabra clave try, seguida por llaves ({}) que delimitan a ese bloque try. El bloque try contiene instrucciones que podrían ocasionar excepciones, e instrucciones que no deberían ejecutarse en caso de que ocurra una instrucción. Debe haber por lo menos una cláusula catch (a la que también se le llama manejador de excepciones) o una cláusula finally inmediatamente después del bloque try. Cada cláusula catch específica entre paréntesis un parámetro de excepción, el cual identifica al tipo de excepción que puede procesar el manejador. El nombre del parámetro de excepción permite que la cláusula catch interactúe con un objeto de excepción atrapada. Después del último manejador catch, una clausula finally opcional proporciona código que siempre se ejecuta, sin importar que ocurra o no una excepción. El punto en el programa en que ocurre una excepción (es decir, la ubicación en la que un método detecta y lanza una excepción) se conoce como el punto de lanzamiento. Si ocurre una excepción en un bloque try, ese bloque termina inmediatamente y el control del programa se transfiere a la primer cláusula catch que vaya después del bloque try. Esto se conoce como modelo de terminación del manejo de excepciones, ya que el bloque try que encierra a una excepción lanzada termina al ocurrir esa excepción. Al igual que con cualquier otro bloque de código, cuando termina un bloque try las variables locales que estén declaradas en el bloque quedan fuera de alcance. A continuación, el programa busca la primera cláusula catch que puede procesar el tipo de excepción que ocurrió. El programa ubica la cláusula catch que concuerde, comparando el tipo de la excepción lanzada con el tipo de parámetro de excepción de cada cláusula catch, hasta que el programa encuentre una concordancia. La concordancia ocurre si los tipos son idénticos, o si el tipo de la excepción lanzada es una subclase del tipo de parámetro de excepción, cuando ocurre una concordancia, se ejecuta el código contenido dentro del manejador catch concordante. Cuando una cláusula catch termina de procesarse, las variables locales que se declaran dentro de la cláusula (incluyendo su parámetro) quedan fuera de alcance. Cualquier cláusula catch restante que corresponda a ese bloque try se ignora, y la ejecución continúa en la primera línea de código después de la secuencia try/catch. Si no ocurren excepciones en un bloque try, el programa ignora el (los) manejador(es) para ese bloque. La ejecución del programa continúa con la siguiente instrucción que haya después de la secuencia try/catch. Si aparece una cláusula finally después de la última cláusula catch, la cláusula finally se ejecutará sin importa que ocurra o no una excepción. Si ocurre una excepción en un método y no es atrapada, o la instrucción que produjo la excepción no se encuentra dentro de un bloque try, hace que termine inmediatamente y el programa trata de localizar un bloque try circundante en el método que hizo la llamada. En la declaración de un método, una cláusula throws específica las excepciones que lanza ese método. Esta cláusula aparece después de la lista de parámetros y antes del cuerpo del método. La cláusula contiene una lista separada por comas de las excepciones que lanzará el método, si ocurre un problema cuando éste se ejecute- dichas excepciones pueden ser lanzadas por instrucciones en el cuerpo del método, o pueden lanzarse



mediante los métodos que se llamen en el cuerpo. Un método puede lanzar excepciones de clases indicadas, o puede lanzar excepciones de sus subclases. Ejemplo de manejo de excepciones - Error de División entre Cero. Para evitar esta situación y gestionar un error de tiempo de ejecución, sencillamente hay que incluir el código que quiera controlar dentro de un bloque try. Inmediatamente después del bloque try, se incluye la cláusula match que especifica el tipo de excepción que se desea capturar. Para mostrar como puede hacerse esto de forma sencilla, el siguiente programa incluye un bloque try y una cláusula match que procesa la excepción ArithmeticException generada por el error debido a la división entre cero.

Código 7.2.1.1. Error de división entre cero. Este programa genera la siguiente salida: División entre cero. Después de la sentencia Catch. Nótese que la llamada a println() dentro del bloque try no llega a ejecutarse. Una vez que se lanza una excepción. Por lo tanto, no aparece en pantalla la línea “Esto no será impreso”. Una vez que se ejecuta la sentencia catch, el control del programa continua con la siguiente línea al bloque try/catch. Un bloque try y su correspondiente sentencia catch forman una unidad. El campo de acción de una cláusula catch se limita a aquellas sentencias especificadas por la sentencia try que le precede inmediatamente. Una sentencia catch no puede capturar una ejecución lanzada por otra sentencia try, excepto en el caso de las sentencias try anidadas. Las sentencias protegidas por try han de estar entre llaves, es decir han de estar en un bloque no puede usarse try en una sentencia individual.



El objetivo de la mayoría de cláusulas catch bien construidas ha de ser el de resolver la condición excepcional y luego continuar como si el error nunca hubiese ocurrido. Por ejemplo, en el siguiente programa cada iteración de bloque for obtiene dos enteros aleatorios. Estos dos enteros se dividen uno entre el otro, y el cociente se utiliza como divisor del valor 12345. El resultado final se almacena en la variable a. si en cualquiera de las dos operaciones se produce una división entre cero, se captura el error, el resultado se pone a cero y el programa continua.

Código 7.2.1.2 Manejo de excepciones.

7.2.1 Lanzamiento de Excepciones

El lanzamiento de las excepciones se hace con las palabras try – catch – finally Try

Es el bloque de código donde se prevé que se genere una excepción. Es como si se dijera "intenta estas sentencias y mira a ver si se produce una excepción". El bloque try tiene que ir seguido, al menos, por una cláusula catch o una cláusula finally.

Catch

Es el código que se ejecuta cuando se produce la excepción. Es como si se dijera "controlo cualquier excepción que coincida con mi argumento". En este bloque se tiene que asegurar de colocar código que no genere excepciones. Se pueden colocar sentencias catch sucesivas, cada una controlando una excepción diferente. No debería intentarse capturar todas las excepciones con una sola cláusula, como esta:



catch( Excepcion e ) { ... Esto representaría un uso demasiado general, podrían llegar muchas más excepciones de las esperadas. En este caso es mejor dejar que la excepción se propague hacia arriba y dar un mensaje de error al usuario.

Se pueden controlar grupos de excepciones, es decir, que se pueden controlar, a través del argumento, excepciones semejantes. Por ejemplo:

Código 7.2.1.3 Control de exepciones

La cláusula catch comprueba los argumentos en el mismo orden en que aparezcan en el programa. Si hay alguno que coincida, se ejecuta el bloque. El operador instanceof se utiliza para identificar exactamente cual ha sido la identidad de la excepción.

Finally

Es el bloque de código que se ejecuta siempre, haya o no excepción. Hay una cierta controversia entre su utilidad, pero, por ejemplo, podría servir para hacer un log o un seguimiento de lo que está pasando, porque como se ejecuta siempre puede dejar grabado si se producen excepciones y se ha recuperado de ellas o no.



Este bloque finally puede ser útil cuando no hay ninguna excepción. Es un trozo de código que se ejecuta independientemente de lo que se haga en el bloque try.

Cuando se va a tratar una excepción, se plantea el problema de qué acciones se van a tomar. En la mayoría de los casos, bastará con presentar una indicación de error al usuario y un mensaje avisándolo de que se ha producido un error y que decida si quiere o no continuar con la ejecución del programa.

Para lanzar una excepción se tienen que hacer dos cosas como mínimo. La primera es crear el objeto que se va a lanzar, la segunda, lanzar el objeto. Para realizar esto se crea una instancia de un objeto perteneciente a la jerarquía de java.lang.Throwable, luego se utiliza la instrucción throw para lanzar el objeto.

Normalmente esta tarea se realiza en una sola línea ya que al lanzar el objeto se crea información para que la excepción sea reportada y es conveniente que la línea que se reporta como origen de la excepción sea la misma donde se lanza. La siguiente es un ejemplo de esto:

throw new IOException("No se encuentra el archivo");

Java requiere, como regla general que todo método que pueda lanzar una excepción debe declarase específicamente, no importa si es explícitamente lanzada por el método o por un método que fue llamado. Para realizar esto se utiliza la instrucción throws en la declaración del método de la siguiente forma:

public void dividir(int x, int y) throws ArithmeticException, IOException { }

La jerarquía de clases que existe bajo la clase java.lang.Throwable esta dividida en tres partes. Una parte, java.lang.Error contiene excepciones que se utilizan para indicar errores, java.lang.Exception que contiene las llamadas excepciones de verificación y java.lang.RuntimeException que es subclase de java.lang.Exception y agrupa las llamadas excepciones en tiempo de ejecución que son siempre por errores de programación.

Las excepciones de verificación describen los problemas que pueden darse en un programa, típicamente, dificultades con el ambiente como problemas de conexión con la red. En un programa comercial se debe escribir código que pueda manejar y recuperarse de estas excepciones. De hecho, el compilador verifica que se estén manejando estas excepciones por lo que entrega un mensaje de error en tiempo de compilación si alguna no esta manejada.

Las excepciones en tiempo de ejecución típicamente describen errores de programa como índices fuera de rango, aquellas que con un código correctamente escrito normalmente no es necesario manejar. Lógicamente no se deberían de manejar errores que no deberían de sucederse.



java.lang.Error describe problemas que son muy inusuales y por lo tanto de difícil recuperación por lo tanto no se requiere que se manejen. Estos reflejan un error de programa o problemas de ambiente como puede ser la memoria agotada.

Una estrategia de diseño e implementación de programa que es muy efectiva a la hora de producir código robusto y confiable es programar por contrato. Usando esta estrategia se definen las responsabilidades de los métodos y de aquellos que llaman a esos métodos. En un método dividir se puede requerir que el divisor sea distinto de cero, en caso contrario se lanza una excepción dado que el contrato entre el método que llama y el llamado se ha roto. Para este tipo de mensajes se deben utilizar excepciones de tiempo de ejecución ya que la llamada claramente es inapropiada y el que realiza la llamada debe verificar estos errores de programación y corregirlos.

Para manejar una excepción de verificación se debe decidir que hacer con ella. Se puede colocar un bloque try/catch para tratar de recuperarse o decidir que el método debe ser abandonado cuando se sucede la excepción. En este último caso no es necesario utilizar try/catch pero si hay que especificar que excepción será lanzada utilizando throws en la declaración del método.

Cuando se extiende una clase y se sobrecarga un método el compilador insiste en que todas las excepciones lanzadas por el nuevo método deben ser las mismas o subclases de las lanzadas por el método original. De la misma forma no puede lanzar ninguna excepción que no sea subclase de la excepción declarada en la clase base.

7.3 Excepciones Definidas por el Usuario

7.3.1 Clase Base de las Excepciones Todas las excepciones que se lanzan en Java están consideradas en el árbol de excepciones que se deriva de la clase Throwable. Por lo cual la clase Throwable es considerada la clase base de las excepciones. Existen dos subclases directas de Throwable: Error y Exception. Los objetos de la clase Error provocan que el intérprete de Java presente un mensaje de información y concluya la ejecución del programa. Los objetos de la clase Exception indican condiciones anómalas durante la ejecución de un método. Esta clase tiene, a su vez, nueve subclases predefinidas. Las clases de excepciones definidas por el programador se construyen como subclases de la clase Exception. En la siguiente figura 16 se observa parte de la jerarquía de clases derivada de Throwable: La clase Error está relacionada con errores de la máquina virtual de Java y no el código, generalmente estos errores no dependen del programador por lo que no debe preocuparse por tratarlos. En la clase Exception se encuentran las excepciones RuntimeException, producidas por errores de programación. El compilador de Java obliga a corregirlas.



Figura 16: Clase base de la clase Throwable.

Como se puede ver en la figura 16, la clase Throwable tiene dos descendientes directos: Error y Exception. - Error Cuando falla un enlace dinámico, y hay algún fallo "hardware" en la máquina virtual, ésta lanza un error. Tipicamente los programas Java no capturan los Errores. Pero siempre lanzarán errores. - Exception La mayoría de los programas lanzan y capturan objetos derivados de la clase Exception. Una Excepción indica que ha ocurrido un problema pero que el problema no es demasiado serio. La mayoría de los programas que se escriben lanzarán y capturarán excepciones. La clase Exception tiene muchos descendientes definidos en los paquetes Java. Estos descendientes indican varios tipos de excepciones que pueden ocurrir. Por ejemplo, IllegalAccessException señala que no se puede encontrar un método particular, y NegativeArraySizeException indica que un programa intenta crear un array con tamaño negativo. Una subclase de Exception tiene un significado especial en el lenguaje Java: RuntimeException. Excepciones en Tiempo de Ejecución La clase RuntimeException representa las excepciones que ocurren dentro de la máquina virtual Java 68(durante el tiempo de ejecución). Un ejemplo de estas excepciones es NullPointerException, que ocurre cuando un método intenta acceder a un miembro de un objeto a través de una referencia nula. Esta excepción puede ocurrir en cualquier lugar en

68 Java Virtual Machine (JVM).



que un programa intente desreferenciar una referencia a un objeto. Frecuentemente el costo de checar estas excepciones sobrepasa los beneficios de capturarlas. Los paquetes Java definen varias clases RuntimeException. Se pueden capturar estas excepciones al igual que las otras. Sin embargo, no se requiere que un método especifique que lanza excepciones en tiempo de ejecución. Además puedes crear sus propias subclases de untimeException. Excepciones en Tiempo de Ejecución -- La Controversia contiene una explicación detallada sobre cómo utilizar las excepciones en tiempo de ejecución.

7.3.2. Creación de una Clase Derivada del Tipo Excepción Aunque las excepciones que incorpora Java gestionan la mayoría de los errores más comunes, es probable que el programador prefiera crear sus tipos de excepciones para gestionar situaciones específicas a sus aplicaciones, esto es bastante sencillo de conseguir definiendo una subclase de Throwable. En realidad, no es necesario que estas subclases que crea el programador implementen nada. simplemente, es su presencia en el sistema lo que permitirá que se utilicen como excepciones. La clase exception no define ningún método por si misma, pero, obviamente, hereda los métodos que proporciona la clase Throwable. Por tanto todas las excepciones, incluyendo aquellas que crea el programador, pueden disponer de métodos definidos por Throwable. Estos métodos, que además pueden sobrescribirse en las clases de excepción propias, se recogen en la tabla siguiente:

Tabla. Métodos definidos por la clase Throwable Método Descripción Throwable Throwable getCause() String getLocalizedMessage() StackTraceElement[] getStack Trace()

Devuelve un objeto de la clase throwable que contiene el trazado completo de la pila Devuelve la excepción que subyace en la excepción actual. Si no hay excepciones subyacentes, se devuelve null Devuelve una descripción localizada de la excepción. Devuelve una descripción de la excepción Devuelve una matriz que contiene el trazado de la pila, un elemento cada vez, y una matriz de StackTraceElement. El primer método de la pila es el último de ser llamado antes de que se lancé la excepción este método se encuentra en el primer elemento de la matriz. La clase StackTraceElement da al programa acceso a la información acerca de cada elemento en el trazado, así como acerca de los nombres de los métodos.



Throwable InitCause (throwable causeExc) void printStackTrace() void printStackTrace (PrintSreamstream) void printDStackTrace (Snack TraceElementselements) String toString()

Asocia causeExc con la llamada a la excepción como causa de la excepción de la llamada. Devuelve una referencia a la excepción Presenta en la pantalla el trazado de la pila Envía el trazado de la pila a flujo determinado Envía el trazado a los elementos pasados en elementos. Este método es para aplicaciones especializadas , no para un uso común Devuelve una cadena con la descripción de la excepción , ese método es llamado como println() cuando se desea imprimir un objeto de la clase throwable.

El siguiente ejemplo declara una nueva subclase de excepcion y luego utiliza esta subclase para señalar una condición de error en un método. Esta subclase sobrescribe el método toString() para permitir que la descripción de la excepción puede impimirse mediante println():



Código 7.3.2.1 Programa que crea un tipo propio de excepción. Este ejemplo define una subclase de Exception, llamada MiExcepcion. Esta subclase es bastante sencilla, sólo contiene un constructor y un método sobrecargado, toString(), que permitirá presentar el valor de la excepción. La clase ExcepcionDemo define un método, llamado compute(), que lanza un objeto del tipo MiExcepcion. La excepción se lanza cuando el parámetro entero de compute() es superior a 10. El método main() establece un gestor de excepciones para MiExcpecion, luego llama a compute() con un valor legal inferior a 10, y con un valor no válido. Para mostrar las dos vías que sigue el código. Este es el resultado: Llamado a compute(1) Salida normal Llamado a compute(20) Agarrada MiExcepcion[20]

7.3.3 Manejo de una Excepción Definida por el Usuario Para el manejo de las excepciones propias, solo se extiende la clase Exception.



Por ejemplo, considérese un programa cliente/servidor. El código cliente se intenta conectar al servidor, y durante 5 segundos se espera a que conteste el servidor. Si el servidor no responde, el servidor lanzaría la excepción de time-out:

Si se quieren capturar las propias excepciones, se deberá utilizar la sentencia try:

Código 7.3.2.Manejo de una excepción definida por el usuario. Sólo se extiende la clase Exception

Cualquier método que lance una excepción también debe capturarla, o declararla como parte del interfaz del método. Cabe preguntarse entonces, el porqué de lanzar una excepción si hay que capturarla en el mismo método. La respuesta es que las excepciones no simplifican el trabajo del control de errores69. Tienen la ventaja de que se puede tener muy localizado el control de errores y no hay que controlar millones de valores de retorno, pero no van más allá.

7.4 Ejercicios resueltos 7.4.1 Implementar un programa que pida un entero y lance una excepción si se teclea una letra o cualquier otro carácter.

69 Aunque muchos desarrolladores de software tienen esa noción.



7.4.2 Implementar un programa que realice una operación de división introduciendo los dos valores desde el teclado y mande una excepción en caso de que uno de los valores no sea numérico o la división de cero.

7.4.3 Implementar un programa que reciba dos parámetros desde la línea de comandos y los sume. Si no se omite alguno de los dos, se manda una excepción.



7.4.4 Implementar un programa realice la división de dos números naturales, si uno de los dos no lo es, que arroje una excepción.



7.5 Ejercicios propuestos: 7.5.1 Escribir un código de una clase Java que lance excepciones para cuantas condiciones considere convenientes. Utilizar una cláusula catch que utilice la sentencia switch para seleccionar el mensaje apropiado y terminar el calculo. Nota. Utilice una jerarquía de clases para listas las condiciones de error. 7.5.2 Escribir un código de un método en el cual se defina un bloque try y dos manejadores catch. En uno de ellos se relanza la excepción. También ha de haber un manejador finally, que lanzara una excepción que relanza el catch, para lo cual, escribir un sencillo programa en que se genere la excepción que es captada por el catch descrito. 7.5.3 Escribir el código de una clase para tratar el error que se produce cuando un argumento de un algoritmo neperiano es negativo. El constructor de la clase tendrá como argumento una cadena y el valor que generado el error. 7.5.4 Escriba un programa Java en el que se genere la excepción del problema anterior, y se capture. 7.5.5 Definir una clase para tratar los errores en el manejo de cadenas de caracteres. A continuación, definir una subclase para tratar el error supuesto de cadenas de longitud mayor de 30 caracteres, y otra subclase que maneje los errores de cadenas que tienen caracteres no alfabéticos. 7.5.6 Escribir un programa java en el que se de entrada a cadenas de caracteres y se capturen excepciones del tipo mencionado en el problema anterior. 7.5.7 Escribir un programa que demuestren como se atrapan las diversas excepciones mediante: catch (Excepction exception) 7.5.8Escriba un programa que demuestre como un constructor pasa información sobre falla del constructor a un manejador de excepciones. 7.5.9 Escribir un programa que demuestre como volver a lanzar una excpecion. 7.5.10 Escriba un programa que demuestre que un método con su propio bloque try no tiene que atrapar cada posble error generado dentro de este bloque try. Algunas excepciones podrían escabullirse y manejarse en otros alcances.

Unidad VIII. Flujos y archivos

Programación orientada a objetos en java 164

UNIDAD 8.FLUJOS Y ARCHIVOS

Definición, Tipos y Operaciones básicas de Archivos



UNIDAD 8.- FLUJOS Y ARCHIVOS

8.1 Definición de archivos de texto y Archivos Binarios

Archivos de texto: Es una estructura de datos permanente no estructurada formada por una secuencia de caracteres ASCII 70. Los archivos de texto son aquellos que están compuestos únicamente por texto sin formato, sólo caracteres. Estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Algunos de los sistemas de codificación más usados son: ASCII, ISO-8859–1 o Latín-1, Unicode, etc. Se les conoce también como archivos de texto plano por carecer de información destinada a generar formatos y tipos de letra (por ejemplo, tipo de letra: Arial, Times, Courier; formato: negritas, subrayado, cursivas; tamaño, etc.). Las aplicaciones destinadas a la escritura y modificación de archivos de texto se llaman editores de texto. La costumbre ha hecho que se nombren con la extensión de archivo .TXT aunque pueden tener cualquier otra, a capricho del usuario (son válidas y habituales .INF .80 .DAT .TMP .PRV .HLP etc.). Los archivos .BAT (o de proceso por lotes), los .HTM y muchos otros son también archivos de texto, que tienen funciones especiales. Archivos binarios: Es una estructura de datos permanente compuesto por registros (filas) y éstos a su vez por campos (columnas). Se caracteriza por tener un tipo de dato asociado, el cual define su estructura interna. Los archivos binarios son archivos electrónicos que han sido guardados utilizando el código básico de las computadoras u ordenadores: una sucesión de ceros y unos. Constituyen, en última instancia, la forma en la cual almacenan la información, aunque su interacción con los usuarios requiere de lenguajes auxiliares que resulten más inteligibles al ser humano.

70 Acrónimo de American Standard Code for Information Interchange (Código Normalizado Americano para el Intercambio de la Información).



8.2 Operaciones Básicas en Archivos de Texto y Binario

8.2.1 Crear Para crear un archivo la sintaxis es: FileWriter nombre_variable = new FileWriter(“Nombre del archivo incluyendo ruta”) Por ejemplo: FileWriter archivo = new FileWriter("c:/prueba.txt"); En el ejemplo anterior se crea un archivo de nombre pureba.txt ubicado en la ruta c:. Si quiere añadir al final de un archivo ya existente, simplemente se debe poner un flag a true como segundo parámetro del constructor de FileWriter FileWriter archivo = new FileWriter("c:/prueba.txt",true); En este ejemplo se añadirán líneas al final del archivo prueba.txt

8.2.2 Abrir La apertura de un archivo se hace con la siguiente sentencia: FileReader nombre_variable = new FileReader(“Nombre del archivo incluyendo ruta”) Por ejemplo: FileReader fr2 = new FileReader("archivo.txt"); Esto es equivalente a: File archi = new File("archivo.txt"); FileReader fr2 = new FileReader(archi); Si a la hora de la apertura no encuentran el archivo indicado, los constructores de FileReader y FileInputStream pueden lanzar la excepción java.io.FileNotFoundException.



8.2.3 Cerrar

public void close() throws IOException

Cierra el stream de entrada. Este método debe invocarse para liberar los recursos71 asociados al stream. Una vez que el stream ha sido cerrado, las operaciones posteriores sobre dicho sfream producirán una exepción IOException. Cerrar un stream previamente cerrado no tiene ningún efecto. La implementación por defecto de close no hace nada.

8.2.4 Lectura y Escritura

Frecuentemente los programas necesitan traer información desde una fuente externa o enviar información a una fuente externa. La información puede estar en cualquier parte, en un archivo, en disco, en algún lugar de la red, en memoria o en otro programa. También puede ser de cualquier tipo: objetos, caracteres, imágenes o sonidos.

Para traer la información, un programa abre un stream sobre una fuente de información (un archivo, memoria, un socket) y lee la información serialmente, de esta forma:

Similarmente, un programa puede enviar información a un destino externo abriendo un stream sobre un destino y escribiendo la información serialmente, de esta forma:

No importa de donde venga o donde vaya la información y tampoco importa el tipo de los datos que están siendo leídos o escritos, los algoritmos para leer y escribir son casi siempre los mismos.

Leer Escribir abrir un stream mientras haya información leer información cerrar el stream

abrir un stream mientras haya información escribir información cerrar el stream

71 Como los descriptores de archivos.

Fuente Programa

Flujo

Fuente

Destino

Flujo

Lectura

Escritura



El paquete java.io contiene una colección de clases stream que soportan estos algoritmos para leer y escribir. Estas clases están divididas en dos árboles basándose en los tipos de datos (caracteres o bytes) sobre los que opera.

Sin embargo, algunas veces es más conveniente agrupar las clases basándose en su propósito en vez en los tipos de datos que lee o escribe. Así, se pueden agrupar los streams dependiendo de si leen u escriben lados en las "profundidades" o procesan la información que está siendo leída o escrita.

InputStream

La clase abstracta InputStream declara métodos para leer bytes de una fuente particular InputStream es la superclase de la mayoría de los streams de bytes de entrada en java y tiene los siguientes métodos:

public abstract int read() throws IOException Lee un solo byte de datos y devuelve el byte leído como un valor entero en el intervalo de O a 255, no de -128 a 127. En otras palabras, el valor del byte se trata como un entero sin signo. Si no hay un byte disponible debido a que se ha alcanzado el final del stream, se devuelve el valor -1. Este método se bloquea hasta que haya entrada disponible, se encuentre el final del stream o se lance una excepción. Se devuelve un int en vez valor de byte real porque se necesita devolver todos los valores de byte válidos, Más un indicador de final de stream. Para ello se requieren más valores de los que puede permitir un byte, por lo que se usa el tipo mayor de int.

Caída de flujo de datos

Flujo de caracteres Flujo de bytes

Flujo de caracteres Flujo de bytes

Procesando flujos



public int read(byte[] buf, int despl, int cuenta) throws IOException

Lee bytes y los almacena en una parte de un array de byte. El máximo número de bytes que se leen es cuenta. Los bytes se almacenan desde buf [despl] hasta un máxima buf [despl +cuenta-1 ]. Todos los demás valores de buf se dejan inalterados. Se devuelve el número de bytes que se han leído realmente. Si no se leen bytes debido a que se detectado el final del stream, se devuelve el valor -1. Si cuenta vale cero, no se leen bytes y se devuelve cero. Este método se bloquea hasta que haya entrada disponible, se alcance el final del stream o se lance una excepción. Si no se puede leer el primer byte, una razón diferente a la de detectar el final del stream (Por ejemplo, stream ya ha sido cerrado), se lanza una excepción IOException. Una vez que se ha leído el byte, cualquier fallo posterior al tratar de leer bytes subsecuentes no se indica con una excepción, sino que se trata como si se encontrara el final del stream: el método se completa normalmente y devuelve el número de bytes leídos antes de que se produjera el fallo.

public int read(byte[] buf) throws IOException

Es equivalente a read (buf, 0, buf .length).

public long skip(long cuenta) throws IOException Salta un máximo de cuenta bytes de la entrada, o hasta que se detecte el final del stream. Devuelve el número real de bytes que se han saltado. Si cuenta es negativo, no se salta ningún byte.

public int available() throws IOException Devuelve el número de bytes que se pueden leer (o saltar) sin bloquearse. La implementación por defecto devuelve cero.

public void close() throws IOException Cierra el stream de entrada. Este método debe invocarse para liberar los recursos (Como los descriptores de archivos) asociados al stream. Una vez el stream ha sido cerrado, las operaciones posteriores sobre dicho stream producirán una excepción IOException. Cerrar un stream previamente cerrado no tiene ningún efecto. La implementación por defecto de close no hace nada.

La implementación de InputStream requiere sólo que una subclase proporcione la variante de un solo byte de read, ya que los otros métodos read se definen en función de aquélla. La mayoría de los Streams, sin embargo, pueden mejorar las prestaciones redefiniendo también otros métodos. Las implementaciones por defecto de available y close necesitan generalmente ser redefinidas para adecuarlas a un stream particular.

El programa siguiente muestra el uso de streams de entrada para contar el número total de bytes de un archivo, o de System.in si no se especifica ningún archivo:



Código 8.2.4.1 Programa que toma un archivo de la línea de comandos y

cuenta los bytes. El programa toma un nombre de archivo de la línea de comandos. La variable in representa el stream de entrada. Si no se proporciona un nombre de archivo, se utiliza el stream de entrada estándar, System.in. Si se proporciona, se crea un objeto FilelnputStream, una subclase de InputStream. El ciclo72 while cuenta el número total de bytes del archivo. Al final, se imprime el resulta-do. Ésta es la salida cuando el programa se ejecuta sobre su propio archivo fuente: • •

318 bytes

Se podría estar tentado de obtener el total utilizando el método available, pero esto no funcionaría con muchos tipos de streams. El método available devuelve el número de bytes que se pueden leer sin bloqueo. En el caso de un archivo, el número de bytes disponibles es generalmente su contenido total. Pero si System.in está asociada a un teclado, la respuesta podría ser incluso cero, ya que si no hay entrada pendiente el siguiente read se bloqueará. OutputStream

La clase abstracta OutputStream es análoga a InputStream. Proporciona una abstracción para escribir bytes en un destino. Sus métodos son:

public abstract void write(int b) throws IOException

Escribe b como un byte. Este byte se pasa como un int porque a menudo es el resultado de una operación aritmética sobre un byte. Las expresiones que involucran bytes son de tipo int, por lo que hacer que el parámetro sea int significa que el resultado puede pasar a byte sin realizar una conversión explícita de tipo. Nótese, sin embargo. Que sólo se escriben los 8 bits de menor peso del int. Este método se bloquea hasta que el byte se escribe.

72 Ciclo.



public void write(byte[] buf, int despl, int cuenta) throws IOException Escribe parte de un array de bytes, empezando en buf [despl], y escribiendo cuenta bytes. Este método se bloquea hasta que los bytes han sido escritos.

public void write(byte[] buf) throws IOException

Equivale a write (buf, 0, buf .length)

public vaid flush() throws IOException

Vacía el stream. Si el stream tiene bytes en buffers correspondientes a varios métodos. write, flush los envía inmediatamente a su destino. Si el destino es otro stream, también se vacía. Una sola invocación a flush vaciará todos los streams de una cadena. Si el stream no es buffered, puede ocurrir que flush no haga nada (que es su implementación por defecto). • •

public void close() throws IOException Cierra el stream de salida. Este método se debe invocar para liberar los recursos (como los descriptores de archivos) asociados al stream. Una vez que un stream ha sido cerrado, las operaciones posteriores sobre el mismo harán que se lance una IOException. Cerrar un stream previamente cerrado no tiene ningún efecto. La implementación por defecto de close no hace nada.

La implementación de OutputStream requiere sólo que una subclase proporcione la va-riante de un solo byte de write, ya que los otros métodos write se definen en términos de aquélla. La mayoría de los streams, sin embargo, pueden mejorar sus prestaciones redefiniendo también otros métodos. Las implementaciones por defecto de flush y close necesitarán generalmente ser redefinidas de forma apropiada para cada stream particular. Concretamente, por ejemplo, puede ser necesario vaciar los streams buffered cuando se cierran.

Se presenta seguidamente un programa que copia su entrada en su salida, transformando un valor particular de byte en otro por el camino. El programa TransformarByte toma dos parámetros: un byte desde y un byte hacia los bytes que coinciden con el valor en la cadena de texto.

Código 8.2.4.2 Programa que toma dos parámetros, un byte desde y un byte

hacia.



Por ejemplo, si se invoca al programa de la siguiente forma:

java TransformarByte b B

Si se tecleara el texto ¡abracadabra!, se obtendría como salida

¡aBracadaBra!

El manejo de datos de un stream después de leerlo, o antes de escribirlo, se realiza generalmente escribiendo streams Filter, en lugar de codificar directamente dicho manejo en un programa. •

Como en el caso de streams de bytes, los streams de caracteres se deben cerrar explícita-mente para liberar sus recursos asociados.

Reader73

La clase abstracta Reader proporciona un stream de caracteres análogo al stream de bytes InputStream, y los métodos de Reader son esencialmente un reflejo de los de InputStream:

public int read() throws IOException

Lee un solo carácter y lo devuelve como un valor entero en el intervalo de O a 65535. Si no hay un carácter disponible debido a que se ha alcanzado el final del stream. Se de-vuelve el valor -1. Este método se bloquea hasta que haya entrada disponible, se en-cuentre el final del stream o se lance una excepción.

public abstract int read(char[l buf, int despl, int cuenta) throws IOException

Lee caracteres y los almacena en una parte de un array de char. El máximo número de caracteres que se leen es cuenta. Los caracteres leídos se almacenan desde buf [despl] hasta un máximo de buf[despl+cuenta-1]. Todos los demás valores de buf se dejan inalterados. Se devuelve el número de caracteres que se han leído realmente. Si no se leen caracteres debido a que se detecta el final del stream, se devuelve el valor -1. Si cuenta vale cero, no se leen caracteres y se devuelve cero. Este método se bloquea hasta que haya entrada disponible, se alcance el final del stream o se lance una excepción. Si no se puede leer el primer carácter por una razón diferente a la de detectar el final del stream (concretamente por ejemplo, si el stream ya ha sido cerrado), se lanza una ex-cepción IOException. Una vez que se ha leido un carácter, cualquier fallo posterior al tra-tar de leer caracteres subsecuentes no se indica con una excepción, sino que se trata como si se encontrara el final del stream: el método se completa normalmente y devuelve el número de caracteres leídos antes de que se produjera el fallo.

public int read(char[] buf) throws IOException

Es equivalente a read (buf, 0, buf .length).

73 Lector.



public long skip(long cuenta) throws IOException

Salta un máximo de cuenta caracteres de la entrada, o hasta que se detecte el final del stream. Devuelve el número real de caracteres que se han saltado. El valor de cuenta no puede ser negativo.

public boolean ready() throws IOException

Devuelve true si el stream está listo para ser leído, es decir, si hay al menos un carácter disponible para ser leído. Nótese que un valor de retorno de false no garantiza que la siguiente invocación de read se bloqueará, ya que pueden haber llegado nuevos datos disponibles en el momento que se produce la invocación a read.

public abstract void close() throws IOException Cierra el stream de entrada. Este método debe invocarse para liberar los recursos (como los descriptores de archivos) asociados al stream. Una vez el stream ha sido cerrado, la operaciones posteriores sobre dicho stream producirán una exepción IOExeeption. Cerrar un stream previamente cerrado no tiene ningún efecto.

La implementación de Reader requiere sólo que una subclase proporcione la implementa-ción del método read que lee en un array de char, y el método close. Muchas subclases pueden mejorar las prestaciones redefiniendo también los otros métodos.

Hay varias diferencias entre Reader e InputStream. En el caso de Reader, el método fun-damental de lectura lee en un array de char, y los otros métodos read se definen en función de ese método fundamental. Por el contrario, la clase InputStream usa el método read de un solo byte como método fundamental de lectura. En la clase Reader las subclases deben implementar el método abstracto close, y no heredan una implementación vacía (muchas clases de streams necesitarán saber al menos si han sido o no cerradas, por lo que close necesitará generalmente ser redefinido). Finalmente, InputStream tiene un método available para indicar cuántos datos hay disponibles para lectura, mientras que Reader tiene un método ready que indica simplemente si hay datos disponibles.



Código 8.2.4.3. Programa que cuenta el número de caracteres blancos que hay en un stream de caracteres.

total caracteres , 111 espacios Writer74 La clase abstracta writer proporciona un stream análogo a OutputStream, pero diseñado

para trabajar con caracteres en vez de con bytes. Los métodos de writer son esencialmente un reflejo de los OutputStream, pero añaden algunas formas útiles de write.

void write(char[] buf, int despl, int cuenta) thro IOException Escribe parte de un array de caracteres, empezando en buf [despl], y escribiendo cuenta

caracteres. Este método se bloquea hasta que los caracteres han sido escritos.

public void write(char[] buf) throws IOException

Es equivalente a write (buf , 0 , buf .length).

public void write(String cad, int despl, int cuenta) throws IOException

Escribe cuenta caracteres de la cadena de texto cad, empezando en cad. charAt (despl).

74 Escritor.



public void write(String cad) throws IOException

Equivale a write (cad , 0 , cad. length (c) public abstract void flush() throws IOException

Vacía el stream. Si el stream tiene caracteres en buffers correspondientes a varios méto-dos write, flush los envía inmediatamente a su destino. Si el destino es otro stream, también se vacía. Una sola invocación a flush vaciará todos los streams de una cadena. Si el stream no es buffered, flush no hará nada.

public abstract void close() .throws IOException Cierra el stream de salida, vaciándolo si es necesario. Este método se debe invocar para liberar los recursos (como los descriptores de archivos) asociados al stream. Una vez que un stream ha sido cerrado, las operaciones posteriores sobre el mismo harán que se lance una IOException_ Cerrar un stream previamente cerrado no tiene ningún efecto.

Las subclases de Writer deben implementar la variante de write que opera sobre un array. y los métodos close y flush. Todos los demás métodos de Writer se implementan en función de estos tres. Esto es una diferencia con OutpuStream, que utiliza la variante de un solo byte del método write como método fundamental, y proporciona implementaciones por defecto de flush y close_ Como en el caso de Reader, muchas subclases pueden dar mejores prestaciones si redefinen también otros métodos.

public abstract void close() .throws IOException Cierra el stream de salida, vaciándolo si es necesario. Este método se debe invocar para liberar los recursos (como los descriptores de archivos) asociados al stream. Una vez que un stream ha sido cerrado, las operaciones posteriores sobre el mismo harán que se lance una IOException_ Cerrar un stream previamente cerrado no tiene ningún efecto.

Las subclases de Writer deben implementar la variante de write que opera sobre un array. y los métodos close y flush. Todos los demás métodos de Writer se implementan en función de estos tres. Esto es una diferencia con OutpuStream, que utiliza la variante de un solo byte del método write como método fundamental, y proporciona implementaciones por defecto de flush y close_ Como en el caso de Reader, muchas subclases pueden dar mejores prestaciones si redefinen también otros métodos.

InputStreamReader 75 y OutputStreamWriter76

Los streams de conversión InputStreamReader y OutputStreamWriter realizan conver-

siones entre Unicode y streams de bytes utilizando una determinada codificación, o la

75 Para java, un InputStream es cualquier cosa de la que se leen bytes. Puede ser el teclado, un archivo, un socket, o cualquier otro dispositivo de entrada. 76 Para Java, un OutputStreamWriter es cualquier cosa en donde se puedan escribir bytes, un archivo, un socket o cualquier dispositivo de salida.



codificación por defecto del sistema local. Los objetos InputS reamReader reciben como

fuente un stream de bytes de entrada y producen los correspondientes caracteres de

Unicode. Los objetos OutputStreamReader reciben como destino un stream de bytes de

salida y producen las formas codificadas en bytes de los caracteres Unicode que se

escriben. Por ejemplo, el código que se presenta a continuación lee bytes

correspondientes a caracteres árabes codificados con ISO 8859-6, Y los convierte en los

caracteres de Unicode apropiados.

Por defecto, estos streams de conversión funcionarán con la codificación por defecto de la plataforma, y si se desean utilizar otras codificaciones, deberán especificarse. Estas clases son el "pegamento" que permite utilizar codificaciones locales de caracteres de 8 bits de forma consistente e independiente de la plataforma.

public InputStreamReader(InputStream in)

Crea un InputStreamReader para leer de un InputStream dado utilizando la codificación de caracteres por defecto.

public InputStreamReader(InputStream in, String codificacion) throws UnsupportedEncodingException

Crea un InputStreamReader para leer del InputStream dado utilizando la codificación de caracteres dada. Si el nombre de la codificación no se admite, se lanza una excepción Un supportedEncoding Exception.

public OutputStreamWriter(OutputStream out)

Crea un OutputStreamWriter para escribir el OutputStream dado utilizando la codificación de caracteres por defecto.

public OutputStreamWriter(OutputStream out, String codificacion) throws UnsupportedEncodingException

Crea un InputStreamWriter para escribir en un OutputStream dado utilizando la co-dificación de caracteres dada. Si el nombre de la codificación no se admite, se lanza una excepción UnsupportedEncodingException.

Los métodos read de InputStreamReader simplemente leen bytes de su InputStream asociado y los convierten en caracteres utilizando la codificación adecuada para ese stream. Similarmente, los métodos write de OutputStreamWriter toman los caracteres que se les suministran, los convierten en bytes utilizando la codificación apropiada y los escriben en su correspondiente OutputStream asociado.

En ambas clases, si se cierra el stream de conversión, se cierra también el stream de



bytes asociado. Esto no siempre tiene por qué ser deseable (como por ejemplo, al convertir los streams estándar), por lo que es conveniente considerar cuidadosamente cuándo se cierran los streams de conversión.

Ambas clases admiten también el método getEncoding, que devuelve una cadena de texto que representa el nombre canónico de la codificación de caracteres que se utiliza en el stream. o null si el stream ha sido cerrado. Las clases FileReader y FileWriter son subclases de estos streams de conversión. Esto nos ayuda en la lectura y escritura de archivos locales de forma consistente utilizando Unicode, mediante la codificación local. Pero si la codificación local por defecto no es la que necesitamos, debemos utilizar objetos InputStreamReader o OutputStreamWriter explícitos.

No existen clases ReaderlnputStream ni WriterOutputStream para convertir streams de caracteres en streams de bytes.

8.2.5 Recorrer En una Lectura El corrimiento de archivos se hace de línea en línea con ciclos, que mejor que un ejemplo para mostrar como funciona;

Código 8.2.5. Recorrer un archivo. El recorrimiento se hace con el ciclo while de línea en línea hasta encontrar el fin de archivo. En una Escritura En este caso se utiliza un ciclo for para recorrer el archivo e insertarle 10 líneas al mismo.

Código 8.2.6. Recorrer un archivo para escritura.



8.3 Aplicaciones

Ejemplo 1:

Código 8.3.1. Lectura de un archivo de texto en java. Ejemplo 2:

Código 8.3.2. Escritura de un archivo de texto en java.



Ejemplo 3:

Archivo: archivo.txt

El proceso de lectura de un archivo de texto es similar a la lectura desde el dispositivo estándar. Se crea un objeto entrada de la clase FileReader en vez de InputStreamReader. El final del archivo viene dado cuando la función read devuelve -1. El resto del código es similar.

Código 8.3.3. Lectura de un archivo

Para mostrar el archivo de texto en la pantalla del monitor, se imprime el contenido del objeto str de la clase StringBuffer.

System.out.println(str);

Una vez concluido el proceso de lectura, es conveniente cerrar el flujo de datos, esto se realiza en una cláusula finally que siempre se llama independientemente de que se produzcan o no errores en el proceso de lectura/escritura.



El código completo de este ejemplo es el siguiente:

Código 8.3.4. Lectura del archivo “archivo2.java” en pantalla.

Ahora se crea un código completo que genera un archivo copia del original, es el siguiente:



Código 8.3.5. Crea una copia del archivo “archivo3.java”. Ejemplo 4. El siguiente ejemplo, genera un archivo de prueba que contiene números enteros aleatorios. Crea un archivo llamado prueba.dat.



Código 8.3.6 Genera un archivo de prueba *.dat y lo llena de números enteros.

Ejemplo 5. La siguiente clase permite leer el archivo "prueba.dat" utilizando las clases FileReader y BufferReader:

Código 8.3.7 Lee prueba.dat utilizando BufferReader y BufferReader.



8.4 Ejercicios propuestos 8.4.1 Crear una aplicación que lea de teclado una oración dada por el usuario y que ésta se escriba en un archivo. 8.4.2 Crear una aplicación para mostrar directorios en una lista, que pida al usuario una ruta absoluta y luego muestre todos los nombres de archivos que haya dentro de ese directorio. Si alguno de los archivos es un directorio, debe imprimirse la palabra "dir" después de su nombre. 8.4.3 Construir un directorio de amigos. Considérese que la información más relevante para representar a un amigo es: nombre, teléfono, correo-e y fecha de cumpleaños. Utilizar objetos serializables para escribir y leer de archivo. 8.4.4 Escribir un método en que se abra un flujo, RandomAccessFile, en modo lectura (“r”) en el caso de que la operación lance una excepción abrir el archivo en modo lectura/escritura(“rw”). 8.4.5 Escribir un método para copiar un archivo. El método entrá dos argumentos de tipo cadena, el primero es el archivo original y el segundo es el archivo destino. Utilizar flujos FileInputStream y FileOutPutStream. 8.4.6 Se tiene un archivo de caracteres de nombre “SALAS.DAT”. Escribir un programa para crear el archivo “SALAS.BIN” con el contenido del primer archivo, pero en modo binario. 8.4.7 Utilizar los argumentos del método main() para dar entrada a dos cadenas; la primera representa una mascara. La segunda el nombre de un archivo de caracteres. El programa tiene que localizar las veces que ocurre la mascara en los archivos. 8.4.8 El archivo “numeros.dat” contiene enteros positivos y negativos. Escribir un programa que habrá un flujo DataInputStream para leer el archivo y determinar el número de enteros negativos. 8.4.9 Escribir un programa que elimine todos los archivos con la extensión *.txt del directorio actual. Utilizar los métodos de la clase File. 8.4.10 Escribir un programa que escriba por pantallas las líneas de caracteres de un archivo, numerando cada línea del mismo.

Resumen


CONCLUSIONES Como ya se vio en este libro de texto, Java es un lenguaje orientado a objetos basado en C++ con atractivas características que lo convierten en uno de los más usados actualmente. Además, Gracias a su simplicidad y claridad en el manejo de conceptos orientados a objetos, Java ha crecido a tal magnitud que numerosas tecnologías y compañías han enfocado sus esfuerzos hacia este lenguaje.

Tienes grandes ventajas: • Simple. Java es simple dado que abstrae la complejidad intrínseca de C++ como el

manejo de apuntadores y el reciclado de la memoria. • Orientado a objetos. Java permite el diseño de aplicaciones basadas en objetos

dado su mejor comprensión y definición en el diseño de interfaces y reusabilidad de componentes.

• Fácil uso en la red. Java facilita el acceso a la red por medio de TCP/IP con utilerías simples e intuitivas para comunicar por HTTP o FTP, por ejemplo.

• Robusto. Java pone énfasis en la detección de errores y bugs a temprana fase del desarrollo, específicamente en la compilación, que encontrarlos en tiempo de ejecución.

• Seguro. Java está orientado a la red y sistemas distribuidos, por lo que refuerza la seguridad en la transmisión por medios de comunicación por red.

• Neutral arquitectura. Debido a que Java está orientado a la red donde están involucrados diferentes CPU, diferentes sistemas operativos y arquitecturas, Java crea programas con un formato especial solo ejecutables por el ambiente Java.

• Portable. A diferencia de C++ donde no existe forma directa de migrar un programa de una plataforma a otra, cualquier programa en Java puede ser compilado y ejecutado en cualquier plataforma sin necesidad de modificar el código.

• Interpretado. Java crea programas en un formato especial conocido como bytecodes. Este formato debe ser ejecutado por un intérprete dependiente de la plataforma.

• Multihilado. Java permite la creación de procesos internos conocidos como hilos (threads) lo que permite la concurrencia de tareas y acceso a recursos.

• Dinámico. El lenguaje Java puede evolucionar o mejorarse liberando versiones que no impactan en los programas ya desarrollados por medio de la incrustación de librerías.

En lo personal, creo que es un lenguaje con un enorme potencial y que en un

futuro, si no es que ya esta pasando, dominara claramente el mercado de la programación.

En hora buena creo hice muy bien al seleccionar este proyecto, ya que aprendí muchísimo elaborando este libro de texto, y además es muy gratificante saber que todo lo aprendido servirá como herramienta de apoyo para la materia de POO (Programación orientada a objetos).

Anexo I. Introducción al lenguaje Java


ANEXO I. INTRODUCCIÓN AL LENGUAJE JAVA



ANEXO I. Introducción al Lenguaje Java

1.1 Introducción Hoy en día la informática invade más campos de la vida cotidiana, estando el ciudadano cada vez más familiarizado con términos del mundo informático, entre ellos, como los lenguajes de programación. A cualquier persona que haya empleado alguna vez un ordenador le resultará familiar alguno de estos nombres: C, Pascal, Cobol, Visual Basic, Java, Fortran y a una persona ya más introducida en ese mundillo posiblemente haya oído muchos otros: Oak, Prolog, Dbase, JavaScrip, Delphi, Simula, Smalltalk, Modula, Oberon, Ada, BCPL 77, Common LISP, Scheme. En la actualidad se podrían recopilar del orden de varios cientos de lenguajes de programación distintos, sino miles. Cabe hacerse una pregunta: ¿Para qué tanto lenguaje de programación?. Toda esta multitud de nombres puede confundir a cualquier no iniciado que haya decidido aprender un lenguaje, quien tras ver las posibles alternativas no sabe cual escoger, al menos entre los del primer grupo, que por ser más conocidos deben estar más extendidos. El motivo de esta disparidad de lenguajes es que cada uno ha sido creado para una determinada función, está especialmente diseñado para facilitar la programación de un determinado tipo de problemas, para garantizar seguridad de las aplicaciones, para obtener una mayor facilidad de programación, para conseguir un mayor aprovechamiento de los recursos del ordenador... Estos objetivos son muchos de ellos excluyentes: el adaptar un lenguaje a un tipo de problemas hará más complicado abordar mediante este lenguaje la programación de otros problemas distintos de aquellos para los que fue diseñado. El facilitar el aprendizaje al programador disminuye el rendimiento y aprovechamiento de los recursos del ordenador por parte de las aplicaciones programadas en este lenguaje.

1.2 Características de Java Estas preguntas ayudan a ver para que tipo de problemas está pensado Java:

1.2.1 Simple Es un lenguaje sencillo de aprender. Su sintaxis es la de C++ “simplificada”. Los creadores de Java partieron de la sintaxis de C++ y trataron de eliminar de este todo lo que resultase complicado o fuente de errores en este lenguaje.

77 Basic Combined Programming Language (Lenguaje de Programación Básico Combinado)



1.2.2 Orientado a Objetos Posiblemente sea el lenguaje más orientado a objetos de todos los existentes; en Java todo, a excepción de los tipos fundamentales de variables (int, char, long...) es un objeto.

1.2.3 Distribuido Java está muy orientado al trabajo en red, soportando protocolos como TCP/IP, UDP, HTTP y FTP. Por otro lado el uso de estos protocolos es bastante sencillo comparándolo con otros lenguajes que los soportan.

1.2.4 Robusto El compilador Java detecta muchos errores que otros compiladores solo detectarían en tiempo de ejecución o incluso nunca. (ej: if(a=b) then ... el compilador Java no dejaría compilar este código.

1.2.5 Seguro Sobre todo un tipo de desarrollo: los Applet 78. Java garantiza que ningún Applet puede escribir o leer de un disco o mandar información del usuario que accede a la página a través de la red (por ejemplo, la dirección de correo electrónico). En general no permite realizar cualquier acción que pudiera dañar la máquina o violar la intimidad del que visita la página web.

1.2.6 Portable En Java no hay aspectos dependientes de la implementación, todas las implementaciones de Java siguen los mismos estándares en cuanto a tamaño y almacenamiento de los datos. Esto no ocurre así en C++, por ejemplo. En éste un entero, por ejemplo, puede tener un tamaño de 16, 32 o más bits, siendo la única limitación que el entero sea mayor que un short y menor que un long int. Así mismo C++ bajo UNIX almacena los datos en formato little endian, mientas que bajo Windows lo hace en big endian. Java lo hace siempre en little endian 79 para evitar confusiones.

1.2.7 Arquitectura Neutral

78 Un applet es un componente de software que corre en el contexto de otro programa, por ejemplo un navegador web. 79 El término “Endian” se refiere a la forma en que los números binarios de bytes múltiples son guardados en la computadora.



El código generado por el compilador Java es independiente de la arquitectura: podría ejecutarse en un entorno UNIX, Mac o Windows. El motivo de esto es que el que realmente ejecuta el código generado por el compilador no es el procesador del ordenador directamente, sino que este se ejecuta mediante una máquina virtual. Esto permite que los Applets de una web pueda ejecutarlos cualquier máquina que se conecte a ella independientemente de que sistema operativo emplee (siempre y cuando el ordenador en cuestión tenga instalada una máquina virtual de Java).

1.2.8 Rendimiento medio Actualmente la velocidad de procesado del código Java es semejante a la de C++, hay ciertos pruebas estándares de comparación80 en las que Java gana a C++ y viceversa. Esto es así gracias al uso de compiladores just in time, compiladores que traduce los bytecodes de Java en código para una determinada CPU 81, que no precisa de la máquina virtual para ser ejecutado, y guardan el resultado de dicha conversión, volviéndolo a llamar en caso de volverlo a necesitar, con lo que se evita la sobrecarga de trabajo asociada a la interpretación del bytecode. No obstante por norma general el programa Java consume bastante más memoria que el programa C++, ya que no sólo ha de cargar en memoria los recursos necesario para la ejecución del programa, sino que además debe simular un sistema operativo y hardware virtuales (la máquina virtual). Por otro lado la programación gráfica empleando las librerías Swing es más lenta que el uso de componentes nativos en las interfaces de usuario. En general en Java se ha sacrificado el rendimiento para facilitar la programación y sobre todo para conseguir la característica de neutralidad arquitectural, si bien es cierto que los avances en las máquinas virtuales remedian cada vez más estas decisiones de diseño.

1.2.9 Multithread Soporta de modo nativo los threads 82, sin necesidad del uso de librerías específicas (como es el caso de C++). Esto le permite además que cada Thread de una aplicación java pueda correr en una CPU distinta, si la aplicación se ejecuta en una máquina que posee varias CPU. Las aplicaciones de C++ no son capaces de distribuir, de modo transparente para el programador, la carga entre varias CPU.

1.3 Java frente a los demás lenguajes Java es un lenguaje relativamente moderno. Su primer uso en una “tarea seria” de programación fue la construcción del navegador HotJava por parte de la empresa Sun en mayo de 1995, y fue a principios de 1996 cuando Sun distribuye la primera versión de 80 Benchnarks. 81 Unidad de Proceso Central. 82 Hilos.



Java. Es esta corta edad lo que hace que Java esté más orientado al mundo web, que no existía cuando, por ejemplo, C fue desarrollado. También es esto lo que ha hecho que soporte de modo nativo (no mediante el uso de librerías, como C) los threads, siendo posible aprovechar las ventajas de los sistemas multiprocesadores. Las ventajas fundamentales de Java frente a otros lenguajes son el menor periodo de aprendizaje por parte del programador, llegando a ser un programador productivo en menos tiempo (sencillez) y siendo posible desarrollar aplicaciones más rápido que en otros lenguajes (sencillez y robustez), lo cual se traduce en el mundo empresarial en un ahorro de costos de desarrollo. Sus cualidades de distribuido, seguro e independencia de la plataforma lo hacen ideal para aplicaciones relacionadas con el mundo web; precisamente a esto es a lo que Java debe su gran difusión y fama. El hecho de que sea independiente de la máquina y del sistema operativo permite que distintas máquinas con distintos sistemas operativos se conecten a una misma página web y ejecuten los mismos applets. Además la seguridad que garantiza Java para los applets impiden que alguien trate de averiguar información sobre los usuarios que se conectan a la página web o intente dañar sus máquinas. En cuanto a su capacidad de soporte de threads y su capacidad de sacarle partido a sistemas multiprocesador lo convierten en un lenguaje más “orientado hacia el futuro “. Estas cualidades podrían dar pie a que algún día los rendimientos computacionales de Java sean comparables con los de C++ y otros lenguajes que hoy son computacionalmente más eficientes. 2 j2sdk, java 2 standard development kit Distribuido por Sun 83, jdk. Dicho entorno de programación es suministrado por Sun de forma gratuita, este se puede encontrar en la dirección web: http://Java.sun.com/j2se/. Es de consenso que el entorno jdk no es el más adecuado para el desarrollo de aplicaciones Java, debido a funcionar única y exclusivamente mediante comandos de consola, ya que hoy en día la programación se suele ayudar de entornos visuales, como JBuilder, JCreator o muchos otros, que facilitan enormemente la tarea. Sin embargo, puede ser un entorno bastante útil para aprender el lenguaje, ya que aunque los entornos visuales nos hagan mucho trabajo siempre es necesario ir al código para modificarlo y obtener el comportamiento deseado, lo cual quiere decir que se necesita dominar el lenguaje y es más fácil llegar a este dominio escribiendo códigos completos en un entorno “hostil” que ayuda, que simplemente remodelando códigos ya generados por entornos visuales.

83 Pagina Oficial de Java.



1.4 Como Compilar y Ejecutar Programas en Java

1.4.1 Javac Es el comando compilador de Java. Su sintaxis es: Javac ejemplo.Java La entrada de este comando ha de ser necesariamente un archivo que contenga código escrito en lenguaje Java y con extensión .Java. El comando nos creará un archivo .class por cada clase que contenga el archivo Java. Los archivos .class contienen código bytecode, el código que es interpretado por la máquina virtual Java.

1.4.2 Java Es el intérprete de Java. Permite ejecutar aplicaciones que previamente hayan sido compiladas y transformadas en archivos .class. Su sintaxis es: Java ejemplo No es necesario aquí suministrar la extensión del archivo, ya que siempre ha de ser un archivo .class.

1.4.3 Appletviewer Se trata de un comando que verifica el comportamiento de un applet. La entrada del comando ha de ser una página web que contenga una referencia al applet que se desea probar. Susintaxis es: Appletviewer supagina.html El comando ignora todo el contenido de la página web que no sean applets y se limita a ejecutarlos. Un ejemplo de página web “mínima” para poder probar un applet llamado myapplet.class sería:

<HTML> <TITLE>My Applet </TITLE> <BODY> <APPLET CODE=”myapplet.class” WIDTH=180 HEIGHT=180> </APPLET> </BODY> </HTML>



Javadoc Este útil comando permite generar documentación en formato html sobre el contenido de archivos con extensión .Java. Su sintaxis es: Javadoc ejemplo.Java En la documentación generada por este comando se puede ver que métodos y constructores posee una determinada clase, junto con comentarios sobre su uso, si posee inner 84 classes, la versión y el autor de la clase....

1.5 Estructuras de Datos Básicas en Java

En este tema se tratarán las estructuras básicas de Java de datos, sus tipos y las variables, operadores. Aquellos que estén familiarizados con C, o C++, no encontrarán prácticamente nada nuevo en este tema, ya que, como se ha dicho en el primer tema, Java hereda toda su sintaxis de C, pudiendo considerarse la sintaxis de Java una versión simplificada de la de C. Sólo las operaciones con Strings pueden resultar un poco novedosas.

1.5.1 Tipos de Datos En Java toda variable declarada ha de tener su tipo, y además antes de poder emplearla se ha de inicializar a un valor, si no el compilador se quejará y no generará los archivos .class. Esto por ejemplo en C no es necesario, siendo fuente de muchos errores al emplearse en operaciones variables que se olvidan de inicializar. A continuación se pasan a describir los tipos de datos:

1.5.2 Enteros Almacenan como su propio nombre indica números enteros, sin parte decimal. Cabe destacar, como ya se indicó en el primer tema, que por razones de portabilidad todos los datos en Java tienen el mismo tamaño y formato. En Java hay cuatro tipos de enteros:

84 Clases Embebidas.



1.5.3 Tipos de Datos Enteros en Java

Tipo Tamaño (bytes) Rango

Int 4 -2147483648 a 2147483647

Short 2 -32768 a 32767

Long 8 -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807

Byte 1 -128 a 127

1.5.4 Tipos de Datos Reales en Java Almacenan número reales, es decir números con parte fraccionaria. Hay dos tipos:

Tipo Tamaño (bytes) Rango

Float 4 + 3.40282347E+38

Double 8 + 179769313486231570E+308

1.5.5 Caracteres En Java hay un único tipo de carácter: char. Cada carácter en Java esta codificado en un formato denominado Unicote 85, en este formato cada caracter ocupa dos bytes, frente a la codificación en ASCII, donde cada caracter ocupaba un solo byte. Unicode es una extensión de ASCII 86, ya que éste último al emplear un byte por caracter solo daba acogida a 256 símbolos distintos. Para poder aceptar todos los alfabetos (chino, japonés, ruso...) y una mayor cantidad de símbolos se creó el formato Unicode. 85 Es un estándar industrial cuyo objetivo es proporcionar el medio por el cual un texto en cualquier forma o idioma puede ser codificado.



En Java al igual que en C se distingue la representación de los datos char frente a las cadenas de caracteres. Los char van entre comillas simples: char ch = ‘a’, mientras que las cadenas de caracteres usan comillas dobles.

1.5.6 Boolean Se trata de un tipo de dato que solo puede tomar dos valores: true y false. Es un tipo de dato bastante útil a la hora de realizar chequeos sobre condiciones. En C no hay un dato equivalente y para suplir su ausencia muchas veces se emplean enteros con valor 1 si “true” y 0 si “false”. Otros lenguajes como Pascal sí tiene este tipo de dato.

1.5.7 Variables Al igual que C, Java requiere que se declaren los tipos de todas las variables empleadas. La sintaxis de iniciación es la misma que C: int i; Sin embargo, y a diferencia que en C, se requiere inicializar todas las variables antes de usarlas, si no el compilador genera un error y aborta la compilación. Se puede inicializar y asignar valor a una variable en una misma línea: int i = 0; Asignación e inicialización pueden hacerse en líneas diferentes: int i ; i = 0; Es posible iniciar varias variables en una línea: int i, j,k=10; Después de cada línea de código, bien sea de iniciación o de código, al igual que en C va un ;. En Java, al igual que en todo lenguaje de programación hay una serie de palabras reservadas que no pueden ser empleadas como nombres de variables (if, int, char, else, goto....); alguna de estas se emplean en la sintaxis del lenguaje, otras, como goto no se emplean en la actualidad pero se han reservado por motivos de compatibilidad por si se emplean en el futuro. Los caracteres aceptados en el nombre de una variable son los comprendidos entre “A-Z”, “az”, _, $ y cualquier carácter que sea una letra en algún idioma.

86 Acrónimo de American Standard Code for Information Interchange.



1.6 Entornos de Desarrollo de Java El propósito de esta sección es informar al lector de algunas de los entornos de desarrollo IDE 87 existentes para el lenguaje Java. 1.6.1 Bluej http://www.bluej.org/ Es el IDE que, sin duda, se recomienda al lector para que empiece a dar sus primeros pasos en Java. Esta herramienta freeware ha sido diseñada para introducir al estudiante en la programación orientada a objetos. Es un IDE “ligera”, posee la funcionalidad básica de cualquier IDE: editor, compilador y depurador. Siempre visualiza el código del proyecto en UML 88, mostrando las clases con las relaciones de herencia y dependencias entre ellas. Posee ciertas capacidades para “jugar” con las clases permitiendo la creación de objetos, así como “jugar” con ellos invocando sus métodos, viendo el valor que toman sus variables… Estas cualidades carecen de valor para un programador experto, pero permiten a un programador novato familiarizarse con los conceptos de objeto, método, variable, herencia… a diferenciar entre objeto y clase… No sólo se recomienda esta IDE a los que empiecen a trabajar con java por su orientación didáctica; se hace además porque se considera que cualquier IDE “pesada”, no es apta para aprender a programar. Su elevada Complejidad, si bien es fácilmente compensada con las opciones que ofrecen a un programador veterano, no lo es en un programador novato, quien ya tiene bastante con pelearse con el lenguaje para además tener que hacerlo con el IDE. Por otro lado los asistentes y el elevado grado de automatización de algunas tareas en los IDE pesados hacen que el programador novato haga cosas sin saber realmente lo que está haciendo, con lo cual, si bien logra hacer pequeñas aplicaciones, su aprendizaje estará plagado de lagunas. Para un programador experto que domina las bases del lenguaje en unos días son más que suficientes para sentirse cómodo en un nuevo IDE. 1.6.2 Jcreator http://www.jcreator.com/ Se trata de una IDE ligera, no posee, por ejemplo, capacidades para desarrollo de aplicaciones de modo gráfico. Sin embargo es interesante ya que requiere máquinas poco potentes para ejecutarse, un Pentium 2 a 300 con 64 megas de RAM sería más que suficiente, mientras que las siguientes, e incluso BlueJ, requieren equipos bastante más potentes. No obstante, a diferencia de BlueJ este producto si es un IDE que puede ser empleado por un programador profesional (BlueJ pierde todo interés más allá de la docencia), con lo

87 Ambientes de Desarrollo Integrado (Integrated Development Environment). 88 Lenguaje de Modelado Unificado.



cual los que empiecen directamente con ella podrán “aguantar” más que los que se decidan por BlueJ. Es un IDE comercial, con dos versiones: JCreator : gratis. JCreator Pro : Aproximadamente 69$ (licencia de estudiante).

1.6.3 Jbuilder Http://www.borland.com/jbuilder/ Desde el punto de vista de algunos expertos esta es la mejor IDE para Java del mercado. Requiere máquinas potentes, la última versión (llamada X por Borland) se arrastra bastante con un equipo inferior a un Pentium III a 800 con 512 megas de RAM. Posee capacidades de desarrollo visual de aplicaciones, así como múltiples asistentes y está integrada con una gran cantidad de herramientas, unas Opensource 89(Ant, CVS, Struts Tomcat…) y otras propietarias (Borland Aplication Server, JDataStore, ClearCase, Visual SouceSafe …). Nuevamente es comercial, y los precios de las versiones no gratuitas son bastante prohibitivos: JBuilder X Persona: gratis JBuilder X Developer: $ JBuilder X Enterprise : $ Existen versiones gratuitas de evaluación por 30 días de todos los productos. 1.6.4 Netbeans http://www.netbeans.org/ Ofrece una funcionalidad más limitada que JBuilder, y es bastante menos intuitivo de manejar, en especial para los programadores novatos. Sin embargo es la herramienta gratuita (Open Source) que más funcionalidad tiene. Permite el diseño de aplicaciones de modo visual. Esta herramienta Open Source está respaldada por Sun Microsystems, empresa que construye su IDE para java, Sun ONE Studio. Si el aprendiz no puede permitirse una herramienta comercial, como JBuilder, y quiere más de lo que da JCreator, esta es, la mejor alternativa en este momento. 1.6.5 Eclipse http://www.eclipse.org/

NetBeans es un proyecto de código abierto de gran éxito con una gran base de usuarios, una comunidad en constante crecimiento, Sun MicroSystems fundó el proyecto de código abierto NetBeans en junio 2000 y continúa siendo el patrocinador principal de los proyectos.

A día de hoy hay disponibles dos productos: el NetBeans IDE y el NetBeans Plataform.

89 Código Abierto.



El NetBeans IDE es un entorno de desarrollo - una herramienta para programadores pensada para escribir, compilar, depurar y ejecutar programas. Está escrito en Java - pero puede servir para cualquier otro lenguaje de programación. Existe además un número importante de módulos para extender el IDE NetBeans. El IDE NetBeans es un producto libre y gratuito sin restricciones de uso.

También disponible está el NetBeans Platform; una base modular y extensible usada como una estructura de integración para crear aplicaciones de escritorio grandes. Empresas independientes asociadas, especializadas en desarrollo de software, proporcionan extensiones adicionales que se integran fácilmente en la plataforma y que pueden también utilizarse para desarrollar sus propias herramientas y soluciones.

Ambos productos son de código abierto y gratuito para el uso tanto comercial y como no comercial. El código fuente está disponible para su reutilización de acuerdo con el Desarrollo Cómun y Licencia de Distribución 90.

Es una IDE extensible en base a plugins 91. Esta filosofía, junto con la actividad que muestra su comunidad convierten a esta herramienta en toda una promesa de futuro. Sin embargo, desde el punto de vista del autor, al día de hoy es una herramienta menos completa que NetBeans, no proporcionando por ejemplo capacidad para el desarrollo visual de aplicaciones. Por otro lado hay ciertos puntos, como la instalación, que están un poco descuidados, y su filosofía en base a plugins obliga al usuario a buscar y descargarse varios plugins o resignarse a carecer de bastante funcionalidad. No obstante esta herramienta posee algunas capacidades, como el refactoring, no presentes en NetBeans en el momento de escribir estas líneas. Además es más pedagógico “construir” su propia IDE en base a plugins que descargarse un paquete donde ya se da todo hecho.

90 Common Development and Distribution License (CDDL). 91 Son pequeños programas que se instalan sobre los navegadores y que confieren posibilidades multimedia al mismo. Identifican el archivo multimedia usando el código MIME: Multipurpose Internet Mail Extensions (Extensiones de correo Internet Multipropósito).

Anexo II. El entorno de desarrollo Eclipse


ANEXO II. EL ENTORNO DE DESARROLLO ECLIPSE

2.1. ¿Que es Eclipse? Eclipse es una plataforma de desarrollo open source basada en Java. Es un desarrollo de IBM cuyo código fuente fue puesto a disposición de los usuarios. En sı mismo Eclipse es un marco y un conjunto de servicios para construir un entorno de desarrollo a partir de componentes conectados (plug-in). Hay plug-ins para el desarrollo de Java (JDT Java Development Tools) así como para el desarrollo en C/C++, COBOL, etc. La versi´on instalada en el laboratorio incluye el plug-in JDT.

2.2. Trabajando con Eclipse

Al ejecutar Eclipse aparece una ventana como la mostrada en la figura 17. Eclipse contiene una serie de perspectivas. Cada perspectiva proporciona una serie de funcionalidades para el desarrollo de un tipo específico de tarea. Por ejemplo la perspectiva Java combina un conjunto de views que permiten ver información útil cuando se esta escribiendo código fuente, mientras que la perspectiva de depuración contiene vistas que muestran información útil para la depuración de los programas Java. La barra de herramientas vertical (en la parte izquierda) muestra las perspectivas abiertas y permite pulsando sobre ellas cambiar de una a otra. La perspectiva activa se muestra en la barra del titulo en la parte superior de la ventana.

2.2.1. Creación de un proyecto Eclipse permite organizar los ficheros en forma de proyecto. Para crear un proyecto Java se procede del siguiente modo: 1. Seleccionando en el menú File − New − Project o pulsando con el botón derecho del Ratón sobre la vista Navigator en la perspectiva Resource y seleccionando New − Project. 2. Aparece una ventana en la que se puede seleccionar el tipo de proyecto. En este caso se pulsa sobre Java en la parte izquierda y Java project en la derecha. Pulsar sobre el botón Next . Ver la figura 18 3. A continuación se piden los datos sobre el proyecto (nombre y ruta donde se almacenarán los ficheros asociados al proyecto). Una vez introducidos se pulsa sobre finish. Véase la figura 19. 4. Eclipse abre automáticamente la perspectiva Java cuando se crea un proyecto Java. Se crea el directorio especificado con dos ficheros .project y .classpath que contienen información sobre el proyecto. Listado 1: Código generado utilizando el asistente



/∗ ∗ Created on “fecha” ∗ ∗ To change the template for this generated f i l e go to ∗ Window>Preferences>Java>Code Generation>Code and Comments _/ /_∗ Clase ∗ @author juan ∗ ∗ Descripcion : _/ public class HolaMundo { public static void main( String [ ] args ) {}

Perspectiva Java contienen un directorio con el nombre del proyecto. Como se comento anteriormente, se puede pasar de una perspectiva a otra pulsando sobre los botones de la barra vertical izquierda. 5. Hay una perspectiva mas asociada con Java, se puede abrir del siguiente modo: Window − Open perspective − Java browsing. En esta perspectiva aparecen vistas correspondientes al proyecto, a paquetes, a clases e interfaces y a los miembros de estas.

2.2.2. Creando clases. Las clases se pueden crear de dos formas diferentes: Utilizando un asistente. Se pulsa con el botón derecho sobre el proyecto − New − Class. Aparece una ventana como la que se muestra en la figura 20. Los campos interesan por ahora son: el nombre de la clase, el modificador, y si se quiere que esta clase tenga un método main(String[] args). Al pulsar sobre Finish (con los datos que se muestran en la figura 21 se crea un fichero HolaMundo.java con el código mostrado en el listado 1 (no será exactamente asi ya que yo he personalizado el comentario que aparece). Si se explora el contenido del directorio c:\tmp\prac1 se vera que además del fichero HolaMundo.java hay otro fichero HolaMundo.class, este fichero es el que contiene el código compilado a partir de HolaMundo.java (Eclipse compila el proyecto cada vez que se guarda). Escribiendo directamente toda la clase: se pulsa con el botón derecho sobre el proyecto − New − File . Se abre una ventana como la que se muestra en la figura 21 donde hay que poner el nombre del fichero. Al pulsar sobre Finish se crea un fichero vació con el nombre HolaMundo.java. No se tiene una preferencia por alguno de los dos métodos expuestos. Aunque, como recomendación, al principio es conveniente escribir toda la clase para saber lo que se esta haciendo.



El asistente simplemente a creado un esqueleto ahora falta completar el código. Se añaden las líneas necesarias para completar el programa. El resultado se muestra en la figura 22.

2.2.3. Ejecutando el programa Los programas se pueden ejecutar dentro de Eclipse. Con la perspectiva Java abierta, seleccionar en el menu: Run − Run... En la ventana que se abre, pulsar 2 veces sobre Java Application . En el panel Main se rellena la información tal y como aparece en la figura 23. Puesto que en el ejemplo propuesto se necesitan argumentos se pulsa sobre el panel Arguments y se pone el argumento que se va a pasar al programa. Un ejemplo se muestra en la figura 24. Una vez proporcionada la información necesaria (hay más paneles pero por ahora no es necesario conocerlos) se pulsa sobre el botón Run. Este programa simplemente muestra un mensaje por consola. La consola esta integrada (es una vista más) dentro de Eclipse. Así tras ejecutar el programa, en la vista Consola se vera lo que se muestra en la figura 24. Cuando el programa no requiere ningún ajuste especial (por ejemplo, no se requiere el paso de argumentos) se puede hacer de forma más rápida pulsando sobre Run − Run as − Java Application . Hay barras de tareas para el acceso rápido a algunas funciones (entre ellas ejecutar). La figura 25 muestra algunas de ellas.

2.2.4. Depuración de programas. Dentro del entorno de desarrollo de Eclipse se pueden depurar programas desarrollados en Java. Window − Open perspective − Debug . Aparecen una serie de vistas similares a las de la figura 26. Una vez se ha abierto la perspectiva de depuración se puede parar la ejecución del programa en una determinada línea (poniendo un breakpoint) e inspeccionar las variables locales. Para poner un breakpoint, en la vista donde se encuentra el código fuente se seleccionas la línea donde se quiere que se detenga la ejecución y se selecciona en el menu Run − Add/remove Breakpoint . Se verá que se muestra un punto azul en la parte izquierda de la línea. Ahora ya se puede lanzar el depurador. Se selecciona en el menú Run − Debug . La ejecución del programa se detiene en el primer breakpoint. Una vez el programa esta detenido, en una de las vistas se puede ver el valor de las variables o ver los breakpoints que se ha definido. En la figura 27 se



muestra el programa detenido en una línea y se muestra la vista Variables con el contenido de una variable local. Una vez inspeccionado el código donde esta el problema se puede optar por ejecutar el programa hasta que termine ( Run − Resume ) o terminar el programa inmediatamente (Run − Terminate )

2.2.5. Otras herramientas interesantes. El editor de Java ofrece correcciones a problemas encontrados mientras se escribe el código y tras compilar. El editor muestra que existen propuestas para la corrección de un problema o aviso mediante una bombilla visible en la parte izquierda del editor. Si se pulsa con el botón izquierdo sobre esta bombilla (o también mediante ( Edit − Quick Fix ) se muestran las propuestas para el problema en la posición del cursor. Si se desean importar recursos a un proyecto se puede realizar del siguiente modo: en la vista Navigator se pulsa sobre el botón derecho y aparece un menú, se selecciona Import y aparece una ventana desde la que se puede seleccionar el directorio donde están los recursos y cuales se desean incorporar al proyecto. Desde un proyecto se pueden exportar todos o algunos de los ficheros que lo conforman. Para ello en la vista Navigator se pulsa sobre el botón derecho y aparece un menú, se selecciona Export y aparece una ventana en la que podemos indicar como se va a exportar (un fichero zip, tal cual aparecen en el proyecto, ...). La siguiente ventana sirve para seleccionar los ficheros que se desean exportar y a donde. Si se coloca el ratón sobre un método (sin pulsar) se muestra la declaración del método (que devuelve y que parámetros acepta). Si se coloca el ratón (sin pulsar) sobre una variable aparece información sobre el tipo de la variable. Al escribir código se puede pulsar Ctrl + espacio y aparece un menú con posibles formas de finalizar la sentencia que se esta escribiendo. Un ejemplo se muestra en la figura 28.

Figura 17: Primera pantalla de Eclipse



Figura 18: Selección del tipo de proyecto en Eclipse

Figura 19: Datos sobre el proyecto en Eclipse



Figura 20: Creación de una clase en Eclipse

Figura 21: Creación de un fichero vació en Eclipse.



Figura 22: La perspectiva Java con las vistas mostrando una clase en Eclipse

Figura 23: Configuración para ejecutar la aplicación: proyecto y clase con el main en Eclipse.



Figura 24: Argumentos para enviar al programa y argumentos para enviar a la Maquina Virtual en

Eclipse

Figura 25: Consola con el resultado de la ejecución en Eclipse.



Figura 26: Barra de Herramientas de Eclipse.

Figura 27: La perspectiva debug en Eclipse.



Figura 28: La perspectiva debug en acción en Elipse.

Figura 29: Asistente de código (pulsando Ctrl + espacio) en Eclipse.

Referencias bibliográficas


BIBLIOGRAFIA 1. Taylor David. Object Orient informations systems, planning and implementations. Ed. Ed. Wiley, Canada, 1992. 2. Larman Craig. UML y patrones introducción al análisis y diseño orientado a objetos. Ed. Pretince Hall, México, 1999. 3. Winblad, Ann L. Edwards, Samuel R. Software orientado a objetos. Ed. Addison. Wesley/ Díaz Santos USA, 1993. 4. Deitel & Deitel. Java how to program. Ed. Prentice Hall. 5. Fco. Javier Ceballos. Java 2 Curso de Programación. Ed. Alfaomega. 6. Agustín Froufe. Java 2 Manual de usuario y tutorial. Ed. Alfaomega. 7. Laura Lemay, Rogers Cadenhead. Aprendiendo JAVA 2 en 21 días. Ed. Prentice Hall. 8. Herbert Schildt. Fundamentos de Programación en Java 2. Ed. McGrawHil. 9. J Deitel y Deitel. Como programar en Java. Ed. Prentice Hall. 10. Stephen R. Davis. Aprenda Java Ya. Ed. McGrawHill. 11. Kris Jamsa Ph D.. ¡Java Ahora! Ed. McGrawHill.. 12. Ken Arnold, James Gosling, David colmes

Referencias bibliográficas


“El Lenguaje de Programación Java” Tercera Edción Pearson Educación, Madrid. 13. Abraham Otero Java 2

http://www.javahispano.org/licencias/

14. Javier García de Jalón,José Ignacio Rodríguez,Iñigo Mingo,Aitor Imaz,Alfonso Brazales, Alberto Larzabal, Jesús Calleja,Jon García Aprenda Java Como si Fuera en Primero Editada por Javier García de Jalón ([email protected] y [email protected]) 15. Philip Heller, Simon Roberts Complete Java® 2 Certification: Study Guide Fifth Edition 16. La Biblia del Java 2 – Español Anaya Multimedia 16. http:// www.javasoft.com 17. http:// www.javaworld.com 18. http:// www.prenhall.com/deitel 19. http://www.javahispano.org/ 20. http://www.java.net/

revisores compañeros amigos que han creído en...

Documents

Transcript of revisores compañeros amigos que han creído en...