Что такое абстрактный тип данных в объектно-ориентированном программировании?

абстрактный класс является концепцией обобщения . Это класс, который вы изобретаете только для использования в качестве базового класса для наследования, но не для создания экземпляров объектов.

И абстрактный тип данных ( ADT ) не обязательно является концепцией ООП. Это старый термин для описания концепций, например, стека и очереди с точки зрения их функциональности, без описания реализации.

Абстрактный тип означает, чьи объекты не существуют в реальном мире, поскольку не имеют физический объект.

Он действует как базовый класс для конкретного класса, который существует физически.

например,

 Shape is an abstract class whereas circle,rectangle are concrete classes.

Вкратце: абстрактный означает, что вы не можете создавать объекты из определенного класса. пример: если у вас есть классы shape, square и rectangle, но вы не хотите определять какие-либо объекты из shape, поэтому вы отметите его как абстрактный ...

после этого, если пользователь попытается определить новый объект из shape , он получит ошибку компилятора ..

До прошлой недели у меня была такая же проблема.

Абстрактный класс - это что-то общее или что-то в целом. Вы можете использовать этот класс, чтобы формировать его и расширять как хотите.

Я могу привести здесь практический пример

Возьмем класс под названием animal. И он содержит такие функции, как еда, звук, движение, которые являются общими для всех животных. Вы можете расширить этот класс, чтобы сделать его более конкретным, например, кошек, собак и т. Д.

например.

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";
   }
}

надеюсь, что мой ответ был вам понятен

В школе меня учили, что ADT - это просто группа, которая содержит набор данных и набор операций, которые могут выполняться над этими данными. Это просто относится к идее, и не связано ни с каким языком, реализацией или парадигмой.

Обновлено:
поэтому перечитайте вопрос и, в соответствии с определением mi, абстрактный тип данных в ООП должен быть абстракцией класса, унаследованным или нет, потому что он содержит данные (свойства, поля и т. д.) и операции (методы).

касается

Абстрактный тип данных (ADT) - это математическая модель типа данных. Он описывает операции, которые могут быть выполнены с данными, и математическое определение этих операций с помощью уравнений.

Например, вы можете смоделировать поведение стека чисел, совершенно абстрактно используя такие операции, как pop (), push () , top () и, возможно, постоянный символ, представляющий пустой стек. org / wiki / Abstract_data_type

Вот несколько хороших (но очень теоретических) примечаний к курсу, объясняющих, что такое ADT http://www-compsci.swan.ac.uk/~csulrich/ftp/adt/ adt.pdf

Хотя внешне он похож на концепцию «класса» в некоторых объектно-ориентированных языках программирования, «класс» не является ADT, но класс может использоваться для реализации определенного ADT.

В В целом концепция ADT, вероятно, более применима к функциональному программированию, чем объектно-ориентированному программированию, потому что не все объектно-ориентированные языки программирования имеют классы, а мышление в стиле ADT приводит к менее эффективным объектно-ориентированным проектам.

• Вот статья, которая демонстрирует проблемы мышления в терминах ADT на языке объектно-ориентированного программирования: http://portal.acm.org/citation.cfm?id=74885
• В основном в статье показано, что "учебный класс" которые вы используете для реализации 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;
}

Серверный модуль может предоставлять абстрактный тип данных (ADT) в форме структуры / записи.

В клиентском модуле мы можем объявить переменные этого типа. Поскольку модуль может объявлять несколько переменных экспортируемого типа, он может иметь более одной структуры данных. Каждая абстрактная структура данных является переменной абстрактного типа данных.

Интерфейс (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;
}

Наконец, серверный модуль может предоставить абстрактный тип данных (ADT) в форме class .

Если наш язык поддерживает ООП, мы можем описывать ADT с помощью классов. И снова в клиентском модуле мы можем объявить переменные этого типа. В объектно-ориентированной терминологии этот тип называется классом , и переменная с этим типом называется объектом .

Интерфейс серверного модуля (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;
}

Различия между двумя последними вариантами:

• Терминология, упомянутая выше (тип <-> класс, переменная <-> объект).
• В неклассовом ADT список формальных параметров каждой процедуры должен включать переменную s типа Stack. В классе стека спецификация структуры данных s не включается в другие формальные параметры, следующие за именем процедуры, но список формальных параметров каждой процедуры должен включать переменную s типа Stack. В классе стека спецификация структуры данных s не включается в другие формальные параметры, следующие за именем процедуры, но список формальных параметров каждой процедуры должен включать переменную s типа Stack. В классе стека спецификация структуры данных s не включается в другие формальные параметры, следующие за именем процедуры, но стоит отдельно в скобках перед названием процедуры. В терминологии Smalltalk формальный параметр перед именем процедуры называется получателем .
• Расположение процедур. В неклассовом ADT процедуры расположены вне структуры Stack. В классе процедуры расположены внутри класса. В объектно-ориентированной терминологии процедуры, которые имеют приемники и поэтому содержатся в типе класса, называются методами .

Код клиента:

#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;
}

Существует разница между абстрактным типом данных " "и" абстрактный класс ".

абстрактный класс - это класс, который может не иметь определений для всех методов, которые он определяет. Следовательно, вы не можете напрямую создать экземпляр абстрактного класса. Вы должны создать подкласс, а затем создать его экземпляр.

абстрактный тип данных - это модель определенного типа структуры данных, например, Стек . Стек имеет операции push () и pop (), которые имеют четко определенное поведение.

Сам абстрактный тип данных (ADT) относится к этой модели, не какой-либо конкретной реализации на каком-либо конкретном языке программирования или парадигме . Вы можете реализовать стек на объектно-ориентированном языке, но вы также можете реализовать его на функциональном языке программирования.

ADT позволяют обсуждать свойства стеков, очередей и т. Д., Которые сохраняются для всех правильных реализаций ADT.

Это от Code Complete - Цитата: Абстрактные типы данных составляют основу концепции классов. На языках, поддерживающих классы, вы можете реализовать каждый абстрактный тип данных в своем собственном классе. Классы обычно включают дополнительные концепции наследования и полиморфизма. Один из способов мышления класса - это абстрактный тип данных плюс наследование и полиморфизм.

Итак, на мой взгляд, абстрактный тип данных в объектно-ориентированном пространстве означает абстрактный класс.

1. классы используют концепцию абстракции данных, известную как тип данных absract.

2. абстрактный тип данных - это старый термин для описания концепций стека и очередей с точки зрения их функциональности без описания их реализации.

Абстрактный класс не образует конкретный объект в реальном мире, в отличие от чистых классов реализации. Абстрактные, поскольку название предполагает, что они содержат / определяют общее поведение связанных объектов, которые необходимо повторно использовать / определять независимо во всех связанных объектах.

Возьмем, к примеру, Птиц. Если вы пишете программу, которая будет иметь какое-то отношение к птицам, то сначала у вас будет абстрактный базовый класс 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();
    }
}

Сделайте один шаг назад от кода:

Что значит абстрактный? Абстрактный

Суть в том, что это "не реальный, но передающий свойство реальных вещей"

Вам нужно знать это для ООП, потому что вы будете проектировать вселенные объектов, что требует от вас думать о том, как эти объекты связаны между собой.

Абстракция позволяет вам группировать некоторые из этих объектов, таким образом организуя

1) Ваш мыслительный процесс 2) Ваш код