1.1 Concepto de Tipo de Datos Abstracto.

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 Implementaciones estáticas y dinámicas. Representaciones contiguas y enlazadas. 1.4.6 Utilización correcta de objetos. Privacidad de los objetos. Previniendo efectos laterales. Comparación de objetos. 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

Tipos de Datos Abstractos: 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

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

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 del TDA Representación elegida Representación 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

Conceptos de la OO: Clase Objeto Propiedad Método Herencia Polimorfismo

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.

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.

Destrucción del Objeto:
1.4.1 Clases y Objetos 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: Constructor Objeto instanciado Destrucción del Objeto: Destructor

1.4.1 Clases y Objetos 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.

1.4.2 Propiedades y Métodos 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>

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

1.4.2 Propiedades y Métodos 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; }

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();

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() { 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: La cantidad de elementos de los casos del TDA es fija y conocida a priori (en tiempo de compilación) La cantidad de elementos de los casos del TDA es fija, pero se conoce en tiempo de ejecución La cantidad de elementos de los casos del TDA es variable en tiempo de ejecución

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];

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

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[]; static private int maxLongitud = 100; private int longitud = 0; public Estructura() { dato = new Object[maxLongitud]; } // resto de métodos de la clase } // fin class Estructura

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 { Object dato; Celda siguiente; } private Celda inicio; // métodos de la clase Estructura } // fin class 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; public Elemento(int valor) { dato = valor; } public Object clone() { return new Elemento(dato); } } // fin class Elemento elemento1 = (Elemento)elemento2.clone();

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

Utilización del método toString public class Elemento { private int dato; public Elemento(int valor) { dato = valor; } public Object clone() { return new Elemento(dato); } public boolean equals(Object elemento) { if (elemento==null) return false; Elemento e = (Elemento)elemento; return (dato==e.dato); public toString(){ return ""+dato; } // fin class Elemento 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; public Elemento(int valor) { dato = valor; } public int valor() { return dato; public Object clone() { return new Elemento(dato);

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

public boolean mayorIgualQue(Object elemento) { Elemento e = (Elemento)elemento; return (dato>=e.dato); } public boolean menorQue(Object elemento) { return (dato<e.dato); public boolean menorIgualQue(Object elemento) { return (dato<=e.dato); } // fin class Elemento

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 public class Estructura { 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 { dato[i] = valor; } // fin class Estructura

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) { }

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.

1.4.7 Ejemplos en Java 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;

1.4.7 Ejemplos en Java 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);

Ejemplos en Java static public Racional multiplica(Racional a, Racional b) { int n = a.num*b.num; int d = a.den*b.den; return new Racional(n,d); } 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;

1.4.7 Ejemplos en Java 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)); } public Object clone() { Racional r = new Racional(num,den); return r; } // fin class Racional

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

1.4.7 Ejemplos en Java 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;

1.4.7 Ejemplos en Java 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

1.1 Concepto de Tipo de Datos Abstracto.

Presentaciones similares

Presentación del tema: "1.1 Concepto de Tipo de Datos Abstracto."— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

1.1 Concepto de Tipo de Datos Abstracto.

Presentaciones similares

Presentación del tema: "1.1 Concepto de Tipo de Datos Abstracto."— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback