La descarga está en progreso. Por favor, espere

La descarga está en progreso. Por favor, espere

Capítulo 1. Tipos de Datos Abstractos y Programación Orientada a Objetos 1.1 Concepto de Tipo de Datos Abstracto. 1.2 Clasificación de Tipos de Datos Abstractos.

Presentaciones similares


Presentación del tema: "Capítulo 1. Tipos de Datos Abstractos y Programación Orientada a Objetos 1.1 Concepto de Tipo de Datos Abstracto. 1.2 Clasificación de Tipos de Datos Abstractos."— Transcripción de la presentación:

1 Capítulo 1. Tipos de Datos Abstractos y Programación Orientada a Objetos 1.1 Concepto de Tipo de Datos Abstracto. 1.2 Clasificación de Tipos de Datos Abstractos. 1.3 Especificación de Tipos de Datos Abstractos Especificaciones informales Especificaciones formales. 1.4 Programación Orientada a Objetos Clases y Objetos Clases y Objetos Propiedades y Métodos Herencia y Polimorfismo Pautas generales en diseño orientado a objetos Técnicas de implementación Implementaciones estáticas y dinámicas Representaciones contiguas y enlazadas Utilización correcta de objetos Privacidad de los objetos Previniendo efectos laterales Comparación de objetos Tratamiento de excepciones Ejemplos en Java.

2 1.1 Concepto y terminología · Tipos de Datos colección de valores + operaciones · Enteros, reales, booleanos, caracteres · Enumerados, subrango · Son opacos · Tipos Estructurados genericidad · Riesgo de crear valores sin semántica · Tipos de Datos Abstractos (TDA) · Tipos de datos creados por el programador, que deben ser opacos

3 1.1 Concepto y terminología · Tipos de Datos Abstractos: · Colección de valores + operaciones · Se definen mediante una especificación, que es independiente de cualquier representación (abstracción) · Acceso a los valores limitado al uso de las operaciones (interfaz con el usuario limitada) · Establecida la interfaz, el programador elige la representación adecuada (implementación) · Los usuarios del TDA sólo conocen su nombre y la especificación de las operaciones · Cambios en la representación no afectarán al resto de programas

4 1.1 Concepto y terminología · Tipos de Datos Abstractos: · El lenguaje de programación trata a los TDAs de igual forma que a sus propios tipos de datos, es decir, como tipos opacos: · Privacidad de la representación · Protección · Para que esto sea posible, la implementación deberá realizarse en un ámbito de declaración inaccesible al resto de los programas

5 1.1 Concepto y terminología · Tipos de Datos Abstractos: · El conjunto de operaciones ha de permitir generar cualquier valor del tipo · Existen dos piezas de documentación bien diferenciadas: · Especificación del TDA. Es lo único que conoce el usuario del TDA. Consiste en el nombre del TDA y la especificación de las operaciones. Tienen parte sintáctica y parte semántica · Implementación del TDA. Conocida sólo por el programador del TDA. Se realiza en un lenguaje de programación concreto. Consiste en la representación del tipo y en la realización de las operaciones

6 1.1 Concepto y terminología · Tipos de datos abstractos: · Se destacan los detalles (normalmente pocos) del comportamiento observable del tipo, que es estable. · Se ocultan los detalles (normalmente numerosos) de la implementación, que es propensa a cambios.

7 1.2 Clasificación de Tipos de Datos Abstractos · Tipos de Datos Abstractos simples: · Cambian su valor pero no su estructura espacio de almacenamiento constante · Enteros, reales, booleanos, carácter, enumerado, subrango, etc. · Tipos de Datos Abstractos contenedores: · Cambian su valor y estructura (colecciones de elementos de número variable) espacio de almacenamiento variable · Listas, colas, pilas, árboles, grafos, conjuntos, etc.

8 1.2 Clasificación de Tipos de Datos Abstractos · Tipos de datos abstractos inmutables: · Sus casos no pueden modificarse (se crean y destruyen, pero no existen operaciones de modificación) · Representación inmutable o mutable · Tipos de datos abstractos mutables: · Sus casos pueden modificarse (existen operaciones de modificación) · Representación mutable

9 1.3 Especificación de Tipos de Datos Abstractos Implementación del TDA RepresentaciónelegidaRepresentación de las operaciones + EspecificaciónUsuarioImplementador l TDA Colección de valores + Operaciones

