OBJECT-ORIENTED PROGRAMMING
PRINCIPLES
Object Oriented Programming
Object-oriented programming (OOP) is a programming paradigm that
represents the concept of objects having data fields (attributes that
describe the object) and associated procedures known as methods.
Objects, which are usually instances of classes, are used to interact
with one another to design applications and computer programs.
C++, Objective-C, Smalltalk, Delphi, Java, Javascript, C#, Perl,
Python, Ruby and PHP are few example of Programming languages
that employs OOP.
Four Main OOP Principles
Ability or technique of making the fields in a class
ENCAPSULATION
private and providing access to the fields via public
methods.
Process where one object acquires the properties of
INHERITANCE
DATA
ABSTRACTION
another. Information is made manageable in a
hierarchical order.
Ability to make a class abstract, one that cannot be
instantiated.
Ability of an object to take on many forms, such that
POLYMORPHISM
it can be used by different objects.
Encapsulation
Described as a protective barrier that prevents the code and data
being randomly accessed by other code defined outside the class.
Access to the data and code is tightly controlled by an interface.
Major benefit is the ability to modify the implemented code without
breaking the code of others who utilizes the implemented code.
Encapsulation is also known as information hiding.
Encapsulation
Usually done by hiding attributes (fields) of an object and only
exposing them via getter and setter methods.
Getter or Accessors method that used to return the value of a
private
field with a naming scheme prefixing the word get to the
start of the
method name.
Setters or Mutators - method is used to set a value of a private field
with a
method
naming scheme prefixing the word set to the start of the
name.
Encapsulation (illustration)
field1
fieldn
inputMethod2
()
(
od
field2
h
et
ge
() tMe
th
o
tM
se
output
(Data)
inputMethod1
()
input
Polymorphism
Polymorphism is an OOP principle that allows to define one interface
and can have multiple implementations.
A feature that allows one interface to be used for a general class of
actions.
Polymorphism can be achieved in two types:
(a) Static Polymorphism (Compile-time Polymorphism)
(b)Dynamic Polymorphism (Runtime Polymorphism)
Polymorphism (illustration)
SUBCLASS1
SUBCLASS2
Methods and Constructors of subclasses
define their own unique behaviors and yet
SUPERCLASS
share some of the same functionality of the
super class.
Method Overloading
Method Overloading is a feature of OOP that allows a class to have
two or more methods having same name with different argument or
parameter lists.
Method overloading can be done by changing the number of
arguments or changing the data types of the arguments.
Method overloading is one of the ways through which java supports
polymorphism.
Method overloading is also known as Static Polymorphism.
Method Overloading (example)
Create object reference for
OverloadingMethods Class
Assign and invoke
multiplyNumbers method with
different parameters to a
variable.
Method Overloading (example)
Overloaded method with different
parameters
Base Class and Derived Class Concepts
Derived Class is a class that is derived from another class.
Derived class is also referred as child class or subclass.
Derived Class inherits state and behavior in the form of variables and
methods from its base class (inheritance).
Base Class is a class from which states and behaviors of the other
classes have been derived or the derived class.
Base Class is also known as parent class or superclass.
Base Class and Derived Class Concepts
Base Class
field1
field2
inherited
field
Derived Class
fielda
field1
fieldn
inherited
fieldn
methodA( )
methodB( )
methodN()
methods
methodA( )
methodB( )
methodC( )
methodN()
Method Overriding
Method Overloading occurs when a method in derived class has the
same name and type signature as a method in its base class.
Derived class overrides the parent class method without even
touching the source code of the base class and creates its own
functionality.
Override methods must have the same return type and must not
have more restrictive access modifier.
Overriding Method is also known as Dynamic Polymorphism.
Method Overriding (example)
Reference of SuperClass and
object for SuperClass
Reference of SuperClass but
object of SubClass
Method Overriding (example)
Override
Method
Constructor
Constructor is a block of code, which runs when you use new keyword
in order to instantiate an object.
Constructor has the same name as its class and is syntactically
similar to a method.
Constructors have no explicit return type nor void.
Constructor is used to initialize values to the instance variables
defined by the class, or to perform any other startup procedures
required to create a fully formed object.
Constructor
Java automatically provides a default constructor that initializes all
member variables to zero.
Once you define your own constructor, the default constructor is no
longer used.
Polymorphism is also achieved through constructor overloading.
You make use of constructor chaining, wherein one constructor calls
the constructor of its super class implicitly or explicitly.
Shadowing and this Keyword
Attributes/Fields/Variables identifiers can be the same as long as the
scope is different.
Java performs a lookup based of the variables within and outside the
method but within the class.
If the same variable name exist in the class, the local variable shadows the
class/instance variable. this Keyword is used to refer the class and instance
variable.
Constructor (example)
Constructor with
parameter
Mutator and Accessor for field name
Reference with
argument
Overload
Constructor
Inheritance
Reusing the fields and methods of the existing
class without having to write (and debug!) them
SUPERCLASS
yourself.
A subclasses inherit all the members from its
superclass.
Constructor of the superclass can be invoked from
the subclass, except for the constructor of the
subclasses.
SUBCLASS
Inheritance (example)
MountainBike (subclass) inherits all the fields and methods of Bicycle
and adds the field seatHeight and a method to set it (mutator).
Except for the constructor, it is as if you had written a new
MountainBike class entirely from scratch, with four fields and five
methods.
A subclass inherits all of the public and protected members of its
parent except for the private members.
Keywords super, extends, & Multiple
Inheritance
super keyword is used to refer immediate parent class instance
variable.
super keyword is used to invoke immediate parent class constructor.
super keyword is used to invoke immediate parent class method.
extends keyword is used to indicate that you are making a new class
(subclass) that derives from an existing class (superclass).
Java disallow a class extends multiple classes (multiple inheritance) to
reduce the complexity and simplify the language
Data Abstraction
Abstraction can be achieved in two ways (1) Abstract Classes and (2)
Interfaces.
An abstract class is a class that cannot be instantiated. Members of the
abstract class still exists and can be accessed in the same manner with
a regular class.
An abstract method is a method that is declared without an
implementation (without braces, and followed by a semicolon) like
abstract void methodName();
Interfaces vs. Abstract Classes
Abstract classes can declare fields that are not static and final, and
define public, protected, and private concrete methods while;
With Interfaces, all fields are automatically public, static, and final, and
all methods that you declare (as default methods) are public.
In addition, you can extends only one class, whether or not it is
abstract, whereas you can implement any number of interfaces.
If class include abstract methods, then the class itself must be
declared abstract.
Data Abstraction (Abstract Class Example)
Data Abstraction (Interface Example)
Interface & Abstract Class (Example)
implements keyword requires that the class being defined also include
declarations and definitions of all the method signatures defined in the
specified interface class.
implements keyword allows you to have multiple inheritance while
extends keyword does not.
Implementing an interface class may think of the class as signing a
contract, agreeing to perform the specific behaviors of the interface, if
not, the class must declare itself as abstract.
