What Is Object Oriented Programming
What Is Object Oriented Programming
What Is Object Oriented Programming
Robregado
BSIT - 2A
ACTIVITY 1
Procedural programming is about writing procedures or functions that perform operations on the data,
while object-oriented programming is about creating objects that contain both data and functions.
OOP helps to keep the C++ code DRY "Don't Repeat Yourself", and makes the code easier to maintain,
modify and debug
OOP makes it possible to create full reusable applications with less code and shorter development time
Encapsulation
For example, we are hiding the name and dob attributes of person class in the below code snippet.
return name;
}
this.name = name;
return dob;
this.dob = dob;
Abstraction
Abstract means a concept or an Idea which is not associated with any particular instance. Using abstract
class/Interface we express the intent of the class rather than the actual implementation. In a way, one
class should not know the inner details of another in order to use it, just knowing the interfaces should
be good enough.
Inheritance
Inheritances expresses “is-a” and/or “has-a” relationship between two objects. Using Inheritance, In
derived classes we can reuse the code of existing super classes. In Java, concept of “is-a” is based on
class inheritance (using extends) or interface implementation (using implements).
Polymorphism
It means one name many forms. It is further of two types — static and dynamic. Static polymorphism is
achieved using method overloading and dynamic polymorphism using method overriding. It is closely
related to inheritance. We can write a code that works on the superclass, and it will work with any
subclass type as well.
Example
Java collections framework has an interface called java.util.Collection, ArrayList and TreeSet are two
different implementation of this interface. ArrayList maintains the insertion order of elements while
TreeSet orders its elements by their natural order or comparator(if supplied). Now if we write a method
that accepts a collection and prints its elements, the actual object (ArrayList or TreeSet) at runtime will
decide the behavior of this method.
Passing an ArrayList
collection1.add("A");
collection1.add("D");
collection1.add("B");
collection1.add("C");
print(collection1); (1)
elements will be printed as per the insertion order of elements into arraylist
Program output
s=A
s=D
s=B
s=C
Passing an TreeSet
collection2.add("A");
collection2.add("D");
collection2.add("B");
collection2.add("C");
print(collection2); (1)
Program output
s=A
s=B
s=C
s=D
We just saw that print() method’s behavior is determined by the actual type of object passed to it at run
time. That’s polymorphism!
What is Class?
CLASS are a blueprint or a set of instructions to build a specific type of object. It is a basic concept of
Object-Oriented Programming which revolve around the real-life entities. Class in Java determines how
an object will behave and what the object will contain.
Syntax
class <class_name>{
field;
method;
What is Object?
OBJECT is an instance of a class. An object is nothing but a self-contained component which consists of
methods and properties to make a particular type of data useful. For example color name, table, bag,
barking. When you send a message to an object, you are asking the object to invoke or execute one of
its methods as defined in the class.
From a programming point of view, an object can include a data structure, a variable, or a function. It
has a memory location allocated. The object is designed as class hierarchies.
Syntax
A class is a blueprint or prototype that defines the variables and the methods (functions) common to all
objects of a certain kind.
An object is a specimen of a class. Software objects are often used to model real-world objects you find
in everyday life.
4. Types of Methods
1. Static methods: A static method is a method that can be called and executed without creating an
object. In general, static methods are used to create instance methods.
Static method can be invoked directly via class name i.e.; we don't have to create an object for a class in
order to initiate static method.
2. Instance methods: These methods act upon the instance variables of a class. Instance methods are
being invoked with below syntax
<<class-name>>.<<method-name>>;
a. Accessor methods: These are the methods which read the instance variables i.e.; just go access the
instance variables data. Generally these methods are named by prefixing with "get".
b. Mutator method: These are the methods, which not only read the instance variables but also modify
the data. Generally these methods are named by prefixing with "set".
InstanceMethodsDemo.java
/**
* @since 02-Mar-2012
* @version 1.0
*/
class Person
//instance variables
String name;
int age;
char sex;
this.name = name;
this.age = age;
this.sex = sex;
System.out.println("Name: "+name);
System.out.println("Age: "+age);
System.out.println("Sex: "+sex);
}
Person modify(Person p)
p.name = "Santhosh";
p.age = 27;
p.sex = 'M';
return p;
class InstanceMethodsDemo
p.display();
Person p1 = p.modify(p);
p1.display();
p2.display();
3. Factory methods: A factory method is a method that returns an object to the class to which it
belongs. All factory methods are static methods.
This concept is also often used to hide the internal representation, or state, of an object from the
outside. This is called information hiding. The general idea of this mechanism is simple. If you have an
attribute that is not visible from the outside of an object, and bundle it with methods that provide read
or write access to it, then you can hide specific information and control access to the internal state of
the object.
Encapsulation is an Object Oriented Programming concept that binds together the data and functions
that manipulate the data, and that keeps both safe from outside interference and misuse. Data
encapsulation led to the important OOP concept of data hiding.
Object - it's just a state and behavior. Each class has interface - set of public methods
Encapsulation tells us that we should know just an interface of class to be able to use it. We don't have
to know anything about internals of class to be able to use it.
Let's check following real-world example. The best example of encapsulation could be a calculator. We
understand its interface from first sight and we don't have to know how it works inside. We know that
we can press 2+2 then = and see the result on display.
In Ruby we can easily check interface of class - we should look for its public methods. Then we can find
method that fits for our needs and check which arguments to pass to get result.
In statically typed languages you also have to define a type of arguments which method has as well as
type for returning value.
Ruby it's a dynamically typed language, so all we can learn about method from first sights it's a name
and params it accepts.
References:
https://www.w3schools.com/cpp/cpp_oop.asp
https://medium.com/@cancerian0684/what-are-four-basic-principles-of-object-oriented-programming-
645af8b43727#:~:text=There%20are%204%20major%20principles,pillars%20of%20Object%20Oriented
%20Programming.
https://www.guru99.com/java-oops-class-objects.html
https://www.santhoshreddymandadi.com/java/java-types-of-methods.html
http://rubyblog.pro/2017/01/object-oriented-programming-encapsulation-inheritance