10 1.3 Especificación de Tipos de Datos Abstractos · Especificaciones informales: · Predomina el lenguaje natural · Poco precisas y breves ambigüedad · Sencillas de escribir, leer y entender · Especificaciones formales: · Lenguaje algebraico verificación formal de programas · Precisas y breves · Pueden resultar más complejas de escribir, leer y entender

11 1.3.1 Especificaciones informales · Cabecera: Aparece el nombre de las operaciones. · Descripción: Se describe de forma general en qué consiste la abstracción, sin decir nada acerca de la implementación. Los casos del TDA pueden describirse en términos de otros tipos para los cuales se espera que el lector de la especificación esté más familiarizado. Se pueden utilizar gráficos y abstracciones matemáticas. Se puede incluir en la descripción si el TDA es mutable o inmutable · Especificación de las operaciones: Para la especificación de una abstracción operacional seguiremos el siguiente modelo: nombre de la operación (entrada) devuelve (salida) ·requerimientos: Esta cláusula muestra las restricciones de uso ·modifica: Esta cláusula identifica las entradas que van a ser modificadas ·efecto: Esta cláusula define el comportamiento

12 1.3.1 Especificaciones informales Observamos los siguientes componentes: · Cabecera: Es la información sintáctica. Se indica el nombre de la operación y el número, orden y tipos de sus entradas y salidas. Deben darse nombres para las entradas y pueden darse para las salidas · Cuerpo: Es la información semántica. Consta de las siguientes cláusulas: · Requerimientos: Restringen el dominio del procedimiento o función. Cuando introducimos requerimientos, obtenemos una abstracción operacional parcial (en caso contario se dice que la abstracción es total). El que use la abstracción es el responsable de que los requerimientos se cumplan; si estos no se cumplen, los resultados pueden ser impredecibles. Si la abstracción es total, la cláusula de requerimientos puede omitirse. Se supone como requerimiento implícito (y por tanto no tiene que ser explicitado en la cláusula de requerimientos) que las entradas que figuran en la lista de parámetros de la abstracción han sido correctamente construidas mediante algún constructor del tipo · Modifica: Indica los argumentos de entrada que cambian de valor tras una llamada a la abstracción operacional · Efecto: Se indica el efecto que se produce al ejecutar la operación para las entradas que cumplen los requerimientos. Debe definir qué salidas son producidas y también qué modificaciones son hechas en la lista de entradas de la cláusula modifica. La cláusula efecto se escribe bajo la asumpción de que se satisface la cláusula requerimientos, y no se dice nada sobre el efecto de la abstracción cuando dicha cláusula no se satisface

13 1.3 Especificación de Tipos de Datos Abstractos · El usuario de la abstracción es el responsable de que se cumplan los requerimientos · Implementaciones robustas: se autoprotegen frente a valores inconsistentes · Mecanismos de protección frente a errores: · Manejo de excepciones · Parámetros de salida de error en cada operación · Puesto que las especificaciones son independientes de las implementaciones, existen requerimientos de uso (información adicional de cara al usuario)

14 1.3.1 Especificaciones informales · Racional = tipo de datos es crea, num, den, suma, resta, multiplica, divide, simplifica · DESCRIPCIÓN: Los valores del TDA racional son números racionales. El TDA Racional es inmutable. · OPERACIONES: · crea(a,b:entero) devuelve (Racional) requerimientos: b<>0. efecto: Devuelve un número racional cuyo numerador es a y cuyo denominador es b. · num(a:Racional) devuelve (entero) efecto: Devuelve el numerador del número racional a. · den(a:Racional) devuelve (entero) efecto: Devuelve el denominador del número racional a. · suma(a,b:Racional) devuelve (Racional) efecto: Devuelve un número racional que es la suma de los números racionales a y b. · resta(a,b:Racional) devuelve (Racional) efecto: Devuelve un número racional que es la resta de los números racionales a y b. · multiplica(a,b:Racional) devuelve (Racional) efecto: Devuelve un número racional que es la multiplicación de los números racionales a y b. · divide(a,b:Racional) devuelve (Racional) efecto: Devuelve un número racional que es la división de los números racionales a y b. · simplifica(a:Racional) devuelve (Racional) efecto: Devuelve un número racional que es la simplificación del número racional a.

