Programación avanzada en Java Miguel Ángel Corella 23

Programación avanzada en Java Miguel Ángel Corella 23 de Septiembre de 2005

Funciones matemáticas • Constantes: Math. PI, Math. E • Métodos (mirar los parámetros en la API): § § § § sqrt pow random abs max round cos § § § sin tan acos exp log … • Todos los métodos y constantes son estáticos (acceso Math. xxx).

Escritura de ficheros de texto • Clase java. io. Print. Stream. • Funciona igual que System. out, pero se imprime a un fichero. Print. Stream printer = new Print. Stream (new File. Output. Stream ("abc. txt")); printer. print ("Dos + " + 2); printer. println (" = " + (2+2)); . . . printer. close (); • Emite la excepción: java. io. IOException

Lectura de ficheros de texto • Clase java. io. Buffered. Reader • Funciona igual que System. in, pero se lee de un fichero. Buffered. Reader reader = new Buffered. Reader (new File. Reader ("abc. txt")); String str = reader. read. Line (); . . . reader. close (); • Emite la excepción: java. io. IOException

Jerarquías de clases

Definición de subclases class Persona { String nombre; int edad; String descripcion () { return "Nombre: " + nombre + "n. Edad: " + edad; } } class Empleado extends Persona { long sueldo. Bruto; Directivo jefe; } class Directivo extends Empleado { int categoria; Vector subordinados = new Vector (); void promocionar () { categoria++; } }

Jerarquía de tipos (I) Persona x 1, x 2; Empleado y, emp = new Empleado (); Directivo z, dir = new Directivo (); • Conversión automática implícita (generalización) x 1 = emp; // Empleado Persona x 2 = dir; // Directivo Persona y • = dir; // Directivo Empleado Un Directivo puede hacer automáticamente el papel de Empleado y de Persona Conversión explícita (especialización), responsabilidad del programador z = x 2; // Error de compilación z = (Directivo) x 2; // Persona Directivo z = (Directivo) x 1; // Error de ejecución: // x 1 no es un Directivo Una Persona puede hacer el papel de Directivo si realmente es un Directivo z = (Perro) x 1; // Error de compilación (a menos que Perro // fuese subclase o superclase de Persona)

Jerarquía de tipos (y II) class C { void f (Empleado p) {. . . } void g (Directivo p) {. . . } } Directivo dir = new Directivo (); Empleado x, emp = new Empleado (); C c = new C (); • Conversión implícita c. f (dir); // Directivo Empleado • Conversión explícita c. g (x); // Error de compilación c. g ((Directivo) x); // Empleado Directivo c. g ((Directivo) emp); // Error de ejecución: emp no es // un Directivo

Herencia de variables y métodos Empleado emp = new Empleado (); Directivo dir = new Directivo (); emp. nombre = "Pedro"; emp. edad = 28; emp. sueldo. Base = 200; emp. jefe = dir; System. out. println (emp. descripcion ()); dir. nombre = "Maria"; dir. edad = 45; dir. sueldo. Bruto = 700; dir. jefe = null; dir. categoria = 3; System. out. println (dir. descripcion ());

Herencia y jerarquía de tipos categoría Directivo sueldo jefe Empleado dir emp nombre edad Persona p

Sobreescritura en herencia • Redefinición de variables y métodos de una clase padre en una subclase • La definición de la subclase oculta a la de la superclase • La definición de la superclase accesible desde la subclase con super • Sobreescritura de métodos (especialización) – El método se redefine con los mismos argumentos y tipo de retorno – Si no coinciden los tipos de los argumentos, se trata de una sobrecarga – No se puede aumentar la privacidad de los métodos sobreescritos – Evita la proliferación de identificadores – Permite la ligadura dinámica • Sobreescritura de variables – Se reserva un espacio de memoria para cada definición – El tipo no tiene por qué coincidir – En general es preferible evitar la sobreescritura de variables

Sobreescritura de métodos class Empleado extends Persona { long sueldo. Bruto; Directivo jefe; String descripcion () { return "Nombre: " + nombre + "n. Edad: " + edad + "n. Sueldo: " + sueldo. Bruto + "n. Jefe: " + ((jefe == null)? nombre : jefe. nombre); } } // Bloque main Empleado emp = new Empleado (); Persona p = emp; emp. descripcion (); // descripcion de Empleado

