Capítulo 1. Tipos de Datos Abstractos y

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.
1.3.1 Especificaciones informales.
1.3.2 Especificaciones formales.
1.4 Programación Orientada a Objetos
1.4.1 Clases y Objetos.
1.4.2 Propiedades y Métodos.
1.4.3 Herencia y Polimorfismo.
1.4.4 Pautas generales en diseño orientado a objetos.
1.4.5 Técnicas de implementación
1.4.5.1 Implementaciones estáticas y dinámicas.
1.4.5.2 Representaciones contiguas y enlazadas.
1.4.6 Utilización correcta de objetos.
1.4.6.1 Privacidad de los objetos.
1.4.6.2 Previniendo efectos laterales.
1.4.6.3 Comparación de objetos.
1.4.6.4 Tratamiento de excepciones.
1.4.7 Ejemplos en Java.
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
❷ 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

❷ El lenguaje de programación trata a los TDA’s 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

❷ 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
❷ 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.
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.
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
1.3 Especificación de Tipos de Datos Abstractos
● TDA → Colección de valores + Operaciones
Usuario Especificación Implementador
Implementación Representación Representación

→ +
del TDA elegida de las operaciones
❷ 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
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
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
❷ 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)
❷ 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.
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
❷ 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.
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.
❷ 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)
1.4 Programación Orientada a
Objetos
Características de la OO:
• Herencia
• Polimorfismo
Objetivos conseguidos:
• Estructuración
• Encapsulación
Objetos
Conceptos de la OO:
• Clase
• Objeto
• Propiedad
• Método
• Herencia
• Polimorfismo
Objetos
Estudiaremos:
• Principales técnicas de implementación
de TDA’s
• Realización de dichas técnicas
mediante un lenguaje orientado a
objetos, en concreto Java.
Objetos
Java:
• Diseñado desde el principio como un
lenguaje orientado a objetos.
• Integración en el ámbito de las
telecomunicaciones, en concreto,
internet.
• Lenguaje de gran actualidad e interés.
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.
Fases de la vida de un objeto:

• Creación del Objeto: declaración + instanciación
• Objeto instanciado
• Destrucción del Objeto
Creación del Objeto: Destrucción del Objeto:

Objeto instanciado
Constructor Destructor
Declaración de una clase en Java:
Class <nombre_de_la_clase> { }
Declaración de un Objeto:
<nombre_de_la_clase> <nombre_del_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();
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.
Definición en Java de una clase con sus propiedades y métodos:
<modificador> class <nombre_de_la_clase> {

private <tipo_de_dato> <nombre_del_dato>;
public <nombre_de_la_clase> (<lista_de_argumentos>) {
<codigo_del_metodo_constructor>
}
public <tipo_de_dato_devuelto> <nombre_del_metodo>
(<lista_de_argumentos>) {
<codigo_del_metodo>
}
}
Palabras clave para restringir el acceso a los

miembros de una clase:
- public
- private
- protected
Miembro estático: static

public class Vehiculo {
private int numeroRuedas;
private double velocidadMaxima;
public String nombrePropietario;
static private String nombreFabrica = "SEAT";
public Vehiculo(int nRuedas) {
if (nRuedas<0) numeroRuedas=0;
else numeroRuedas = nRuedas;
}
public void estableceVelocidadMaxima(double vMaxima) {
if (vMaxima<0) velocidadMaxima=0.0;
else velocidadMaxima = vMaxima;
}
public double recuperaVelocidadMaxima() {
return velocidadMaxima;
}
static public String recuperaNombreFabrica() {
return nombreFabrica;
}
}
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();
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
Herencia multinivel
Vehiculo
Motocicleta Coche
Compacto Monovolumen
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.
Declaración de subclases en Java

public class Motocicleta extends Vehiculo {
public Motocicleta() {
super(2);
}
}
public class Coche extends Vehiculo {
private int numeroPuertas;
public Coche(int nPuertas) {
super(4);
numeroPuertas = nPuertas;
}
public Coche() {
super(4);
numeroPuertas = 4;
}
public int recuperaNumeroPuertas() {
return numeroPuertas;
}
}
Constructores sobrecargados
Coche miCoche = new Coche(5);
Coche miCoche = new Coche();
public class Monovolumen extends Coche {

public Monovolumen() {
super(5);
}
}
public class Compacto extends Coche {

public Compacto() {
super(2);
}
}
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.
• Clasificar dichas propiedades y métodos dentro de clases.
• Examinar las clases para ver las posibles relaciones de
herencia.
• Establecer los métodos necesarios para realizar la interface
entre las diversas clases.
• 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
• Código resultante de mayor calidad: más fácil de depurar y
mantener
1.4.5 Técnicas de implementación
❷ Implementaciones estáticas y dinámicas
❷ Representaciones contiguas y enlazadas

