Relationship between instance and abstract data type

relationship between instance and abstract data type

In computer science, an abstract data type (ADT) is a mathematical model for data types, where . Abstract data types are purely theoretical entities, used ( among other things) to simplify the description of abstract Some algorithms need to create new instances of some ADT (such as new variables, or new stacks ). Abstract Data type (ADT) is a type (or class) for objects whose behavior is defined by a set of value and a set of operations. The definition of ADT only mentions. fundamental difference between objects and abstract data types. While objects and .. opened twice, the values from one instance cannot be mixed with values .

Abstract data type

Opaque data type Implementing an ADT means providing one procedure or function for each abstract operation. The ADT instances are represented by some concrete data structure that is manipulated by those procedures, according to the ADT's specifications.

relationship between instance and abstract data type

Usually there are many ways to implement the same ADT, using several different concrete data structures. Thus, for example, an abstract stack can be implemented by a linked list or by an array.

In order to prevent clients from depending on the implementation, an ADT is often packaged as an opaque data type in one or more moduleswhose interface contains only the signature number and types of the parameters and results of the operations.

Difference between Primitive and Object Data Types in Java

The implementation of the module—namely, the bodies of the procedures and the concrete data structure used—can then be hidden from most clients of the module. This makes it possible to change the implementation without affecting the clients. If the implementation is exposed, it is known instead as a transparent data type. When implementing an ADT, each instance in imperative-style definitions or each state in functional-style definitions is usually represented by a handle of some sort.

When a class is used as a type, it is an abstract type that refers to a hidden representation.

relationship between instance and abstract data type

In this model an ADT is typically implemented as a classand each instance of the ADT is usually an object of that class. The module's interface typically declares the constructors as ordinary procedures, and most of the other ADT operations as methods of that class. However, such an approach does not easily encapsulate multiple representational variants found in an ADT.

It also can undermine the extensibility of object-oriented programs. IntSetStruct, say The converse of this is that procedural data abstraction objects allow you to easily introduce new implementations that work with your old ones. But this is a trade-off: Often you end up having to expose more functionality and implementation details in your interface than you would with an ADT implementation.

Abstract data type - Wikipedia

Now I feel like I'm just retyping the Cook essay, so really, read it! I would like to add an example to this. Cook suggests that an example of an abstract data type is a module in C. Indeed, modules in C involve information hiding, since there are public functions that are exported through a header file, and static private functions that don't. Additionally, often there are constructors e. This is analogous to a way that two different groups from abstract algebra cannot interoperate that is, you can't take the product of an element of one group with an element of another group.

This is because groups assume the closure property of group the product of elements in a group must be in the group.

relationship between instance and abstract data type

However, if we can prove that two different groups are in fact subgroups of another group G, then we can use the product of G to add two elements, one from each of the two groups.

Roughly speaking, ADTs are coupled with generic functions that are often implemented in functional programming languages, while objects are coupled with Java "objects" accessed through interfaces. Both generic functions and objects implement polymorphism, but with generic functions, the programmer KNOWS which function will be executed by the generic function without looking at the code of the generic function.

With objects on the other hand, the programmer does not know how the object will handle the arguments, unless the programmers looks at the code of the object.

Usually the expression problem is thought of in terms of "do I have lots of representations?

Abstract Data Types | The Oxford Math Center

In the first case one should organize code by representation as is most common, especially in Java. In the second case one should organize code by functions i. If you organize your code by representation, then, if you want to add extra functionality, you are forced to add the functionality to every representation of the object; in this sense adding functionality is not "additive". If you organize your code by functionality, then, if you want to add an extra representation - you are forced to add the representation to every object; in this sense adding representations in not "additive".

Advantage of ADTs over objects Adding functionality is additive Possible to leverage knowledge of the representation of an ADT for performance, or to prove that the ADT will guarantee some postcondition given a precondition.

Abstract Data Types

This means that programming with ADTs is about doing the right things in the right order chaining together pre-conditions and post-conditions towards a "goal" post condition. In this case, the advantages of objects are that 1 it's easy to change representations without changing the interface and 2 objects can inter-operate.

However, this defeats the purpose of OOP in the sense of smalltalk.

relationship between instance and abstract data type

This is so that it's possible to define procedures in a generic way, that doesn't assume a particular representation. To be concrete - object oriented programming is easy in python, because it's possible to program methods of an object in a way that doesn't assume a particular representation.

This is why python doesn't need interfaces like Java. In Java, classes are ADTs.