Ligadura dinámica • La sobreescritura de métodos se resuelve por ligadura dinámica en tiempo de ejecución • Se ejecuta la definición del método de la clase más específica del objeto, independientemente de cómo se ha declarado la referencia al objeto A void f () B void f () E obj = new E(); A x = obj; C x. f(); D E void f () obj pertenece a las clases A, B, C, D, E x declarado como A, apunta a un E se ejecuta la versión de f definida en D

Ejemplo de ligadura dinámica (I) class Persona { String nombre; int edad; String descripcion () { return "Nombre: " + nombre + "n. Edad: " + edad; } } class Empleado extends Persona { long sueldo. Bruto; Directivo jefe; String descripcion () { return "Nombre: " + nombre + "n. Edad: " + edad + "n. Sueldo: " + sueldo. Bruto + "n. Jefe: " + ((jefe == null)? nombre : jefe. nombre); } }

Ejemplo de ligadura dinámica (II) class Directivo extends Empleado { int categoria; Vector subordinados = new Vector (); String descripcion () { return "Nombre: " + nombre + "n. Edad: " + edad + "n. Sueldo: " + sueldo. Bruto + "n. Jefe: " + ((jefe == null)? nombre : jefe. nombre) + "n. Categoria: " + categoria; } void promocionar () { categoria++; } }

Ejemplo de ligadura dinámica (y III) // Bloque main Directivo dir = new Directivo (); Empleado emp = new Empleado (); Empleado z = dir; Persona p = new Persona (); Persona x = emp; Persona y = z; p. descripcion (); emp. descripcion (); dir. descripcion (); x. descripcion (); y. descripcion (); z. descripcion (); y. promocionar (); // // descripcion descripcion ERROR de de de Persona Empleado Directivo

Interfaces

Motivación de interfaces (I) // Algoritmo de ordenacion public class Algoritmos { public static void ordenar (double valores[]) { int i, j; for (i = 0; i < valores. length; i++) for (j = valores. length; j > i; j--) if (valores[j] < valores[j-1]) intercambiar (valores, j, j-1); } }

Motivación de interfaces (y II) • ¿Y si queremos ordenar valores int? • Las interfaces permiten generalizar funcionalidad. // Generalizacion Interfaz (o capacidad) cumplida por los objetos que se pueden ordenar public class Algoritmos { public static void ordenar (Ordenable valores[]) { int i, j; for (i = 0; i < valores. length; i++) for (j = valores. length; j > i; j--) if (valores[j]. menor (valores[j-1])) intercambiar (valores, j, j-1); } Método que deben } implementar todos los objetos que se pueden ordenar

Solución al problema (I) interface Ordenable { boolean menor (Ordenable valor); } class Directivo extends Empleado implements Ordenable {. . . public boolean menor (Ordenable dir) { return categoria < ((Directivo) dir). categoria; } } class Figura implements Ordenable {. . . public boolean menor (Ordenable fig) { return area () < ((Figura) fig). area (); } }

Solución al problema (y II) public static void main (String args[]) { Directivo jefes[] = { new Directivo (. . . ), new Directivo (. . . ) }; Figura objcompuesto[] = { new Triangulo (. . . ), new Circulo (. . . ), new Rectangulo (. . . ) }; Algoritmos. ordenar (jefes); Algoritmos. ordenar (objcompuesto); }

¿Qué es una interfaz? • Colección de métodos sin definir y valores constantes • Extender de una clase implementar una interfaz • Una clase puede implementar varias interfaces

¿Para qué sirve una interfaz? • Una interfaz impone un protocolo de métodos a implementar • Una interfaz introduce un nuevo tipo • Las clases que implementan la interfaz son compatibles con este tipo • Las interfaces posibilitan la herencia múltiple en cuanto a jerarquía de tipos: • Una interfaz define un tipo una clase puede tener múltiples supertipos • Sin embargo una interfaz no tiene contenido que heredar: – los métodos no tienen código – las variables se heredan pero son inamovibles (son estáticas y constantes) • Una interfaz no proporciona funcionalidad a un objeto, sino la posibilidad de ser objeto de la funcionalidad de otros objetos

Programación avanzada en Java Miguel Ángel Corella 23 de Septiembre de 2005