Introduction to OOP
Object-oriented programming is a programming paradigm which deals
with the concepts of object to build programs and software applications.
It is modeled around the real world.
The world we live in is full of objects. Every object has a well-defined
identity, attributes, and behavior.
The features of object-oriented programming also map closely to the
real-world features like inheritance, abstraction, encapsulation, and
polymorphism.
There are many object-oriented programming (OOP) languages, including:
1. JAVA
2. PHP
3. PYTHON
4. R
Need for Object-Oriented Programming
There were certain limitations in earlier programming approaches and to
overcome these limitations, a new programming approach was required.
1. Better Organization and Modularity:
OOP allows code to be organized into classes, making it modular. Each
class can represent a specific concept. This modularity makes code
easier to understand and maintain.
2. Code Reusability
Object-Oriented Programming (OOP) allows reusing code through
inheritance, where one class can reuse the features and functions of
other classes. This avoids repetition of the code and speeds up
development.
3. Improved Security
OOP ensures data security through encapsulation by restricting direct
access to object properties and providing controlled access via special
methods.
4. Productivity:
OOP allows programmers to construct new programs quickly by using
reusable code and multiple libraries.
Principles of Object-Oriented Languages
OOP languages follow certain principles. These principles map very
closely to the real world.
o Classes
o Objects
o Abstraction
o Inheritance
o Encapsulation
o Polymorphism
Classes:
A class is a blueprint or prototype for creating an object.
Class consists of data members and member functions, which can be
accessed and used by creating an instance of that class.
Objects:
An object is an instance of a Class.
An object is a real-word entity that has state and behaviour.
Objects have their own set of attributes (data) and methods (functions)
that describe and define their behavior.
When a class is defined, no memory is allocated but when it is
instantiated (i.e. an object is created), memory is allocated.
Abstraction:
Abstraction is a process of hiding the implementation details and
showing only functionality to the user.
Another way, it shows only essential things to the user and hides the
internal details, for example, sending SMS where we type the text and
send the message. We do not know the internal processing about the
message delivery.
Abstraction lets you focus on what the object does instead of how it
does it.
Inheritance:
Inheritance enables a class to inherit properties and actions from
another class.
When we inherit methods from an existing class, we can reuse methods
and fields of the parent class and we can add new methods and fields in
your current class also.
Encapsulation:
Encapsulation is a process of wrapping of data and methods in a single
unit is called encapsulation.
Polymorphism:
Polymorphism is considered one of the important features of Object-
Oriented Programming. Polymorphism allows us to perform a single
action in different ways.
Procedural Language vs OOP
Aspect Procedural Language Object-Oriented Programming
Focus Focuses on functions and logic. Focuses on objects, which
represent real-world entities.
Usage Used for small programs and Used for larger programs and
applications. applications.
Importance It gives importance to functions It gives importance to data over
over data. functions.
Code Linear and sequential - step-by- Modular, Organizes code into
Organization step problem-solving. classes and objects.
Security Less secure. Provides Better security through
encapsulation, access specifiers.
Approach Procedural programming Object-oriented programming
follows a top-down approach. follows a bottom-up approach.
Code Less reusable. (via functions) More reusable. (via inheritance and
reusability polymorphism)
Flexibility Less flexible. Highly flexible.
Data hiding There is not any proper way for Supports data hiding.
data hiding.
Implementation Difficult to implement change. Easier to manage and implement
of change. change.
Example C, FORTAN, Pascal JAVA, C++, VB.NET, C#.NET.
Classes and Objects:
Classes:
A class is a blueprint or prototype or template for creating an object.
Each class has its attributes and methods that can be accessed and
manipulated through the objects.
You can create multiple objects from a class.
Objects:
An object is an instance of a Class.
An object is a real-world entity that has state and behaviour.
Objects have their own set of attributes (data) and methods (functions)
that describe and define their behavior.
If we consider the real world, we can find many objects around us, cars,
dogs, humans, table, chair, fan, computer, pen, etc. All these real- world
objects have different states and behaviors.
E.g., Bikes have
o attributes - (brand, color, engine capacity, fuelCapacity),
o methods - (accelerating, , and changing gears).
If we consider a human, then its
o states(attributes)- name, age, height, weight, email, nationality
o behaviors(methods)–eating, sleeping, walking, talking
Difference Between Objects and Classes:
1. Class: A class is a blueprint or template for creating objects.
Object: An object is an instance of a class.
For Example, blueprint of a bike is not a bike.
2. There is no memory allocation done at the time of creating class,
whereas, memory will get allocated at the time of creating objects.
Why Should we Use Objects and Classes?
Modularity, information hiding, can be incorporated using objects.
Classes also provide the benefit of reusability.
For example, bike manufacturers reuse the same blueprint over and
over again to build lots of bikes. Same way programmers use the same
class repeatedly to create many objects.
Class Declaration in Java:
A class can be declared using the keyword class followed by the name of
the class.
Class declaration syntax:
[modifiers] class ClassName [extends SuperClassName] [implements InterfaceNames]
{
...
}
The items enclosed inside [] are optional.
o modifiers declare whether the class is public, protected, default, abstract or final.
o ClassName- name of the class.
o SuperClassName- name of the superclass of the class.
o InterfaceNames - list of the interfaces implemented by ClassName
Only the class keyword and the class name are mandatory. Other parameters are
optional.
Class Body
The class contains two different sections:
o variable declarations and
o method declarations.
Three types of variables:
o Local variables,
o Instance variables, and
o Class variables.
1) Local variables are defined inside a method.
2) Instance variable is defined inside the class but outside the methods.
3) Class variables are declared with the static modifier inside the class and
outside the methods.
1. Local Variables:
Declared within a method, constructor, or block
Only accessible within that method, constructor, or block
No default value; must be initialized before use
Stored in the stack memory
public class Example {
public void myMethod() {
int x = 10; // local variable
System.out.println(x);
}
}
2. Instance Variables:
Declared within a class, but outside any method or block
Each instance of the class has its own copy
Can be accessed using an instance of the class
Default values are assigned (e.g., 0 for integers, null for objects)
Stored in the heap memory
public class Car {
String color; // instance variable
int speed; // instance variable
public void accelerate() {
speed++;
}
public static void main(String[] args) {
Car myCar = new Car();
myCar.color = "Red";
myCar.speed = 60;
System.out.println(myCar.color + " " + myCar.speed);
}
}
3. Class Variables (Static Variables):
Declared with the static keyword within a class
Shared by all instances of the class
Can be accessed using the class name or an instance
Default values are assigned (e.g., 0 for integers, null for objects)
Stored in the method area of the heap memory
public class Counter {
static int count = 3; // class variable
public Counter()
{
count++;
}
public static void main(String[] args) {
Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(Counter.count); // prints 2
}
}
Key differences:
Scope: Local variables are only accessible within a method or block, instance
variables are accessible within an instance, and class variables are accessible
using the class name or instance.
Lifespan: Local variables are created and destroyed within a method or block,
instance variables are created and destroyed with an instance, and class
variables are created when the class is loaded and destroyed when the class is
unloaded.
Memory allocation: Local variables are stored in the stack, instance variables
are stored in the heap, and class variables are stored in the method area of the
heap.
Creating Objects:
In Java, new keyword is used to create an object or instance of the class.
Syntax:
ClassName object = new ClassName();
Example:
SalesTaxCalculator obj1 = new SalesTaxCalculator();
This statement creates a new SalesTaxCalculatorobject.This
single statement declares, instantiates, and initializes the object.
Steps for creating an object:
1. Declaring an Object
2. Instantiating an Object
3. Initializing an Object
1) Declaring an Object:
Object declarations are same as variable declarations.
Generally, the declaration is as follows:
type name;
Example:
SalesTaxCalculator obj1;
where type is the type of the object (i.e., class name) and name is the
name of the reference variable used to refer the object.
2) Instantiating an Object:
After declaring a variable, an actual, physical copy of the object must be
acquired and assigned to that variable. In other words, (we need allocate
memory for the object).
The new keyword allocates memory for an object and returns a
reference, this reference is nothing but the address in the memory of
the object allocated by new.
This reference or memory address is stored in the variable declared.
SalesTaxCalculator obj1 = new SalesTaxCalculator()
In above statement, new operator creates an object obj1 by allocating
memory for its member variables.
3) Initializing an Object:
Initializing an object means assigning initial values to its attributes.