15 1.3.2 Especificaciones formales · Tipo: Nombre del TDA · Sintasis: Forma de las operaciones nombre de la función (tipo de los argumentos) tipo del resultado · Semántica: Significado de las operaciones nombre de la función (valores particulares) expresión del resultado

16 1.3.2 Especificaciones formales · No se definen reglas semánticas (se consideran axiomas) para ciertas funciones, como son algunas funciones constructoras o las funciones destructoras. · La expresión del resultado puede ser recursiva, conteniendo referencias a la misma función o a otras del TDA. · Las expresiones pueden contener referencias a otros tipos que consideramos predefinidos. En particular es importante considerar como predefinido el tipo booleano, con los valores cierto y falso, o el valor predefinido error, para indicar los valores de los argumentos en los que ciertas funciones parciales no están definidas. · Cualquier implementación del TDA deberá cumplir las condiciones impuestas por la semántica. · Las reglas han de intentar aplicarse en el orden indicado para la verificación formal de programas.

17 1.3.2 Especificaciones formales Para facilitar la escritura de las expresiones en la parte de semántica, se permite emplear expresiones condicionales, que adoptan la forma: si condición valor si cierto | valor si falso La condición será una expresión que toma un valor booleano. Se considera como predefinida la comparación de igualdad entre valores del mismo tipo, escrita como valor1 = valor2. Otra ampliación de la notación es permitir la definición de TDA's genéricos, que se expresan en base a otro u otros tipos sin especificar exactamente cuáles son.

18 1.3.2 Especificaciones formales · Tipo Bolsa (Elemento) · Sintaxis bolsavacia Bolsa poner(Bolsa,Elemento) Bolsa esvacia(Bolsa) booleano cuantos(Bolsa,Elemento) natural · Semántica b Bolsa, e,f Elemento: esvacia(bolsavacia) cierto esvacia(poner(b,e)) falso cuantos(bolsavacia,e) cero cuantos(poner(b,f),e) si f=e sucesor(cuantos(b,e)) | cuantos(b,e)

19 1.4 Programación Orientada a Objetos Características de la OO: Herencia Herencia Polimorfismo Polimorfismo Objetivos conseguidos: Estructuración Estructuración Encapsulación Encapsulación

20 1.4 Programación Orientada a Objetos Conceptos de la OO: Clase Clase Objeto Objeto Propiedad Propiedad Método Método Herencia Herencia Polimorfismo Polimorfismo

21 1.4 Programación Orientada a Objetos Estudiaremos: Principales técnicas de implementación de TDAs Principales técnicas de implementación de TDAs Realización de dichas técnicas mediante un lenguaje orientado a objetos, en concreto Java. Realización de dichas técnicas mediante un lenguaje orientado a objetos, en concreto Java.

22 1.4 Programación Orientada a Objetos Java: Diseñado desde el principio como un lenguaje orientado a objetos. Diseñado desde el principio como un lenguaje orientado a objetos. Integración en el ámbito de las telecomunicaciones, en concreto, internet. Integración en el ámbito de las telecomunicaciones, en concreto, internet. Lenguaje de gran actualidad e interés. Lenguaje de gran actualidad e interés.

23 1.4.1 Clases y Objetos Clase: Tipo de datos definido por el usuario. Objeto: Es un dato del tipo definido por su clase, es decir, es una instancia específica de su clase.

24 1.4.1 Clases y Objetos Fases de la vida de un objeto: Creación del Objeto: declaración + instanciaciónCreación del Objeto: declaración + instanciación Objeto instanciadoObjeto instanciado Destrucción del ObjetoDestrucción del Objeto Creación del Objeto: Constructor Objeto instanciado Destrucción del Objeto: Destructor

25 1.4.1 Clases y Objetos Declaración de una clase en Java: Class { } Declaración de un Objeto: Instanciación de un Objeto: mediante la palabra clave new Ejemplo: Class Vehiculo{ } Vehiculo miVehiculo; miVechiculo = new Vehiculo(); O en una sola línea: Vehiculo miVehiculo = new Vehiculo();

26 1.4.2 Propiedades y Métodos Campos de datos dentro de una clase: variables miembros o propiedades de la clase. Operaciones con los datos de una clase: funciones miembros o métodos de la clase. Los miembros de una clase (propiedades y métodos) pueden ser: -Públicos; se puede acceder a ellos desde fuera de la clase -Privados; sólo se puede acceder a ellos desde dentro de la clase Para acceder a propiedades privadas de la clase se definen métodos de acceso. Un miembro puede ser estático, si pertenece a la clase en sí y no a los objetos de la clase.

