Why OOP?
Suppose that you want to assemble your own PC, you go to a
hardware store and pick up a motherboard, a processor, some RAMs, a hard disk,
a casing, a power supply, and put them together. You turn on the power,
and the PC runs. You need not worry whether the motherboard is a 4-layer
or 6-layer board, whether the hard disk has 4 or 6 plates; 3 inches or 5 inches
in diameter, whether the RAM is made in Japan or Korea, and so on. You simply
put the hardware components
together and expect the machine to run. Of course, you have to make sure
that you have the correct interfaces,
i.e., you pick an IDE hard disk rather than a SCSI hard disk, if your
motherboard supports only IDE; you have to select RAMs with the correct speed
rating, and so on. Nevertheless, it is not difficult to set up a machine
from hardware components.
Similarly,
a car is assembled from parts and components, such as chassis, doors, engine,
wheels, brake, and transmission. The components are reusable, e.g., a wheel can
be used in many cars (of the same specifications).
Hardware,
such as computers and cars, are assembled from parts, which are reusable
components.
How about software? Can you "assemble" a software
application by picking a routine here, a routine there, and expect the program
to run? The answer is obviously no! Unlike hardware, it is very
difficult to "assemble" an application from software components.
Since the advent of computer 60 years ago, we have written tons and tons of
programs. However, for each new application, we have to re-invent the
wheels and write the program from scratch.
Why
re-invent the wheels?
Drawbacks of Procedural Languages:
Traditional procedural-oriented languages (such
as C and Pascal) suffer some notable drawbacks in creating reusable software
components:
1.
The programs are made up
of functions. Functions are often not reusable. It is very
difficult to copy a function from one program and reuse in another program
because the the function is likely to reference the headers, global variables and
other functions. In other words, functions are not well-encapsulated as a
self-contained reusable unit.
2.
The procedural languages
are not suitable of high-level abstraction for solving real
life problems. For example, C programs uses constructs such as if-else,
for-loop, array, function, pointer, which are low-level and hard to abstract
real problems such as a Customer Relationship Management (CRM) system or a
computer soccer game. (Imagine using assembly codes, which is a very low level
code, to write a computer soccer game. C is better but no much better.)
What is OOP?
The prime purpose of C++ programming was to add
object orientation to the C programming language, which is in itself one of the
most powerful programming languages.
The core of the pure object-oriented programming
is to create an object, in code, that has certain properties and methods. While
designing C++ modules, we try to see whole world in the form of objects. For
example a car is an object which has certain properties such as color, number
of doors, and the like. It also has certain methods such as accelerate, brake,
and so on.
There are a few principle concepts that form the
foundation of object-oriented programming:
Object:
This is the basic unit of object oriented
programming. That is both data and function that operate on data are bundled as
a unit called as object.
Class:
When you define a class, you define a blueprint
for an object. This doesn't actually define any data, but it does define what
the class name means, that is, what an object of the class will consist of and
what operations can be performed on such an object.
Abstraction:
Data abstraction refers to, providing only
essential information to the outside world and hiding their background details,
i.e., to represent the needed information in program without presenting the
details.
For example, a database system hides certain
details of how data is stored and created and maintained. Similar way, C++
classes provides different methods to the outside world without giving internal
detail about those methods and data.
Encapsulation:
Encapsulation is placing the data and the
functions that work on that data in the same place. While working with
procedural languages, it is not always clear which functions work on which
variables but object-oriented programming provides you framework to place the
data and the relevant functions together in the same object.
Inheritance:
One of the most useful aspects of
object-oriented programming is code reusability. As the name suggests
Inheritance is the process of forming a new class from an existing class that
is from the existing class called as base class, new class is formed called as
derived class.
This is a very important concept of
object-oriented programming since this feature helps to reduce the code size.
Polymorphism:
The ability to use an operator or function in
different ways in other words giving different meaning or functions to the
operators or functions is called polymorphism. Poly refers to many. That is a
single function or an operator functioning in many ways different upon the
usage is called polymorphism.
Overloading:
The concept of overloading is also a branch of
polymorphism. When the exiting operator or function is made to operate on new
data type, it is said to be overloaded.
OOP Real life example:
As an example, suppose you wish to write a
computer soccer games (which I consider as a complex application). It is quite
difficult to model the game in procedural-oriented languages. But using OOP
languages, you can easily model the program accordingly to the "real
things" appear in the soccer games.
·
Player: attributes
include name, number, location in the field, and etc; operations include run,
jump, kick-the-ball, and etc.
·
Ball:
·
Reference:
·
Field:
·
Audience:
·
Weather:
Most importantly, some of these classes (such as Ball and Audience) can be reused in
another application, e.g., computer basketball game, with little or no
modification.
Benefits of OOP:
Object-Oriented technology has many benefits:
·
Ease
in software design as you could think
in the problem space rather than the machine's bits and bytes. You are dealing
with high-level concepts and abstractions. Ease in design leads to more
productive software development.
·
Ease
in software maintenance:
object-oriented software are easier to understand, therefore easier to test,
debug, and maintain.
·
Reusable
software: you don't need to keep
re-inventing the wheels and re-write the same functions for different
situations. The fastest and safest way of developing a new application is to
reuse existing codes - fully tested and proven codes.
Creating simple Class:
class SoccerPlayer { // classname
private:
int number; //
Data members (variables)
string name;
int x, y;
public:
void run(); //
Member functions
void kickBall();
}
Constructor:
A constructor is a special function that has
the function name same as the classname. In the above Circle class, we define a
constructor as follows:
//
Constructor has the same name as the class
Circle(double
r = 1.0, string c = "red") {
radius = r;
color = c;
}
A constructor is used to construct and initialize all the
data members. To create a new instance of a class, you need to declare the
name of the instance and invoke the constructor. For example,
Circle
c1(1.2, "blue");
Circle
c2(3.4); // default color
Circle
c3; // default radius and color
// Take note that there is
no empty bracket ()
A constructor function is different from an
ordinary function in the following aspects:
·
The name of the
constructor is the same as the classname.
·
Constructor has no
return type (or implicitly returns void). Hence, no return statement is
allowed inside the constructor's body.
·
Constructor can only be
invoked once to initialize the instance constructed. You
cannot call the constructor afterwards in your program.
·
Constructors are not
inherited (to be explained later).
Public Private Access:
An access control modifier can be used to control
the visibility of a data member or a member function within a class. We begin
with the following two access control modifiers:
1. public: The member (data or
function) is accessible and available to all in the system.
2. private: The member (data or
function) is accessible and available within this class only.
For example, in the above Circle definition, the data member radius is declared private. As the result, radius is accessible
inside the Circle class, but NOT outside the class. In other words,
you cannot use "c1.radius" to refer to c1's radius in main(). Try inserting the
statement "cout << c1.radius;" in main() and observe the
error message:
CircleAIO.cpp:8:11:
error: 'double Circle::radius' is private
Try moving radius to the public section, and
re-run the statement.
On the other hand, the function getRadius() is declared public in the Circle class. Hence, it
can be invoked in the main().
No comments:
Post a Comment