An abstraction is a simplified description, or specification, of a system that focuses on some essential structure or behavior of a real-world or conceptual object. A good abstraction is one in which information that is significant to the user is emphasized while details that are immaterial, at least for the moment, are suppressed. We use the principles of information hiding to encapsulate these details.
An abstract data type is a programming language facility for organizing programs into modules using criteria that are based on the data structures of the program. The specification of the module should provide all information required for using the type, including the allowable values of the data and the effects of the operations. However, details about the implementation, such as data representations and algorithms for implementing the operations, are hidden within the module. This separation of specification from implementation is a key idea of abstract data types.
Each module that defines an abstract data type may include both data declarations and subroutine definitions. The criteria for organizing the modules emphasize protecting the data structures from arbitrary manipulation- malicious or accidental-by other parts of the program. Languages that support abstract data types include scope rules that guarantee this locality by hiding the names of local data from all parts of the program outside the module that defines the abstract data type. The objective of organizing a program using abstract data types is to expedite program development and to simplify maintenance by imposing a certain kind of predictable and useful structure on the program.
Like structured programming, the methodology of abstract data types emphasizes locality of related collections of information. In the case of abstract data types, attention is focused on data rather than on control, and the strategy is to form modules consisting of a data structure and its associated operations. The objective is to treat these modules in the same way as ordinary types, such as integers and reals, are treated; this requires support for declarations, infix operators, specification of parameters to subroutines, etc. The resulting abstract data type effectively extends the set of types available to a program. It explains the properties of a new group of variables by specifying the values that one of these variables may have, and it explains the operations that will be permitted on the variables of the new type by giving the effects the operations have on the values of the variables.
In designing a data type abstraction, we first specify the functional properties of a data structure and its operations, and then we implement them in terms of existing language constructs (and other data types) and show that the specification is accurate. When we subsequently use the abstraction, we deal with the new type solely in terms of its specification. This philosophy has been developed in several programming languages, including Ada, C++, Concurrent Pascal, Euclid, Gypsy, Mesa, Modula, and Simula.