27 1.4.2 Propiedades y Métodos Definición en Java de una clase con sus propiedades y métodos: class { class { private ; private ; public ( ) { public ( ) { } public public ( ) { ( ) { }}

28 1.4.2 Propiedades y Métodos Palabras clave para restringir el acceso a los miembros de una clase: - public - private - protected Miembro estático: static

29 1.4.2 Propiedades y Métodos public class Vehiculo { private int numeroRuedas; private int numeroRuedas; private double velocidadMaxima; private double velocidadMaxima; public String nombrePropietario; public String nombrePropietario; static private String nombreFabrica = "SEAT"; static private String nombreFabrica = "SEAT"; public Vehiculo(int nRuedas) { public Vehiculo(int nRuedas) { if (nRuedas<0) numeroRuedas=0; if (nRuedas<0) numeroRuedas=0; else numeroRuedas = nRuedas; else numeroRuedas = nRuedas; } public void estableceVelocidadMaxima(double vMaxima) { public void estableceVelocidadMaxima(double vMaxima) { if (vMaxima<0) velocidadMaxima=0.0; if (vMaxima<0) velocidadMaxima=0.0; else velocidadMaxima = vMaxima; else velocidadMaxima = vMaxima; } public double recuperaVelocidadMaxima() { public double recuperaVelocidadMaxima() { return velocidadMaxima; return velocidadMaxima; } static public String recuperaNombreFabrica() { static public String recuperaNombreFabrica() { return nombreFabrica; return nombreFabrica; }}

30 1.4.2 Propiedades y Métodos Declaración e instanciación de un objeto: Vehiculo miVehiculo = new Vehiculo(4); Acceso a un dato publico: miVehiculo.nombrePropietario = Cipriano López; String nombre = miVehiculo.nombrePropietario; Acceso a un dato privado: miVehiculo.estableceVelocidadMaxima(200.0); Double velocidad = miVehiculo.recuperaVelocidadMaxima(); Acceso a un dato estático: String nombre = Vehiculo.recuperaNombreFabrica();

31 1.4.3 Herencia y Polimorfismo La herencia permite la reutilización de código. Las clases Motocicleta y Coche son subclases de Vehiculo, mientras que Vehiculo es la superclase de Motocicleta y Coche. Las clases Motocicleta y Coche heredan de la clase Vehiculo todas sus variables y métodos miembros. Vehiculo Motocicleta Coche

32 1.4.3 Herencia y Polimorfismo Herencia multinivel Vehiculo Motocicleta Coche CompactoMonovolumen

33 1.4.3 Herencia y Polimorfismo Conceptos de Polimorfismo: -Sobreescritura: reemplazar los métodos de la superclase en las subclases. -Sobrecarga: varios métodos se llaman igual, pero difieren en el número, tipo u orden de sus argumentos.

34 1.4.3 Herencia y Polimorfismo Declaración de subclases en Java public class Motocicleta extends Vehiculo { public Motocicleta() { public Motocicleta() { super(2); super(2); }}

35 1.4.3 Herencia y Polimorfismo public class Coche extends Vehiculo { private int numeroPuertas; private int numeroPuertas; public Coche(int nPuertas) { public Coche(int nPuertas) { super(4); super(4); numeroPuertas = nPuertas; numeroPuertas = nPuertas; } public Coche() { public Coche() { super(4); super(4); numeroPuertas = 4; numeroPuertas = 4; } public int recuperaNumeroPuertas() { public int recuperaNumeroPuertas() { return numeroPuertas; return numeroPuertas; }} Constructores sobrecargados Coche miCoche = new Coche(5); Coche miCoche = new Coche();

36 1.4.3 Herencia y Polimorfismo public class Monovolumen extends Coche { public Monovolumen() { public Monovolumen() { super(5); super(5); }} public class Compacto extends Coche { public Compacto() { public Compacto() { super(2); super(2); }}

37 1.4.4 Pautas generales en diseño orientado a objetos Hacer una lista de todas las propiedades y métodos que requiera el programa. Hacer una lista de todas las propiedades y métodos que requiera el programa. Clasificar dichas propiedades y métodos dentro de clases. Clasificar dichas propiedades y métodos dentro de clases. Examinar las clases para ver las posibles relaciones de herencia. Examinar las clases para ver las posibles relaciones de herencia. Establecer los métodos necesarios para realizar la interface entre las diversas clases. Establecer los métodos necesarios para realizar la interface entre las diversas clases. Comprobar que dentro de la estructura de clases todo encaja. Comprobar que dentro de la estructura de clases todo encaja. Realizar un buen diseño supone: Ahorro e tiempo y esfuerzo en la fase de programar Ahorro e tiempo y esfuerzo en la fase de programar Código resultante de mayor calidad: más fácil de depurar y mantener Código resultante de mayor calidad: más fácil de depurar y mantener

38 1.4.5 Técnicas de implementación · Implementaciones estáticas y dinámicas · Representaciones contiguas y enlazadas

39 Implementaciones estáticas y dinámicas · Implementaciones estáticas asignación de memoria en tiempo de compilación · Implementaciones dinámicas asignación de memoria en tiempo de ejecución

40 Implementaciones éstáticas y dinámicas · Variables dinámicas: · Variables cuyo espacio de almacenamiento requerido se asigna en tiempo de ejecución · Se accede a ellas por medio de apuntadores Podemos crear variables dinámicas asignándoles memoria Podemos crear variables dinámicas asignándoles memoria · Podemos destruir variables dinámicas liberando memoria · Se alojan en el segmento montón (heap)

41 Implementaciones éstáticas y dinámicas · En Programación Orientada a Objetos: · Un Objeto es internamente un apuntador a los datos que lo componen. · Cuando se crea un objeto mediante su constructor, la reserva de memoria se hace de forma dinámica. · La liberación de memoria se realiza mediante el destructor del objeto; en Java esto se realiza de forma automática mediante el Garbaje Collector. · El uso de objetos abstrae al programador del manejo directo de apuntadores y ofrece mecanismos para conseguir privacidad y protección.

42 Representaciones contiguas y enlazadas En la representación de TDAs formados por colecciones de elementos, nos encontramos las siguientes situaciones: 1. La cantidad de elementos de los casos del TDA es fija y conocida a priori (en tiempo de compilación) 2. La cantidad de elementos de los casos del TDA es fija, pero se conoce en tiempo de ejecución 3. La cantidad de elementos de los casos del TDA es variable en tiempo de ejecución

43 Representaciones contiguas y enlazadas Ante la situación (1) probablemente la mejor opción es representar los casos del TDA mediante un array. public class Estructura { public Object dato[]; public Object dato[]; static private int longitud = 10; static private int longitud = 10; public Estructura() { public Estructura() { dato = new Object[longitud]; dato = new Object[longitud]; } // resto de métodos de la clase // resto de métodos de la clase } // fin class Estructura Estructura estructura; estructura = new Estructura(); estructura.dato[i]=x;y=estructura.dato[i];

44 Representaciones contiguas y enlazadas Para la situación (2), Java permite la siguiente forma de representación contigua: public class Estructura { public Object dato[]; public Object dato[]; private int longitud; private int longitud; public Estructura(int n) { public Estructura(int n) { longitud = n; longitud = n; dato = new Object[n]; dato = new Object[n]; } // resto de métodos de la clase // resto de métodos de la clase } // fin class Estructura Estructura estructura; estructura = new Estructura(10);

45 Representaciones contiguas y enlazadas Para la situación (3) disponemos de varias alternativas. Si sabemos en tiempo de compilación el número aproximado de elementos, se puede establecer una cantidad máxima maxLongitud de elementos que podrán contener los casos del TDA public class Estructura { public Object dato[]; public Object dato[]; static private int maxLongitud = 100; static private int maxLongitud = 100; private int longitud = 0; private int longitud = 0; public Estructura() { public Estructura() { dato = new Object[maxLongitud]; dato = new Object[maxLongitud]; } // resto de métodos de la clase // resto de métodos de la clase } // fin class Estructura

46 Representaciones contiguas y enlazadas Cuando en tiempo de compilación no sabemos ni siquiera de forma aproximada el número de elementos es conveniente utilizar una representación enlazada: public class Estructura { class Celda { class Celda { Object dato; Object dato; Celda siguiente; Celda siguiente; } private Celda inicio; private Celda inicio; // métodos de la clase Estructura // métodos de la clase Estructura } // fin class Estructura

47 1.4.6 Utilización correcta de objetos · Privacidad de los objetos · Prevención de efectos laterales · Comparación de objetos · Tratamiento de excepciones

48 Privacidad de los Objetos Declarar los campos de los objetos como privados Ofrecer métodos públicos para su acceso public class Elemento { private int dato; private int dato; public Elemento(int valor) { public Elemento(int valor) { dato = valor; dato = valor; } public int valor() { public int valor() { return dato; return dato; } } // fin class Elemento Elemento elemento = new Elemento(10); int n = elemento.valor();

49 Previniendo efectos laterales Utilización del método clone public class Elemento implements Cloneable { private int dato; private int dato; public Elemento(int valor) { public Elemento(int valor) { dato = valor; dato = valor; } public Object clone() { public Object clone() { return new Elemento(dato); return new Elemento(dato); } } // fin class Elemento elemento1 = (Elemento)elemento2.clone();

50 Comparación de objetos Utilización del método equals public class Elemento { private int dato; private int dato; public Elemento(int valor) { public Elemento(int valor) { dato = valor; dato = valor; } public Object clone() { public Object clone() { return new Elemento(dato); return new Elemento(dato); } public boolean equals(Object elemento) { public boolean equals(Object elemento) { if (elemento==null) return false; if (elemento==null) return false; Elemento e = (Elemento)elemento; Elemento e = (Elemento)elemento; return (dato==e.dato); return (dato==e.dato); } } // fin class Elemento if (elemento1.equals(elemento2)) { // cuerpo de la sentencia condicional // cuerpo de la sentencia condicional}

51 Comparación de objetos Utilización del método toString public class Elemento { private int dato; private int dato; public Elemento(int valor) { public Elemento(int valor) { dato = valor; dato = valor; } public Object clone() { public Object clone() { return new Elemento(dato); return new Elemento(dato); } public boolean equals(Object elemento) { public boolean equals(Object elemento) { if (elemento==null) return false; if (elemento==null) return false; Elemento e = (Elemento)elemento; Elemento e = (Elemento)elemento; return (dato==e.dato); return (dato==e.dato); } public toString(){ public toString(){ return ""+dato; return ""+dato; } } // fin class Elemento System.out.println(elemento);

52 Comparación de objetos import java.io.*; public class Util { static public int leeEntero() throws IOException { static public int leeEntero() throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int i = Integer.valueOf(br.readLine().trim()).intValue(); int i = Integer.valueOf(br.readLine().trim()).intValue(); return i; return i; } static public double leeDoble() throws IOException { static public double leeDoble() throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); double d = Double.valueOf(br.readLine().trim()).doubleValue(); double d = Double.valueOf(br.readLine().trim()).doubleValue(); return d; return d; } static public String leeString() throws IOException { static public String leeString() throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String s = br.readLine(); String s = br.readLine(); return s; return s; }}

53 Comparación de objetos Interface Comparable public interface Comparable { public boolean mayorQue(Object elemento); public boolean mayorQue(Object elemento); public boolean mayorIgualQue(Object elemento); public boolean mayorIgualQue(Object elemento); public boolean menorQue(Object elemento); public boolean menorQue(Object elemento); public boolean menorIgualQue(Object elemento); public boolean menorIgualQue(Object elemento); } // fin interface Comparable Interface Valuable public interface Valuable { public int valor(); public int valor(); } // fin interface Valuable

54 Comparación de objetos public class Elemento implements Cloneable, Comparable, Valuable { private int dato; private int dato; public Elemento(int valor) { public Elemento(int valor) { dato = valor; dato = valor; } public int valor() { public int valor() { return dato; return dato; } public Object clone() { public Object clone() { return new Elemento(dato); return new Elemento(dato); }

55 Comparación de objetos public boolean equals(Object elemento) { public boolean equals(Object elemento) { if (elemento==null) return false; if (elemento==null) return false; Elemento e = (Elemento)elemento; Elemento e = (Elemento)elemento; return (dato==e.dato); return (dato==e.dato); } public toString() { public toString() { return ""+dato; return ""+dato; } public boolean mayorQue(Object elemento) { public boolean mayorQue(Object elemento) { Elemento e = (Elemento)elemento; Elemento e = (Elemento)elemento; return (dato>e.dato); return (dato>e.dato); }

56 Comparación de objetos public boolean mayorIgualQue(Object elemento) { public boolean mayorIgualQue(Object elemento) { Elemento e = (Elemento)elemento; Elemento e = (Elemento)elemento; return (dato>=e.dato); return (dato>=e.dato); } public boolean menorQue(Object elemento) { public boolean menorQue(Object elemento) { Elemento e = (Elemento)elemento; Elemento e = (Elemento)elemento; return (dato

57 Tratamiento de excepciones - Java posee un mecanismo propio para el manejo de errores mediante excepciones - Cuando va a producirse una situación de error, ésta se traduce una excepción. - Por ejemplo, para la segunda definición de la clase Estructura vista en la sección anterior, el acceso a los datos del array debe hacerse mediante métodos de interface, y dentro de estos métodos, el acceso a una posicion no correcta puede traducirse en una excepción public class Estructura { private Object dato[]; private Object dato[]; private int longitud; private int longitud; public Estructura(int n) throws LongitudNoValidaException { public Estructura(int n) throws LongitudNoValidaException { if (n<0) throw new LongitudNoValidaException("Longitud if (n<0) throw new LongitudNoValidaException("Longitud no válida. Debe ser positiva"); no válida. Debe ser positiva"); longitud = n; longitud = n; dato = new Object[n]; dato = new Object[n]; }

58 Tratamiento de excepciones public Object recuperaDato(int i) throws IndiceNoValidoException { public Object recuperaDato(int i) throws IndiceNoValidoException { if ((i =longitud)) throw new IndiceNoValidoException("Indice if ((i =longitud)) throw new IndiceNoValidoException("Indice no válido. Debe estar entre 0 y "+longitud-1); no válido. Debe estar entre 0 y "+longitud-1); return dato[i]; return dato[i]; } public void estableceDato(int i, Object valor) public void estableceDato(int i, Object valor) throws IndiceNoValidoException { throws IndiceNoValidoException { if ((i =longitud)) throw new IndiceNoValidoException("Indice if ((i =longitud)) throw new IndiceNoValidoException("Indice no válido. Debe estar entre 0 y "+longitud-1); no válido. Debe estar entre 0 y "+longitud-1); dato[i] = valor; dato[i] = valor; } } // fin class Estructura

59 Tratamiento de excepciones Podemos crear nuevas excepciones como clases que heredan de la clase Exception public class LongitudNoValidaException extends Exception { public LongitudNoValidaException() { super(); }; public LongitudNoValidaException() { super(); }; public LongitudNoValidaException(String s) { super(s); }; public LongitudNoValidaException(String s) { super(s); };} public class IndiceNoValidoException extends Exception { public IndiceNoValidoException() { super(); }; public IndiceNoValidoException() { super(); }; public IndiceNoValidoException(String s) { super(s); }; public IndiceNoValidoException(String s) { super(s); };}

60 Tratamiento de excepciones Para utilizar las llamadas a métodos con excepciones, se deben manejar dichas excepciones mediante bloques try catch try { Estructura estructura = new Estructura(10); Estructura estructura = new Estructura(10); estructura.estableceDato(0,elemento); estructura.estableceDato(0,elemento); elemento = estructura.recuperaDato(0); elemento = estructura.recuperaDato(0); } catch (LongitudNoValidaException e) { System.err.println(e); System.err.println(e); } catch (IndiceNoValidoException e) { System.err.println(e); System.err.println(e);}

61 1.4.7 Ejemplos en Java · Para terminar este capítulo mostraremos la implementación en Java de los TDAs racional y bolsa. · El TDA racional es un TDA simple que se ha definido como inmutable. · El TDA bolsa es un TDA contenedor que se ha definido como mutable y se ha implementado utilizando representación enlazada. · Para el TDA racional se ha incluido manejo de excepciones, así como las operaciones toString, equals y clone. · En el caso del TDA bolsa no se ha incluido manejo de excepciones porque no se ha contemplado ninguna situación de error.

62 1.4.7 Ejemplos en Java public class Racional implements Cloneable { private int num, den; private int num, den; public Racional(int n, int d) { public Racional(int n, int d) { if (d==0) throw new DenominadorCeroException("El if (d==0) throw new DenominadorCeroException("El denominador no puede ser cero"); denominador no puede ser cero"); num = n; num = n; den = d; den = d; } static private int mcd(int m, int n) { static private int mcd(int m, int n) { int t; int t; while(m>0) { while(m>0) { t=m; t=m; m=n%m; m=n%m; n=t; n=t; } return n; return n; }

63 1.4.7 Ejemplos en Java public int numerador() { public int numerador() { return num; return num; } public int denominador() { public int denominador() { return den; return den; } static public Racional suma(Racional a, Racional b) { static public Racional suma(Racional a, Racional b) { int n = (a.num*b.den)+(b.num*a.den); int n = (a.num*b.den)+(b.num*a.den); int d = a.den*b.den; int d = a.den*b.den; return new Racional(n,d); return new Racional(n,d); } static public Racional resta(Racional a, Racional b) { static public Racional resta(Racional a, Racional b) { int n = (a.num*b.den)-(b.num*a.den); int n = (a.num*b.den)-(b.num*a.den); int d = a.den*b.den; int d = a.den*b.den; return new Racional(n,d); return new Racional(n,d); }

64 1.4.7 Ejemplos en Java static public Racional multiplica(Racional a, Racional b) { static public Racional multiplica(Racional a, Racional b) { int n = a.num*b.num; int n = a.num*b.num; int d = a.den*b.den; int d = a.den*b.den; return new Racional(n,d); return new Racional(n,d); } static public Racional divide(Racional a, Racional b) { static public Racional divide(Racional a, Racional b) { int n = a.num*b.den; int n = a.num*b.den; int d = a.den*b.num; int d = a.den*b.num; return new Racional(n,d); return new Racional(n,d); } static public Racional simplifica(Racional a) { static public Racional simplifica(Racional a) { int x = mcd(Math.abs(a.num),Math.abs(a.den)); int x = mcd(Math.abs(a.num),Math.abs(a.den)); int n = a.num/x; int n = a.num/x; int d = a.den/x; int d = a.den/x; return new Racional(n,d); return new Racional(n,d); }

65 1.4.7 Ejemplos en Java public String toString() { public String toString() { return (num+"/"+den); return (num+"/"+den); } public boolean equals(Object o) { public boolean equals(Object o) { Racional r1 = simplifica(this); Racional r1 = simplifica(this); Racional r2 = simplifica((Racional)o); Racional r2 = simplifica((Racional)o); return ((r1.num==r2.num)&&(r1.den==r2.den)); return ((r1.num==r2.num)&&(r1.den==r2.den)); } public Object clone() { public Object clone() { Racional r = new Racional(num,den); Racional r = new Racional(num,den); return r; return r; } } // fin class Racional

66 1.4.7 Ejemplos en Java public class DenominadorCeroException extends RuntimeException { public class DenominadorCeroException extends RuntimeException { public DenominadorCeroException() { super(); }; public DenominadorCeroException() { super(); }; public DenominadorCeroException(String s) { super(s); }; public DenominadorCeroException(String s) { super(s); }; }

67 1.4.7 Ejemplos en Java public class Bolsa { class Celda { class Celda { Object dato; Object dato; Celda siguiente; Celda siguiente; } private Celda inicio; private Celda inicio; public Bolsa() { public Bolsa() { inicio = null; inicio = null; } public void poner(Object elemento) { public void poner(Object elemento) { Celda aux = new Celda(); Celda aux = new Celda(); aux.dato = elemento; aux.dato = elemento; aux.siguiente = inicio; aux.siguiente = inicio; inicio = aux; inicio = aux; }

68 1.4.7 Ejemplos en Java public boolean esVacia() { public boolean esVacia() { return (inicio==null); return (inicio==null); } public int cuantos(Object elemento) { public int cuantos(Object elemento) { Celda aux = inicio; Celda aux = inicio; int cont = 0; int cont = 0; while (aux!=null) { while (aux!=null) { if (elemento.equals(aux.dato)) cont++; if (elemento.equals(aux.dato)) cont++; aux = aux.siguiente; aux = aux.siguiente; } return cont; return cont; } } // fin class Bolsa


Descargar ppt "Capítulo 1. Tipos de Datos Abstractos y Programación Orientada a Objetos 1.1 Concepto de Tipo de Datos Abstracto. 1.2 Clasificación de Tipos de Datos Abstractos."

Presentaciones similares


Anuncios Google