Representation for Abstract Data Type – Best Strategies to Work

What is Abstract Data Type?

Abstract Data Type (ADT) refers to a type (or class) of an object whose functionality is being defined as a set of values and operations.

The ADT definition just specifies what operations should be performed, not how they should be managed to perform. It says nothing about how data will be stored in memory or what algorithms we will use to carry out the tasks. Because it provides a view that is independent of implementation, it is also called “abstract.” The approach of giving simply the fundamentals while concealing the complexities is known as abstraction.

An Abstract data type (ADT) is a data type notion or paradigm. Abstract data type means that a user does not have to worry about how a data type is being implemented. Furthermore, ADT is responsible for the implementation of functions on a data type. The user will be able to use preset functions on any data type for any operation. In general, a user in Abstract data type understands what to do without revealing how to do it. These models are also defined by the data items and operations that go with them. ADTs are also implemented using distinct methods and logic in each programming language. Regardless of language, we can still conduct all of the associated operations that are defined for that Abstract data type.

Key Concept of Abstract Data Type:

You don’t really need to understand the mechanics of the starter motor to start your car. To start the sequence, all you have to do is turn the key. The engine will turn over if everything goes well. This real-world example exemplifies the programming idea of data abstraction, which allows a programmer to protect/hide a process’s implementation while only granting access to other functions or users. You only need to know enough about a function to run it; you don’t need to understand (or care about) how it works internally.

We can go even further and build complete data types. A class with a defined set of operations and values is known as an abstract data type (or ADT). To put it another way, you can design the starter motor as a full abstract data type, shielding the user from all of the inner code. The user can just call the start() function to get the car started. An Abstract data type has the following characteristics in programming:

  • An Abstract data type does not specify how data gets arranged, and 
  • It just offers what is being required to carry out its functions.

An Abstract data type is a great example of how data abstraction and data hiding may be used to their maximum potential. This means that enforcing abstraction, permitting data hiding (protecting information from other portions of the program), and encapsulation are all important aspects of object-oriented programming approaches (combining elements into a single unit, such as a class). You have option to buy dissertation online in case of any issue,

Representation of Abstract Data Type:

The process of arranging programmes so that they can deal with abstract data is known as data abstraction. That is, our programmes should use data in a way that requires as few assumptions about the data as possible. Simultaneously, a concrete data representation is also defined as a separate component of the programme.

There are two sections to any programme. A short set of functions connects the two sections of a programme, the portion that works on abstract data and the part that defines a concrete representation, by implementing abstract data in terms of the concrete representation. Consider the design of a collection of functions for manipulating rational numbers as an example of this technique.


A rational number is an integer ratio, and rational numbers are a significant subcategory of real numbers. A rational number like 8/3 or 19/23 is being represented as:  


Where <numerator> and <denominator> are placeholders for integer values. To precisely characterize the value of the rational number, both parts are also required. When you divide integers, you get a float approximation, which loses the precision of integers.


However, by combining the numerator and denominator, you may generate an exact representation for rational numbers. We can start programming productively before we have an implementation of some elements of our programme, as we know from using functional abstractions.

Abstract Data Type Examples:

Here are several abstract data type examples, as well as some of its operations, organized by kind.

1.      Int is the primitive integer type in Java.  Because int is immutable, it does not have any mutators.

·         Creators: The number literals 0, 1, 2,..

·         Producers: arithmetic operators +, -, ×, ÷

·         Observers: comparison operators ==,!=, >,<

·         Mutators: none (it cannot get changed)

2.      List is Java’s list interface.

A changeable list is one that can be changed. The list is also an interface, which means that other classes are responsible for the data type’s implementation. ArrayList and LinkedList are two of these types.

  • Creators: ArrayList and LinkedList constructors, Collections.singletonList.
  • Producers: Collections.unmodifiableList.
  • Observers: size, get.
  • Mutators: add, remove, addAll, Collections.sort.
  • String is the string type in Java. Strings are unchangeable.
  • Creators: String constructors
  • Producers: concat, substring, toUpperCase
  • Observers: length, charAt
  • Mutators: none (it’s immutable)

This classification provides some helpful terms, but it is not without flaws. For example, with sophisticated data types, an operation that is both a producer and a mutator may exist. Some individuals exclusively use the term “producer” to describe operations that do not include mutation.


Abstract data types allow complicated objects to be used without having to worry about their implementation. The separation between specification and implementation details does this. This notion is also incorporated into the design of modern programming languages in order to give suitable tools for the separation of specifications and implementations. The representation chosen for an Abstract data type has no bearing on the user of the ADT. In some cases, it is advantageous to select the representation and algorithms. The idea of offering such a feature in the context of abstract data types is presented in this article.

Related Articles

Leave a Reply

Your email address will not be published.

Back to top button