- Programming terminology:
- object =
a structure that
consists of:
- Data fields
(= variables)
- Methods that manipulate the data fields (= instance methods)
(This concept originated from the programming language Simula 67)
- Data fields
(= variables)
- object =
a structure that
consists of:
- Object Oriented Programming Language:
- A programming language
(such as Java) that
allows the programmer to
specify:
- Data fields
(= variables),
and
- Methods that manipulate the data fields (= instance methods)
together inside the same structure (= class) is called an Object Oriented Programming language
- Data fields
(= variables),
and
- A programming language
(such as Java) that
allows the programmer to
specify:
- For historical reasons,
(because object oriented programming was
a big deal),
the user-defined data type
in object oriented programming languages
are called objects
.... to distinguish them from non-object oriented programming:
- Methods in
Object Oriented programming
use an implicit parameter
this
Object Oriented programming uses access specifiers to control access of the instance variables
- Non
Object Oriented programming
do not
uses implicit parameters
Non Object Oriented programming do not uses access specifiers (all variables are "public")
- Methods in
Object Oriented programming
use an implicit parameter
this
- Before the
introduction of object concept,
the programming languages
allows the programmer to:
- Define the
variables
separately
- Define the
methods that
operate on the variables
separately
- The methods access the
variables in the data structure through
an explicit parameter
passed to the method:
- Define the
variables
separately
- Short-coming of
Non-object oriented
programming language:
- Any programmer can
add a new method
that modifies the
content of the
data structure:
- The programming language
does not offer a way
to shield the
users of the
data structure from the
implementation details
- There is also no
language support to
decouple
the functionality
from the
implementation
- You will learn more about decoupling
when we discuss interfaces
- An interface specifies the
functionality
- The implementation of an interface can be realised by one or more classes
- You will learn more about decoupling
when we discuss interfaces
- Any programmer can
add a new method
that modifies the
content of the
data structure:
- Short answer:
- Programs that access an information structure directly, can only work with that specific information structure
- To understand this, you need to realize that:
- There are
different ways
to solve the same problem
- The different solution methods will usually organize the information differently
- There are
different ways
to solve the same problem
- Example:
- Suppose there are two different
solutions (programs)
for the same problem
available:
- SolveProbSol1() and
SolveProbSol2()
can solve the
same probkem
Suppose that:- The SolveProbSol1() is very easy to program, but it is not efficient
- The solution SolveProbSol2() is more efficient
And we decide to implement SolveProbSol1():
- Suppose there are two different
solutions (programs)
for the same problem
available:
- Now, suppose that
other programs
are written later
that uses this
information structure
to solve other problems:
Notice that:
- All 3 programs
are dependent on the
information structure
- So when you change the way you store the information, all 3 programs that use that information structure must be updated.
- All 3 programs
are dependent on the
information structure
- Consequently, if
we introduce the
more efficient solution
later,
all the programs
solveProbSol1, solveA1 and solveB1
need to be updated:
We call this phenomenon:
- The data dependency of
a computer program
Wikipedia entry: click here
- The data dependency of
a computer program
- Summary:
why is
decoupling
the functionality
and the implementation such a big deal:
- All programs that
make direct use of
the how the information
is implemented
are dependent on
that specific information structure
- These programs cannot function if a different (better) information structure is used.
- All programs that
make direct use of
the how the information
is implemented
are dependent on
that specific information structure
- Obtaining the information indirectly:
- To solve a problem, a
program needs
information
- Information can be obtained
directly by
accessing the variable
directly:
Explanation:
- In this example, the programs solveProbSol1(), solveA1() and solveB1() obtain the information direct by accessing the variables (e.g., using p.z)
- Information can also
be obtained
indirectly
through the use
of method invocations
that return the
desired information:
Explanation:
- In this example, the programs solveProbSol1(), solveA1() and solveB1() obtain the information indirect by invoking the methods getInfo1(), getInfo2() and putInfo1() that manage the information stored variables
- To solve a problem, a
program needs
information
- Decoupling the
functionality and the implementation:
- Implementation =
how to store the information
- Functionality =
how to use the information
- The implmentation and the
functionality of information
is decoupled by using
a group of methods
that provides the
required functionality:
- Furthermore,
we require a program that
want to use the stored information
to
access the information through
the methods that
implement the functionality:
- Implementation =
how to store the information
- Recall that:
- when programs
use the information stored in variables
directly:
- all the
programs must be
changed
if we store the information
in a different (better) format:
- when programs
use the information stored in variables
directly:
- Providing the same functionality
with
different implementation:
- Suppose we use a different
information structure
- And also
update the methods
to provide the
same functionality
using the
new information structure:
- Suppose we use a different
information structure
- Now we can
switch the programs
over to use the
new information structure
with very little effort:
- Programs that make use of the
old information structure:
- Programs that make use of the
new information structure:
- Programs that make use of the
old information structure:
- What needs to be done to switch
over to use the new information
structure:
- If you do it right, all you need to
do is:
- Change one line of code in any program to switch over to use the new information structure
So with decoupling, programs are more flexible !!!
- If you do it right, all you need to
do is:
- Data Abstraction:
- Data abstraction
enforces a
clear separation between
- The allowable operations
(= the methods) of a
data type (= class),
and
- The details of its implementation (= what is stored inside the data type (= class))
- The allowable operations
(= the methods) of a
data type (= class),
and
- In data abstraction:
- The
implementation details
(= the instance variables)
are
hidden away
from the user (= other programmers)
(In Java, we use the private access modifier to "hide" (= forbid) the instance variables away from the user)
- The allowable operators
(= methods)
are exposed to the user
(= other programmers)
(In Java, we use the public access modifier to "expose" the methods to the user)
- The
implementation details
(= the instance variables)
are
hidden away
from the user (= other programmers)
- Data abstraction
enforces a
clear separation between
- "Hiding Data" in Data Abstraction:
- The "hiding" data part is actually
forbidding
the user to access the variables
that contains the data.
This is achieved using the private access specifier
- The "hiding" data part is actually
forbidding
the user to access the variables
that contains the data.
- Main Strength:
- Fact 1:
- Data Abstraction
forces the
user of
a data type (= class)
to access the data
through the use of the
(public) methods
(The user of the data type (= class) do not have direct access to the instance variables
- Data Abstraction
forces the
user of
a data type (= class)
to access the data
through the use of the
(public) methods
- Fact 2:
- There are many different ways
to store information
(Some ways are easy to program, but inefficient; while other ways are harder to program but more efficient)
- There are many different ways
to store information
- Fact 3:
- When you change the way you store information, you can still provide the same operations by changing the methods
- Benefit of Data Abstraction:
- The user of the
data type (= class) can
switch between
different implementations of
the data type (= class)
with minimum effort !!!
(We saw this before in the example of decoupling functionality and implementation)
- The user of the
data type (= class) can
switch between
different implementations of
the data type (= class)
with minimum effort !!!
- Fact 1:
- We will illustrate this concept with the implementation of a deck of playing cards next