Object-Oriented Paradigm is where we focus real
life objects while programming any solution. By focusing real life objects we
mean that over solutions revolves around different objects, which represent
respective objects in real life situation.
The
objective of this section is to provide a thorough understanding of the
principles of object-oriented paradigm.
Data Abstraction
Data abstraction is the reduction of a particular body of data to a simplified representation of the whole. Abstraction,
in general, is the process of taking away or removing characteristics
from something in order to reduce it to a set of essential
characteristics.
In
object-oriented programming, objects interact with each other by messages. The
only thing that an object knows about another object is the object's interface.
Each object's data and logic is hidden from other objects. In other words, the
interface encapsulates the object's code and data.
This
allow the developer to separate an object's implementation from its behaviour.
This separation creates a "black-box" affect where the user is
isolated from implementation changes. As long as the interface remains the
same, any changes to the internal implementation is transparent to the user.
For example, if the name message is sent to the Student object,
it does not matter to the user how the developer implemented the code to handle
this message. All the sending object needs is the correct protocol for
interacting with the Student object. The developer can change the
implementation at any time, but the name message would still work
because the interface is the same.
Another
benefit of separating implementation from behaviour is polymorphism.
Polymorphism allows two or more objects respond to the same message. A method
called name could also be implemented for an object of the class Course.
Even though the implementation of this name message may return a course number
and a course title, its protocol is the same as the name message to the Student
object. Polymorphism allows a sending object to communicate with different
objects in a consistent manner without worrying about how many different
implementations of a message.
An
analogy of polymorphism to daily life is how students response to a school
bell. Every student knows the significant of the bell. When the bell (message)
rings, however, it has its own meaning to different students (objects). Some
students go home, some go to the library, and some go to other classes. Every
student responds to the bell, but how they response to it might be different.
Another
example of polymorphism is the function of printing. Every printable object
must know how to print itself. The message is the same to all the different
objects: print, but the actual implementation of what they must do to
print themselves varies.
The
sending object does not have to know how the receiving object implement the
message. Only the receiving objects worries about that. Assume that there is a print
Page method in a Document object that has the responsibility of
printing a page. To print the page, the print Page method sends the print
message to each object on the page. The Document does not need to know
what types of objects are on the page, only that each object supports the behaviour
of printing.
New
objects can be added to the page without affecting the print Page
method. This method still sends the print message and the new object
provides its own print method in response to that message.
Polymorphism
allows the sending object to communicate with receiving objects without having
to understand what type of object it is, as long as the receiving objects
support the messages.
Another
important concept of object-oriented programming is inheritance.
Inheritance allows a class to have the same behaviour as another class and
extend or tailor that behaviour to provide special action for specific needs.
Let's
use the following application as an example. Both Graduate class and Undergraduate
class have similar behaviour such as managing a name, an address, a major, and
a GPA. Rather than put this behaviour in both of these classes, the behaviour
is placed in a new class called Student. Both Graduate and Undergraduate
become subclass of the Student class, and both inherit the
Student behaviour.
Both
Graduate and Undergraduate classes can then add additional behaviour
that is unique to them. For example, Graduate can be either Master's
program or phD program. On the other hand, Undergraduate class might
want to keep track of either the student is Freshman, Sophomores, Junior or
Senior.
Classes
that inherit from a class are called subclasses. The class a subclass
inherits from are called super class. In the example, Student is
a super class for Graduate and Undergraduate. Graduate and
Undergraduate are subclasses of Student.
