The basic idea of data abstraction is to structure programs so that they operate on abstract data.
A concrete data representation is defined as an independent part of the program.
Any program consist of two parts. The two parts of a programs are, the part that operates on abstract data and the part that defines a concrete representation, is connected by a small set of functions that implement abstract data in terms of the concrete representation.
Example:
A rational number is a ratio of integers, and rational numbers constitute an important sub-class of real numbers.
A rational number such as 8/3 or 19/23 is typically written as:
           ↳  <numerator>/<denominator>
Where both the <numerator> and <denominator> are place holders for integer values. Both parts are needed to exactly characterize the value of the rational number. Actually dividing integers produces a float approximation, losing the exact precision of integers.
The pseudo code for the representation of the rational number using the constructor and selector is component.
x, y:=8,3
rational (n, d)
number (x) /number(y)
- output: 2.6666666666666665

List is constructed by the placing expressions within square brackets separated by commas. Such an expression is called a list literal.
List can store multiple value. Each value can be of any type and can even be another list.
List is[10,20]
The elements of a list can be accessed in two ways. The first method of multiple assignments, Which unpacks a list into its elements and bind each element to a different name.
1st:=[10,20]
x,y:=1st
In the above example x will become 10 and y will become 20
A second method for accessing the elements in a list is by the element selections operators, also expressed using square brackets. Unlike a list literal a square brackets expression directly following another expression does not evaluate to a list value, but insted select an element from the value of the preceding expression.
lst[0]
10
lst[1]
20
In both example mentioned above mathematically we can represent list similar to a set.
1st [(0,10),(1,20)]

Abstract Data Type is a type for objects whose behaviour is defined by a set of values and a set of operations.
The definition of ADT only mentions what operations are to be performed but not how these operations will be implemented. It does not specify. how data will be organized in memory and what algorithms will be used for implementing the operations.
It is called " abstract" because it gives an implementation independent view. The process of providing only the essentials and hiding the details is known as abstraction.
There can be different ways to implement an ADT, for example, the list ADT can be implemented using singly linked list or doubly linked list. Similarly, stack ADT and queue ADT can be implemented using lists.

Constructors are functions that build the abstract data type.
Selectors are functions that retrieve information from the data type.
For example, say we have an abstract data type called city. This city object will hold the city name and its latitude and longitude. To create a city object, we'd use a function like
city = makecity (name, lat, lon)
To extract the information of a city object, we would use functions like
(i) get name (city)
(ii) get lat (city)
(iii) get lot (city)
The pseudo code will compute the distance between two city objects:
distance (city1, city2):
It1, lg1:= getlat (city1 ), getlon (city1)
It2, lg2:= getlat (city2), getlon (city2)
return((lt1 -lt2) **2 + (lg1 - lg2) **2))^1/2
Int the above code read distance(), getlat() and getlon() as function and read lt as latitude and lg as longitude. Read:=as "assigned as" or "becomes"
It1, lg1:= getlat (city1), getlon,( city1)
is read as lt1 becomes the value of getlat(city1) and lg1 becomes the value of getlon (city 1).
The function which creates the object of the city is the constructor.

These function extract the information of the city object

Now let ns consider orle more examples to identify the constructor and selector for a slope. Read--as comments.
-- constructor
makepoint(x,y):
return x,y
-- selector
xcoord (point):
return point[O]
-- selector
ycoord (point):
return point[1]

(i) Data abstraction is a powerful concept in computer science that allows programmers to treat code as objects.
(ii) Programmers need not to worry about how code is implemented they have to just know what it does.
(iii) This is especially important when several people are doing a project. Proiect refers to the programming with data abstraction, our group members won't have to read through every line of our code to understand. They can just assume that it does work.
(iv) Abstraction provides modularity. It means splitting a program into many modules. Classes are the representation for "Abstract Data Types", ( ADT).

(i) The basic idea of data abstraction is to structure programs so that they operate on abstract data. That is, our programs should use data in such a way, as to make as few assumptions about the data as possible.
(li) At the same time, a concrete data representation is defined as an independent part of the program.
(iii) Any program consist of two parts. The two parts of a program are, the part that operates on abstract data and the part that defines a concrete representation, is connected by a small set of functions that implement abstract data in terms of the concrete representation.
(iv) To illustrate this technique, let us consider an example to design a set of functions for manipulating rational numbers.
(v) Example: A rational number is a ratio of integers, and rational numbers constitute an important sub-class of real numbers. A rational number such as 8/3 or 19/23 is typically written as : < numerator > /< denominator >
(vi) where both the < numerator > and <denominator> are placeholders for integer values. Both parts are needed to exactly characterize the value of the rational number. Actually dividing integers produces a float approximation, losing the exact precision of integers.
(vii) However, you can create an exact representation for rational numbers by combining together the numerator and denominator.
(viii) As we know from using functional abstractions, we can start programming productively before you have an implementation of some parts of our program.
(ix) Let us begin by assuming that you already have a way of constructing a rational number from a numerator and a denominator. You also assume that, given a rational number, you have a way of selecting its numerator and its denominator component.