什么是面向对象编程中的抽象数据types？
什么是面向对象编程中的抽象数据types？ 我已经通过维基这个话题，但我还不清楚。 有人能澄清吗？
抽象类是一个概括的概念。 这是一个你发明的类，只能用作inheritance的基类，而不能实例化对象。
而抽象数据types （ ADT ）不一定是OOP的概念。 根据其function描述Stack和Queue的概念，这是一个较老的术语，没有描述实现。
“ 抽象数据types ”和“ 抽象类 ”是有区别的。
一个抽象类可能没有定义它定义的所有方法。 因此你不能直接实例化一个抽象类。 你必须创build一个子类然后实例化。
抽象数据types是某种数据结构（例如堆栈）的模型 。 一个Stack具有push（）和pop（）操作，并具有定义良好的行为。
抽象数据types（ADT）本身是指这个模型，而不是任何特定的编程语言或范例的具体实现 。 你可以用面向对象的语言来实现一个Stack，但是你也可以用一种函数式编程语言来实现它。
ADT允许讨论堆栈，队列等属性，这些属性适用于ADT的所有正确实现。
那么，这全是关于抽象 。 抽象在编程中特别有用。 主要优点是隐藏实现细节的能力。 您将其隐藏在一个模块（所谓的“服务器模块”）中，并为其他模块（所谓的“客户端模块”）提供一些公共接口。 现在我们有三种不同的可能性：
服务器模块本身可以提供一个抽象数据结构（ADS） 。
在这种情况下，它包含ADS实体本身。 公共接口由一些程序组成（可能还有一些常量）。
服务器模块接口（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 实现（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; }
在客户端模块（main.cpp）中，我们直接导入服务器模块并使用数据结构。
#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; }
服务器模块可以以struct / record的forms提供抽象数据types（ADT） 。
在客户端模块中，我们可以声明variables的types。 由于模块可以自由地将多个variables声明为导出types，因此它可以具有多个数据结构。 每个抽象数据结构都是抽象数据types的variables。
接口（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
实现（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; }
客户端模块：
#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; }
最后，服务器模块可以以类的forms提供抽象数据types（ADT） 。
如果我们的语言支持OOP，我们可以用类来描述ADT。 再次在客户端模块中，我们可以声明variables的types。 在面向对象的术语中，types被称为类 ，并且具有该types的variables被称为对象 。
服务器模块接口（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
实现（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; }
最后两个选项之间的差异是：
- 上面提到的术语（type < – > class，variable < – > object）。
- 在非类ADT中，每个过程的forms参数列表必须包含一个types为Stack的variabless。 在堆栈类中，数据结构的规范不包含在过程名称后面的其他forms参数中，而是单独包含在过程名称前面的括号中。 在过程名称之前使用Smalltalk术语forms参数称为接收器 。
- 程序的位置。 在非ADT类中，这些过程位于Stack结构之外。 在课堂上，程序位于课堂内。 在面向对象的术语中，具有接收者并因此被包含在类types中的过程称为方法 。
客户代码：
#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; }
抽象数据types（ADT）是一种数据types的math模型。 它描述了可以对数据执行的操作以及使用方程式对这些操作的math定义。
例如，可以使用pop（），push（），top（）等操作完全抽象地表示一堆数字的行为，也可以使用代表空堆栈的常量符号。
例如，这里有一些方程可以构成一堆数字的定义的一部分：
pop(empty) = empty // silently ignores popping an empty stack pop(push(N,S)) = S // ie pop removes the top element of push(N,S) top(push(N,S)) = N // return topmost element of the stack without changing the stack
抽象数据types与对象模型中的类完全不同，尽pipe它们有些相似之处。
这里是重要概念的名字：初始代数语义，同构，商，同余
抽象数据types的要点是通过使用方程和一些花式math来理解整个等价types表示的行为，这些math表明每个实现都是“同构的” – 即两个实现在可观察行为是完全等价的关心。
维基百科条目非常好： http ： //en.wikipedia.org/wiki/Abstract_data_type
这里有一些很好（但非常理论化）的课程笔记，指出ADT是什么~csulrich/ftp/adt/adt.pdf
尽pipe在某些面向对象的编程语言中表面上类似于“类”的概念，但“类”不是ADT，而是一个类可以用来实现特定的ADT。
一般来说，ADT概念可能比面向对象编程更适用于函数式编程，因为并不是所有的面向对象的编程语言都有类，而ADT式的思想产生的OOdevise效果较差。
- 以下是一篇论文，以面向对象语言的forms展示ADT的思维问题： http ://portal.acm.org/citation.cfm?id=74885
- 基本上，本文表明，用来实现ADT的“类”最终包含了许多微小的方法（看起来像是ADT方程的基础），而不是具有一些强大的，高度抽象的方法。
定义：
粗略地说， 抽象数据types （ADT）是一种查看数据结构的方法： 关注数据结构，忽略它的工作方式。
抽象数据types主要是通过它们的接口来定义的：可以对它们执行的允许的操作。 用于实现它们的基本机制通常对用户不可见。
例子：
Stack ， Queue和PriorityQueue是ADT的一些例子，它们比数组，链表和其他数据存储结构更抽象。
例如，一个栈的底层机制，可以是一个Array ，也可以是一个LinkedList 。 PriorityQueue的基本机制可以是一个Array或称为Heap的特殊types的树。
码：
下面是使用Heap实现的称为PriorityQueue的抽象数据types的Java示例：
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(); } }
在这里你可以看到， PriorityQueue类的方法只是简单的包装在底层的Heap类的方法中。 同样，你可以使用Array而不是Heap来实现相同的function，即使在Array情况下，你也需要更多的代码来处理插入和删除操作。 这个例子应该在概念上清楚说明一个PriorityQueue是一个ADT，可以用各种方式实现，使用堆，数组等等。
尽pipeADT在面向对象编程（OOP）语言中更有意义，但它们不仅限于OOP语言，还可以使用非OOP语言创build。
在学校里，他们教我说ADT只是一个包含数据集合和一组可以对这些数据进行操作的小组。 它只是指这个想法，而不是与任何语言，实施都没有关系范式。
更新：
所以重新读取这个问题，并根据mi的定义，OOP中的一个抽象数据types应该是一个类的抽象，是否inheritance，因为它包含数据（属性，字段等）和操作（方法）。
问候
摘要是程序devise和现实生活中最基本，最普遍的概念。
什么是面向对象编程中的抽象数据types？
ADT是一个容纳不同types的物体的容器。 数据的逻辑表示（即接口或协议）以及操作数据的组成元素的操作。
ADT的例子：List，Map，Set，Stack，Queue，Tree，Graph。
数据结构可以实现一个或多个特定的抽象数据types（ADT）。 在Java中，例如ArrayList，LinkedList，Stack和Vector是List的数据结构实现（类）。
在现实生活中堆叠示例：
- 当一个人戴上手镯时 ，最后一个手镯将被拆除，第一个手镯将被拆除。 这遵循先进先出（LIFO）的原则。
- 在一叠盘子里 ，一次可以从上面取出盘子，或者把盘子放在上面。 首先放置的盘子是最后拿出的盘子。 这遵循LIFO原则的堆栈。
- 手电筒中的电池 ： – 您不能取出第二块电池，除非您将最后一块电池取下。因此，放入第一块的电池将是最后一块取出的电池。 这遵循LIFO原则的堆栈。
- 衣服在树干里
排队在现实生活中的例子
- 售票窗口的人排队：先来的人先获得门票。 最后一个来的人最后拿到票。 因此，它遵循队列的先进先出（FIFO）策略。
- 加税车上的车辆：首先驶入收费站的车辆先离开车厢。 最后一辆车离开最后。 因此，它遵循队列的先进先出（FIFO）策略。
- 行李检查机：行李检查机首先检查行李。 因此，它遵循队列的FIFO原则。
- 在医生诊所外等候的病人：先来的病人先去看医生，最后去的病人去看医生。 因此，它遵循队列的先进先出（FIFO）策略。
上面的例子从Source1和Source2收集
直到上周，我也遇到了同样的问题。
抽象类是普遍的东西或一般的东西。 你可以使用这个类来塑造它，并以你喜欢的方式扩展它。
我可以在这里给你一个实际的例子
参加一个叫做动物的课。 它包含了所有动物一般的吃，听，动的function。 您可以扩展该类，以获得像猫，狗等特定的
例如。
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"; } }
希望我的回答对你有意义
从代码中退一步：
抽象是什么意思？ 抽象
它的要点是“不真实，但捕捉真实的东西的属性”
你需要知道这个OOP，因为你将devise对象的宇宙，这需要你思考这些对象是如何相关的。
抽象允许你分组这些对象，从而组织
1）你的思考过程2）你的代码
-
类使用数据抽象的概念，称为absract数据types。
-
抽象数据types是一个较老的术语，用于描述堆栈和队列的概念，而不用描述它们的实现。
简而言之：抽象意味着你不能从定义的类中创build对象。 例如：如果你有形状，正方形和长方形的类，但你不想从形状中定义任何对象，所以你将它标记为抽象的。
之后，如果用户试图从形状定义一个新的对象，他会得到编译器错误。
这是来自代码完成 – 引用：抽象数据types构成了类的概念的基础。 在支持类的语言中，可以在自己的类中实现每个抽象数据types。 类通常涉及inheritance和多态的附加概念。 思考类的一种方式是作为抽象数据types加上inheritance和多态性。
所以在我看来，OO中的抽象数据types就是抽象类。
什么是面向对象编程中的抽象数据types？
类/抽象数据types是一组属性和函数（用于访问数据）的任何我们可能想要处理的问题，同时以面向对象的方式解决一些问题。
什么是对象？
Object是一个Class / Abstract数据types的接口，通过它我们可以访问它的属性和函数。 对象具有与用于存储数据的关联的存储器。
ADT是一种数据结构。 它不是描述数据的结构，而是描述数据的operation 。
例如，什么是stack ？ 可能是一个search树或者一些线性数据结构，但用户不在意。 用户只关心“ LIFO先出”又名LIFO
一个ADT定义了一组数据值和一组这些值的操作。
与纯粹的实现类不同，抽象类在现实世界中并不形成具体的对象。 抽象名称build议他们持有/定义相关对象的共同行为，需要在所有相关对象中独立重用/定义。
以鸟类为例。 如果你正在编写一个与鸟类有关的程序，那么你将首先拥有一个抽象的基类Bird，每个鸟类都来自抽象基类Bird。 请注意，抽象类BIRD并不代表一个具体的现实世界对象，而是一种相关的对象，即鸟类！
让我们从类图开始，然后是一些代码。
替代文字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(); } }
抽象types意味着对象在现实世界中不存在，因为它没有物理实体。
它作为具有物理存在的具体类的基类。
例如
Shape is an abstract class whereas circle,rectangle are concrete classes.
