Object-oriented Programming

(OOP)
 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 CPU is 1-core
or 6-core; the motherboard is a 4-layer or 6-layer; the hard disk has 4
plates or 6 plates, 3 inches or 5 inches in diameter; 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 hardware 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 70 years ago, we have written tons
and tons of programs and routines. However, for each
new application, we have to re-invent the wheels and
write the program from scratch!
• Why re-invent the wheels? Why re-writing codes? Can
you write better codes than those codes written by the
experts?
 Future Software
• Suatu saat nanti, kita akan bisa menyusun
komponen software seperti komponen
hardware
Traditional Procedural-Oriented languages
• Traditional procedural-oriented programming languages (such as C,
Fortran, Cobol and Pascal) suffer some notable drawbacks in creating
reusable software components:
• The procedural-oriented programs are made up of functions. Functions
are less reusable. It is very difficult to copy a function from one program
and reuse in another program because the function is likely to reference
the global variables and other functions. In other words, functions are not
well-encapsulated as a self-contained reusable unit.
• 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, method, pointer, which are low-level and hard to
abstract real problems such as a Customer Relationship Management
(CRM) system or a computer soccer game.
• The traditional procedural-languages separate the data structures
(variables) and algorithms (functions).
Procedural-Oriented languages Illustration
In the early 1970s, the US Department of Defense (DoD) commissioned a task
force to investigate why its IT budget always went out of control; but without
much to show for. The findings are:
• 80% of the budget went to the software (with the remaining 20% to the
hardware).
• More than 80% of the software budget went to maintenance (only the
remaining 20% for new software development).
• Hardware components could be applied to various products, and their
integrity normally did not affect other products. (Hardware can share and
reuse! Hardware faults are isolated!)
• Software procedures were often non-sharable and not reusable. Software
faults could affect other programs running in computers.
• The task force proposed to make software behave like hardware OBJECT.
Subsequently, DoD replaces over 450 computer languages, which were
then used to build DoD systems, with an object-oriented language called
Ada.
 Object-Oriented Programming Languages
• Object-oriented programming (OOP) languages are designed to
overcome these problems.
• The basic unit of OOP is a class, which encapsulates both the static
properties and dynamic operations within a "box", and specifies the
public interface for using these boxes. Since classes are well-
encapsulated, it is easier to reuse these classes. In other words,
OOP combines the data structures and algorithms of a software
entity inside the same box.
• OOP languages permit higher level of abstraction for solving real-life
problems. The traditional procedural language (such as C and
Pascal) forces you to think in terms of the structure of the computer
(e.g. memory bits and bytes, array, decision, loop) rather than
thinking in terms of the problem you are trying to solve. The OOP
languages (such as Java, C++ and C#) let you think in the problem
space, and use software objects to represent and abstract entities
of the problem space to solve the problem.
OOP Objects
 OOP Illustration
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.
Class Illustration
 Benefits of OOP
• The procedural-oriented languages focus on procedures, with function as the
basic unit. You need to first figure out all the functions and then think about
how to represent data.
• The object-oriented languages focus on components that the user perceives,
with objects as the basic unit. You figure out all the objects by putting all the
data and operations that describe the user's interaction with the data.

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.
 OOP in Java
• Class
• Methods
• Instances (Objects)
• Encapsulation
• Polymorphism
 Class
In Java, a class is a definition of objects of the same kind. In
other words, a class is a blueprint, template, or prototype that
defines and describes the static attributes and dynamic
behaviors common to all objects of the same kind.
• An instance is a realization of a particular item of a class. In
other words, an instance is an instantiation of a class. All
the instances of a class have similar properties, as
described in the class definition. For example, you can
define a class called "Student" and create three instances
of the class "Student" for "Peter", "Paul" and "Pauline".
• The term "object" usually refers to instance. But it is often
used loosely, and may refer to a class or an instance.
A Class is a 3-Compartment Box Encapsulating
Data and Operations

A class can be visualized as a three-compartment box, as

illustrated:
• Name (or identity): identifies the class.
• Variables (or attribute, state, field): contains the static
attributes of the class.
• Methods (or behaviors, function, operation): contains
the dynamic behaviors of the class.
In other words, a class encapsulates the static attributes
(data) and dynamic behaviors (operations that operate on
the data) in a box.
 Class consist of

Unified Modeling Language (UML) Class and Instance Diagrams: The above
class diagrams are drawn according to the UML notations. A class is
represented as a 3-compartment box, containing name, data members
(variables), and member functions, respectively. classname is shown in bold
and centralized. An instance (object) is also represented as a 3-compartment
box, with instance name shown as instanceName:Classname and underlined.
The followings figure shows a few
examples of classes:
The following figure shows two instances (objects) of
the class Student, identified as "paul" and "peter".

Brief Summary
• A class is a programmer-defined, abstract, self-contained, reusable software entity that mimics a real-
world thing.
• A class is a 3-compartment box containing the name, data members (variables) and the member
functions.
• A class encapsulates the data structures (in data members) and algorithms (member functions). The
values of the data members constitute its state. The member functions constitute its behaviors.
• An instance is an instantiation (or realization) of a particular item of a class.
 Class Definition in Java
In Java, we use the keyword class to define a class. For examples:
 Class Naming

• Class Naming Convention: A class name shall be a noun or a

noun phrase made up of several words. All the words shall be
initial-capitalized (camel-case). Use a singular noun for class
name. Choose a meaningful and self-descriptive classname. For
examples, SoccerPlayer, HttpProxyServer, FileInputStream,
PrintStream and SocketFactory.
 Creating Objects of a Class

To create an instance (object) of a class, you have

to:
• Declare an instance identifier (instance name)
of a particular class.
• Construct the instance (i.e., allocate storage for
the instance and initialize the instance) using
the "new" operator.
 For examples
• suppose that we have a class called Circle, we
can create instances of Circle as follows:
 Dot (.) Operator
The variables and methods belonging to a class are formally
called member variables and member methods. To
reference a member variable or method, you must:
• First identify the instance you are interested in, and then,
• Use the dot operator (.) to reference the desired member
variable or method.
• For example, suppose that we have a class called Circle,
with two member variables (radius and color) and two
member methods (getRadius() and getArea()). We have
created three instances of the class Circle, namely, c1, c2
and c3. To invoke the method getArea(), you must first
identity the instance of interest, says c2, then use the dot
operator, in the form of c2.getArea().
 For example

• Calling getArea() without identifying the instance is meaningless, as the radius is

unknown (there could be many instances of Circle - each maintaining its own
radius). Furthermore, c1.getArea() and c2.getArea() are likely to produce different
results.
• In general, suppose there is a class called AClass with a member variable called
aVariable and a member method called aMethod(). An instance called anInstance
is constructed for AClass. You use anInstance.aVariable and anInstance.aMethod().
 Tugas 1
1. Apa perbedaan pbo dengan pemograman
prosedural?
2. Apa kelebihan pbo?
3. Apa isi dari sebuah kelas di dalam pbo?
4. Apa yang dimaksud dengan method?
5. Apa perbedaan method dengan fungsi didalam
pemograman prosedural?
6. Apa yang dimaksud dengan objek di dalam
pbo?
Sekian !