oop - tipos - ¿Qué es un tipo de datos abstracto en programación orientada a objetos?
tipos de datos abstractos libros (18)
¿Qué es un tipo de datos abstracto en programación orientada a objetos?
Un tipo de datos Clase / Resumen es un grupo de propiedades y funciones (para acceder a los datos) de cualquier cosa que deseemos tratar mientras solucionamos algún problema de una manera orientada a objetos.
¿Qué es un objeto?
Object es una interfaz para un tipo de datos Clase / Resumen a través del cual podemos acceder a sus propiedades y funciones. Los objetos tienen recuerdos asociados a ellos utilizados para almacenar datos.
¿Qué es un tipo de datos abstracto en programación orientada a objetos? He revisado el wiki para este tema, pero todavía no estoy claro al respecto. ¿Alguien podría aclarar?
Definición:
A grandes rasgos, Abstract Data Type (ADT) es una forma de ver una estructura de datos: centrarse en lo que hace e ignorar cómo hace su trabajo.
Los tipos de datos abstractos se definen principalmente por su interfaz: las operaciones permisibles que se pueden llevar a cabo en ellos. El mecanismo subyacente utilizado para implementarlos generalmente no es visible para su usuario.
Ejemplos:
Stack , Queue y PriorityQueue son algunos de los ejemplos de los ADT, son más abstractos que las matrices say, las listas enlazadas y muchas otras estructuras de almacenamiento de datos.
Por ejemplo, el mecanismo subyacente para una pila, puede ser una Array o puede ser una lista LinkedList . El mecanismo subyacente para un PriorityQueue puede ser un Array o un tipo especial de árbol llamado Heap .
Código:
Aquí hay un ejemplo de Java del tipo de datos abstractos llamado PriorityQueue , implementado usando el Heap:
class Heap {
private Node heapArray[];
public void insert(Node node) {...}
public Node remove() {...}
}
class PriorityQueue {
private Heap heap;
public void insert(Node node) {
heap.insert(node);
}
public Node remove() {
return heap.remove();
}
}
Aquí puede ver que los métodos para la clase PriorityQueue simplemente se envuelven alrededor de los métodos para la clase Heap subyacente. Del mismo modo, puede utilizar Array lugar de Heap para implementar la misma funcionalidad, aunque en el caso de Array necesitará más código para encargarse de operaciones como insertar y eliminar. Este ejemplo debería dejar en claro conceptualmente que un PriorityQueue es un ADT que se puede implementar de varias maneras, usando montones, matrices, etc.
Aunque los ADT tienen más sentido en los lenguajes de programación orientada a objetos (OOP), no están limitados únicamente a los lenguajes OOP y también se pueden crear utilizando lenguajes que no sean OOP.
clases utiliza el concepto de abstracción de datos, conocido como tipo de datos absract.
tipo de datos abstractos es un término más antiguo para describir los conceptos de pila y colas en términos de su funcionalidad sin describir su implementación.
ADT es un conjunto de objetos y operaciones, en ninguna parte de las definiciones de un ADT hay mención de cómo se implementa el conjunto de operaciones. Los programadores que usan colecciones solo necesitan saber cómo crear instancias y acceder a los datos de una manera predeterminada, sin preocuparse por los detalles de las implementaciones de las colecciones. En otras palabras, desde la perspectiva de un usuario, una colección es una abstracción, y por esta razón, en informática, algunas colecciones se conocen como tipos de datos abstractos (ADT). El usuario solo se preocupa por aprender su interfaz o el conjunto de operaciones que realiza.
Los objetos como listas, conjuntos y gráficos junto con sus operaciones se pueden ver como tipos de datos abstractos. Los ADT son básicamente tipos de datos que ocultan los detalles de su implementación. Cualquier parte de un programa que necesite realizar una operación en ADT puede hacerlo simplemente cambiando las rutinas que realizan las operaciones de ADT. El programa que los usa (ADT) no necesariamente necesita saber qué implementación se utilizó. Puede leer más aquí
ADT es un tipo de estructura de datos. En lugar de describir la estructura de datos, describe la operation en los datos.
por ejemplo, ¿qué es una stack ? puede ser un árbol de búsqueda o una estructura de datos lineal, pero al usuario no le importa. El usuario solo se preocupa por "último en LIFO primero", también conocido como LIFO
Bueno, se trata de abstracción . La abstracción es particularmente útil en la programación. La principal ventaja es la capacidad de ocultar detalles de realización. Lo esconde dentro de un módulo (los llamados "módulos de servidor") y proporciona una interfaz pública para otros módulos (los denominados "módulos de cliente"). Y ahora tenemos tres posibilidades diferentes:
El módulo de servidor puede proporcionar una estructura de datos abstracta (ADS) .
En ese caso, contiene la entidad ADS en sí misma. La interfaz pública consta de algunos procedimientos (y tal vez algunas constantes).
Interfaz del módulo de servidor (stack_ads.h):
#ifndef STACK_ADS
#define STACK_ADS
const int capacity = 10;
void clear();
int size();
int pop();
void push(int value);
#endif STACK_ADS
Implementación (stack_ads.cpp):
#include "stack_ads.h"
int items[capacity];
int top = -1;
void clear()
{
top = -1;
}
int size()
{
return top + 1;
}
int pop()
{
top -= 1;
return items[top + 1];
}
void push(int value)
{
top += 1;
items[top] = value;
}
En el módulo de cliente (main.cpp) importamos el módulo de servidor y usamos la estructura de datos directamente.
#include <iostream>
#include "stack_ads.h"
int main (int argc, char* const argv[])
{
push(1);
push(2);
push(3);
std::cout << pop() << std::endl;
std::cout << pop() << std::endl;
std::cout << pop() << std::endl;
return 0;
}
El módulo de servidor puede suministrar un tipo de datos abstractos (ADT) en forma de estructura / registro.
En el módulo cliente, podemos declarar que las variables son de ese tipo. Como un módulo es libre de declarar que más de una variable es del tipo exportado, puede tener más de una estructura de datos. Cada estructura de datos abstracta es variable de tipo de datos abstractos.
Interfaz (stack_adt.h):
#ifndef STACK_ADT
#define STACK_ADT
const int capacity = 10;
typedef struct
{
int items[capacity];
int top;
} StackADT;
void clear(StackADT* stack);
int size(StackADT* stack);
int pop(StackADT* stack);
void push(StackADT* stack, int value);
#endif STACK_ADT
Implementación (stack_adt.cpp):
#include "stack_adt.h"
void clear(StackADT* stack)
{
stack->top = -1;
}
int size(StackADT* stack)
{
return stack->top + 1;
}
int pop(StackADT* stack)
{
stack->top -= 1;
return stack->items[stack->top + 1];
}
void push(StackADT* stack, int value)
{
stack->top += 1;
stack->items[stack->top] = value;
}
Módulo de cliente:
#include <iostream>
#include "stack_adt.h"
int main (int argc, char* const argv[])
{
StackADT stack1;
StackADT stack2;
stack1.top = -1;
stack2.top = -1;
push(&stack1, 1);
push(&stack1, 2);
push(&stack1, 3);
std::cout << pop(&stack1) << std::endl;
std::cout << pop(&stack1) << std::endl;
std::cout << pop(&stack1) << std::endl;
push(&stack2, 10);
push(&stack2, 20);
push(&stack2, 30);
std::cout << pop(&stack2) << std::endl;
std::cout << pop(&stack2) << std::endl;
std::cout << pop(&stack2) << std::endl;
return 0;
}
Finalmente, el módulo de servidor puede suministrar un tipo de datos abstractos (ADT) en forma de clase .
Si nuestro lenguaje admite OOP, podemos describir ADT por medio de clases. Y una vez más, en el módulo de cliente, podemos declarar que las variables son de ese tipo. En la terminología orientada a objetos, el tipo se llama una clase , y la variable con ese tipo se llama un objeto .
Interfaz de módulo de servidor (Stack.h):
#ifndef STACK
#define STACK
const int capacity = 10;
class Stack
{
public:
Stack();
void clear();
int size();
int pop();
void push(int value);
private:
int items[capacity];
int top;
};
#endif STACK
Implementación (Stack.cpp):
#include "Stack.h"
Stack::Stack()
{
this->top = -1;
}
void Stack::clear()
{
this->top = -1;
}
int Stack::size()
{
return this->top + 1;
}
int Stack::pop()
{
this->top -= 1;
return this->items[this->top + 1];
}
void Stack::push(int value)
{
this->top += 1;
this->items[this->top] = value;
}
Las diferencias entre las dos últimas opciones son:
- Terminología mencionada anteriormente (tipo <-> clase, variable <-> objeto).
- En el ADT que no es de clase, la lista de parámetros formales de cada procedimiento debe incluir una variable s de tipo Pila. En la clase de pila, la especificación de la estructura de datos s no se incluye con los otros parámetros formales que siguen el nombre del procedimiento, sino que se encuentra sola entre paréntesis antes del nombre del procedimiento. El uso del parámetro formal terminología Smalltalk antes del nombre del procedimiento se llama receptor .
- La ubicación de los procedimientos. En el ADT que no es de clase, los procedimientos se encuentran fuera de la estructura de Stack. En la clase, los procedimientos están ubicados dentro de la clase. En la terminología orientada a objetos, los procedimientos que tienen receptores, y por lo tanto están contenidos dentro de un tipo de clase, se llaman métodos .
Codigo del cliente:
#include <iostream>
#include "stack.h"
int main (int argc, char* const argv[])
{
Stack stack1;
Stack stack2;
stack1.push(1);
stack1.push(2);
stack1.push(3);
std::cout << stack1.pop() << std::endl;
std::cout << stack1.pop() << std::endl;
std::cout << stack1.pop() << std::endl;
stack2.push(10);
stack2.push(20);
stack2.push(30);
std::cout << stack2.pop() << std::endl;
std::cout << stack2.pop() << std::endl;
std::cout << stack2.pop() << std::endl;
return 0;
}
El resumen es el concepto más fundamental y generalizado en una programación y en la vida real.
¿Qué es un tipo de datos abstracto en programación orientada a objetos?
ADT es un contenedor que contiene diferentes tipos de objetos con especificaciones. representación lógica (es decir, una interfaz o protocolo) de los datos y las operaciones para manipular los elementos componentes de los datos.
Ejemplos de ADT: Lista, Mapa, Conjunto, Pila, Cola, Árbol, Gráfico.
Las estructuras de datos pueden implementar uno o más tipos de datos abstractos particulares (ADT). En java, por ejemplo, ArrayList, LinkedList, Stack y Vector son implementaciones de estructuras de datos (clases) de List.
Ejemplos de pila en la vida real:
- Cuando una persona usa brazaletes, el último brazalete usado es el primero que se quitará y el primer brazalete será el último que se quitará. Esto sigue el principio de pila de último en entrar primero (LIFO).
- En una pila de platos , una vez puede sacar el plato de arriba o puede mantener el plato en la parte superior. La placa que se colocó primero sería la última en sacar. Esto sigue el principio LIFO de la pila.
- Baterías en la linterna: - No puede quitar la segunda batería a menos que retire la última. Por lo tanto, la batería que se colocó primero sería la última que se sacará. Esto sigue el principio LIFO de la pila.
- Ropa en el baúl
ejemplos de cola en la vida real
- Una cola de personas en la ventanilla de boletos : la persona que viene primero obtiene el boleto primero. La persona que viene por última vez recibe las entradas por última vez. Por lo tanto, sigue la estrategia de cola primero en entrar primero en salir (FIFO).
- Vehículos en el puente de impuestos de peaje: el vehículo que llega primero al puesto de taxis deja el stand primero. El vehículo que viene último sale último. Por lo tanto, sigue la estrategia de cola primero en entrar primero en salir (FIFO).
- Máquina de control de equipaje : la máquina de control de equipaje comprueba el equipaje primero que viene primero. Por lo tanto, sigue el principio FIFO de cola.
- Pacientes que esperan fuera de la clínica del médico: el paciente que llega primero visita primero al médico y el último que visita al médico es el último. Por lo tanto, sigue la estrategia de cola de primero en entrar, primero en salir (FIFO).
En la escuela, me enseñaron que un ADT es solo un grupo que contiene una colección de datos y un conjunto de operaciones que se pueden tomar sobre estos datos. Simplemente se refiere a la idea, y no está relacionada con ningún lenguaje, implementación ni paradigma.
Actualizado:
entonces volver a leer la pregunta, y de acuerdo a mi definición, un tipo de datos abstracto en OOP debe ser una abstracción de clase, heredada o no, porque contiene datos (propiedades, campos, etc.) y operaciones (métodos).
Saludos
En resumen: abstracto significa que no puede crear objetos a partir de la clase definida. por ejemplo: si tiene clases de forma, cuadrado y rectángulo, pero no quiere definir ningún objeto de forma, lo marcará como abstracto ...
después de eso, si el usuario intenta definir un nuevo objeto a partir de la forma, obtendrá un error de compilación.
Esto es de Code Complete -Quote: los tipos de datos abstractos forman la base del concepto de clases. En idiomas que admiten clases, puede implementar cada tipo de datos abstractos en su propia clase. Las clases generalmente involucran los conceptos adicionales de herencia y polimorfismo. Una forma de pensar en una clase es como un tipo de datos abstracto más herencia y polimorfismo.
Entonces, en mi opinión, el tipo de datos abstractos en OO significa clase abstracta.
Hay una diferencia entre un " tipo de datos abstracto " y una " clase abstracta ".
Una clase abstracta es aquella que puede no tener definiciones para todos los métodos que define. Por lo tanto, no puede instanciar directamente una clase abstracta. Tienes que crear una subclase y luego instanciar eso.
Un tipo de datos abstracto es un modelo de un cierto tipo de estructura de datos, por ejemplo, una pila . Una pila tiene operaciones push () y pop () y que tienen un comportamiento bien definido.
El tipo de datos abstractos (ADT) se refiere a este modelo, no a una implementación particular en un lenguaje de programación o paradigma en particular . Podría implementar una pila en un lenguaje orientado a objetos, pero también podría implementarla en un lenguaje de programación funcional.
Los ADT permiten la discusión sobre las propiedades de Stacks, Queues, etc. que se mantienen para todas las implementaciones correctas de ADT.
Retroceda un paso desde el código:
¿Qué significa abstracto? Abstract
La esencia de esto es "no real, sino capturar una propiedad de cosas reales"
Necesitas saber esto para OOP porque estarás diseñando universos de objetos, lo que requiere que pienses cómo se relacionan esos objetos.
La abstracción le permite agrupar algunos de esos objetos, organizando así
1) Su proceso de pensamiento 2) Su código
Tipo abstracto significa cuyos objetos no existen en el mundo real ya que no tiene entidad física.
Actúa como una clase base para la clase concreta que tiene existencia física.
p.ej
Shape is an abstract class whereas circle,rectangle are concrete classes.
Tuve el mismo problema hasta la semana pasada.
Una clase abstracta es algo que es común o algo en general. Puedes usar esa clase para moldearla y extenderla de la forma que quieras.
Puedo darte un ejemplo práctico aquí
Toma una clase llamada animal. Y contiene funciones como comer, sonido, movimiento que es general que todos los animales hacen. Puedes extender esa clase para obtener específicos como gatos, perros, etc.
p.ej.
abstract class animal {
abstract protected function eat();
abstract protected function sound();
}
class dogs extends animal
{
protected function eat() {
return "meat";
}
public function sound() {
return "bow wow";
}
}
Espero que mi respuesta tenga sentido para ti
Un ADT define un conjunto de valores de datos y un conjunto de operaciones sobre estos valores.
Un tipo abstracto de datos (ADT) es un modelo matemático de un tipo de datos. Describe las operaciones que se pueden realizar en los datos y la definición matemática de esas operaciones usando ecuaciones.
Por ejemplo, puede modelar el comportamiento de una pila de números, usando operaciones abstractivamente abstractas como pop (), push (), top () y tal vez un símbolo constante que represente la pila vacía.
Por ejemplo, aquí hay algunas ecuaciones que podrían formar parte de la definición de una pila de números:
pop(empty) = empty // silently ignores popping an empty stack
pop(push(N,S)) = S // i.e. pop removes the top element of push(N,S)
top(push(N,S)) = N // return topmost element of the stack without changing the stack
Un tipo de datos abstracto no es en absoluto lo mismo que una clase en un modelo de objetos, aunque presentan algunas similitudes.
Estos son los nombres de los conceptos importantes: semántica inicial de álgebra, isomorfismo, cocientes, congruencias
El objetivo de un tipo de datos abstracto es comprender el comportamiento de una clase completa de representaciones de tipo equivalente utilizando ecuaciones y algunas matemáticas sofisticadas que demuestren que cada implementación es "isomorfa", es decir, que ambas implementaciones son exactamente equivalentes en la medida en que el comportamiento observable es preocupado.
La entrada de Wikipedia en esto es bastante buena: en.wikipedia.org/wiki/Abstract_data_type
Aquí hay algunas notas de curso buenas (pero muy teóricas) que detallan qué es un ADT: http://www-compsci.swan.ac.uk/~csulrich/ftp/adt/adt.pdf
Aunque superficialmente similar al concepto de "clase" en algunos lenguajes de programación orientados a objetos, una "clase" no es un ADT, pero se puede usar una clase para implementar un ADT específico.
En general, el concepto de ADT es probablemente más aplicable a la programación funcional que la programación orientada a objetos porque no todos los lenguajes de programación orientados a objetos tienen clases y el pensamiento de estilo ADT produce diseños de OO menos efectivos.
- Aquí hay un documento que demuestra los problemas de pensar en términos de ADT en un lenguaje OO: http://portal.acm.org/citation.cfm?id=74885
- Básicamente, el documento muestra que la "clase" que utilizas para implementar un ADT termina cubierta con muchos pequeños métodos (que parecen ser la base de las ecuaciones ADT) en lugar de tener algunos métodos potentes y de alta abstracción.
Una clase abstracta es un concepto de generalización. Es una clase que inventas para usar solo como una clase base para la herencia pero no para crear instancias de objetos.
Y el tipo de datos abstracto ( ADT ) no es necesariamente un concepto de OOP. Es un término más antiguo para describir los conceptos de, por ejemplo, Stack and Queue en términos de su funcionalidad, sin describir la implementación.
Una clase abstracta no forma un objeto concreto en el mundo real a diferencia de las clases de implementación puras. Resumen, ya que el nombre sugiere que tienen / definen comportamientos comunes de objetos relacionados que necesitan ser reutilizados / definidos independientemente en todos los objetos relacionados.
Tome un ejemplo de Aves. Si está escribiendo un programa que tendrá algo que ver con las aves, primero tendrá una clase base abstracta como Bird y cada ave derivada de la clase base abstracta Bird. Tenga en cuenta que la clase abstracta BIRD no representa un objeto concreto del mundo real, sino un tipo de objetos relacionados que son las aves.
Comencemos con el diagrama de clases y luego un poco de código.
texto alternativo http://ruchitsurati.net/files/birds.png
public abstract class Bird
{
protected string Name = string.Empty;
public Bird(string name)
{
this.Name = name;
}
public virtual void Fly()
{
Console.WriteLine(string.Format("{0} is flying.", this.Name));
}
public virtual void Run()
{
Console.WriteLine(string.Format("{0} cannot run.", this.Name));
}
}
public class Parrot : Bird
{
public Parrot() : base("parrot") { }
}
public class Sparrow : Bird
{
public Sparrow() : base("sparrow") { }
}
public class Penguin : Bird
{
public Penguin() : base("penguin") { }
public override void Fly()
{
Console.WriteLine(string.Format("{0} cannot fly. Some birds do not fly.", this.Name));
}
public override void Run()
{
Console.WriteLine(string.Format("{0} is running. Some birds do run.", this.Name));
}
}
class Program
{
static void Main(string[] args)
{
Parrot p = new Parrot();
Sparrow s = new Sparrow();
Penguin pe = new Penguin();
List<Bird> birds = new List<Bird>();
birds.Add(p);
birds.Add(s);
birds.Add(pe);
foreach (Bird bird in birds)
{
bird.Fly();
bird.Run();
}
Console.ReadLine();
}
}