1.4.5.1 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
1.4.5.1 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 destruir variables dinámicas liberando memoria
❷ Se alojan en el segmento montón (heap)
1.4.5.1 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.
1.4.5.2 Representaciones contiguas y
enlazadas
En la representación de TDA’s 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
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[];
static private int longitud = 10;
public Estructura() {
dato = new Object[longitud];
}
// resto de métodos de la clase
} // fin class Estructura
Estructura estructura;
estructura = new Estructura();
estructura.dato[i]=x;
y=estructura.dato[i];
enlazadas
Para la situación (2), Java permite la siguiente forma de
representación contigua:

private int longitud;
public Estructura(int n) {
longitud = n;
dato = new Object[n];
}
Estructura estructura;
estructura = new Estructura(10);
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

static private int maxLongitud = 100;
private int longitud = 0;
public Estructura() {
dato = new Object[maxLongitud];
}
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:

class Celda {
Object dato;
Celda siguiente;
}
private Celda inicio;
// métodos de la clase Estructura
1.4.6 Utilización correcta de objetos
 Privacidad de los objetos

 Prevención de efectos laterales
 Comparación de objetos
 Tratamiento de excepciones
1.4.6.1 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;
public Elemento(int valor) {
dato = valor;
}
public int valor() {
return dato;
}
} // fin class Elemento
Elemento elemento = new Elemento(10);

int n = elemento.valor();
1.4.6.2 Previniendo efectos laterales
Utilización del método clone

public class Elemento implements Cloneable {
private int dato;
dato = valor;
}
public Object clone() {
return new Elemento(dato);
}
elemento1 = (Elemento)elemento2.clone();
1.4.6.3 Comparación de objetos
Utilización del método equals

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

private int dato;
dato = valor;
}
}
}
public toString(){
return ""+dato;
}
System.out.println(elemento);
import java.io.*;
public class Util {
static public int leeEntero() throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int i = Integer.valueOf(br.readLine().trim()).intValue();
return i;
}
static public double leeDoble() throws IOException {
double d = Double.valueOf(br.readLine().trim()).doubleValue();
return d;
}
static public String leeString() throws IOException {
String s = br.readLine();
return s;
}
}
Interface Comparable
public interface Comparable {
public boolean mayorQue(Object elemento);
public boolean mayorIgualQue(Object elemento);
public boolean menorQue(Object elemento);
public boolean menorIgualQue(Object elemento);
} // fin interface Comparable
Interface Valuable
public interface Valuable {
public int valor();
} // fin interface Valuable
public class Elemento implements Cloneable,

Comparable, Valuable {
private int dato;
dato = valor;
}
public int valor() {
return dato;
}

}

}
public toString() {
return ""+dato;
}
public boolean mayorQue(Object elemento) {
return (dato>e.dato);
}
public boolean mayorIgualQue(Object elemento) {

return (dato>=e.dato);
}
public boolean menorQue(Object elemento) {
return (dato<e.dato);
}
public boolean menorIgualQue(Object elemento) {
return (dato<=e.dato);
}
1.4.6.4 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
private Object dato[];
private int longitud;
public Estructura(int n) throws LongitudNoValidaException {
if (n<0) throw new LongitudNoValidaException("Longitud
no válida. Debe ser positiva");
longitud = n;
dato = new Object[n];
}
public Object recuperaDato(int i) throws IndiceNoValidoException {

if ((i<0)||(i>=longitud)) throw new IndiceNoValidoException("Indice
no válido. Debe estar entre 0 y "+longitud-1);
return dato[i];
}
public void estableceDato(int i, Object valor)
throws IndiceNoValidoException {
if ((i<0)||(i>=longitud)) throw new IndiceNoValidoException("Indice
no válido. Debe estar entre 0 y "+longitud-1);
dato[i] = valor;
}
Podemos crear nuevas excepciones como clases

que heredan de la clase Exception
public class LongitudNoValidaException extends Exception {
public LongitudNoValidaException() { super(); };
public LongitudNoValidaException(String s) { super(s);
};
}
public class IndiceNoValidoException extends Exception {
public IndiceNoValidoException() { super(); };
public IndiceNoValidoException(String s)
{ super(s); };
}
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.estableceDato(0,elemento);
elemento = estructura.recuperaDato(0);
} catch (LongitudNoValidaException e) {
System.err.println(e);
} catch (IndiceNoValidoException e) {
System.err.println(e);
}
1.4.7 Ejemplos en Java
❷ Para terminar este capítulo mostraremos la implementación

en Java de los TDA’s 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.
public class Racional implements Cloneable {
private int num, den;
public Racional(int n, int d) {
if (d==0) throw new DenominadorCeroException("El
denominador no puede ser cero");
num = n;
den = d;
}
static private int mcd(int m, int n) {
int t;
while(m>0) {
t=m;
m=n%m;
n=t;
}
return n;
}
public int numerador() {

return num;
}
public int denominador() {
return den;
}
static public Racional suma(Racional a, Racional b) {
int n = (a.num*b.den)+(b.num*a.den);
int d = a.den*b.den;
return new Racional(n,d);
}
static public Racional resta(Racional a, Racional b) {
int n = (a.num*b.den)-(b.num*a.den);
}
static public Racional multiplica(Racional a, Racional b) {

int n = a.num*b.num;
}
static public Racional divide(Racional a, Racional b) {
int n = a.num*b.den;
int d = a.den*b.num;
}
static public Racional simplifica(Racional a) {
int x = mcd(Math.abs(a.num),Math.abs(a.den));
int n = a.num/x;
int d = a.den/x;
}
public String toString() {

return (num+"/"+den);
}
public boolean equals(Object o) {
Racional r1 = simplifica(this);
Racional r2 = simplifica((Racional)o);
return ((r1.num==r2.num)&&(r1.den==r2.den));
}
Racional r = new Racional(num,den);
return r;
}
} // fin class Racional
public class DenominadorCeroException extends RuntimeException

{
public DenominadorCeroException() { super(); };
public DenominadorCeroException(String s) { super(s); };
}
public class Bolsa {

class Celda {
Object dato;
Celda siguiente;
}
private Celda inicio;
public Bolsa() {
inicio = null;
}
public void poner(Object elemento) {
Celda aux = new Celda();
aux.dato = elemento;
aux.siguiente = inicio;
inicio = aux;
}
public boolean esVacia() {

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

Capítulo 1. Tipos de Datos Abstractos y

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Capítulo 1. Tipos de Datos Abstractos y

Cargado por

Copyright:

Formatos disponibles

Capítulo 1.

Tipos de Datos Abstractos y

❷ Tipos de Datos → colección de valores + operaciones

❷ Tipos de Datos Abstractos:

❷ Tipos de Datos Abstractos:

❷ Tipos de Datos Abstractos:

❷ Tipos de datos abstractos:

❷ Tipos de Datos Abstractos simples:

❷ Tipos de datos abstractos inmutables:

● TDA → Colección de valores + Operaciones

Usuario Especificación Implementador

Implementación Representación Representación

❷ Cabecera: Aparece el nombre de las operaciones.

❷ El usuario de la abstracción es el responsable de

❷ Tipo: Nombre del TDA

❷ Sintasis: Forma de las operaciones

❷ Semántica: Significado de las operaciones

si condición ⇒ valor si cierto | valor si falso

La condición será una expresión que toma un valor booleano. Se

Otra ampliación de la notación es permitir la definición de TDA's

❷ Tipo Bolsa (Elemento)

Clase: Tipo de datos definido por el

Objeto: Es un dato del tipo definido por

Fases de la vida de un objeto:

Creación del Objeto: Destrucción del Objeto:

Instanciación de un Objeto: mediante la palabra clave new

O en una sola línea:

Operaciones con los datos de una clase: funciones miembros o

Los miembros de una clase (propiedades y métodos) pueden ser:

Para acceder a propiedades privadas de la clase se definen métodos

Un miembro puede ser estático, si pertenece a la clase en sí y no a los

Definición en Java de una clase con sus propiedades y métodos:

<modificador> class <nombre_de_la_clase> {

Palabras clave para restringir el acceso a los

Miembro estático: static

Declaración e instanciación de un objeto:

Acceso a un dato publico:

Acceso a un dato privado:

Acceso a un dato estático:

La herencia permite la reutilización de código.

-Sobreescritura:reemplazar los métodos de

-Sobrecarga: varios métodos se llaman igual,

Declaración de subclases en Java

public class Monovolumen extends Coche {

public class Compacto extends Coche {

• Hacer una lista de todas las propiedades y métodos que

Realizar un buen diseño supone:

❷ Implementaciones estáticas y dinámicas

❷ Representaciones contiguas y enlazadas

❷ Implementaciones dinámicas → asignación

❷ En Programación Orientada a Objetos:

En la representación de TDA’s formados por colecciones

public class Estructura {

public class Estructura {

public class Estructura {

 Privacidad de los objetos

Declarar los campos de los objetos como privados

Elemento elemento = new Elemento(10);

Utilización del método clone

Utilización del método equals

Utilización del método toString

public class Elemento implements Cloneable,

public Object clone() {

public boolean equals(Object elemento) {