- University Admissions
- Subject
- Business Tutoring
- Management
- Computer Science / it
- Mathematics
- Finance
- Social Sciences
- Healthcare and Nutrition
- Science
- Humanities
- Biotechnology
- Law
- Communication
- Services
- Editing & Proofreading
- Blog
You may have heard of object-oriented programming oop, but what are the concepts that make it work? Object Oriented programming oop is a programming approach that relies on the concept of classes and objects. In this article, we'll explore the four pillars of oop: inheritance oop, abstraction oop, polymorphism oop, and encapsulation oop. Understanding these concepts is key to using oop effectively in your own code. Let's get started!
Before we can start talking about the four pillars of object-oriented programming, we need to make sure that we're all on the same page when it comes to understanding the basics. So, let's take a look at what object-oriented programming is and how it works.
Object-oriented programming is a way of designing software using objects, which are essentially reusable templates for data. In object-oriented programming, each object has its own data and its own set of instructions for processing that data. This allows you to create complex systems by combining simple objects together.
- Instead of having to start writing the code from scratch, OOP can build programs using pre-built, interconnected modules, which reduces development time and increases productivity.
- OOP makes it possible to split down programs into bit-sized problems so they can be solved easily.
- It can be upgraded from small to large systems easily.
- It allows multiple objects to co-exist without any interference.
- It is very easy to partition the work in a project based on objects.
- The principle of data hiding helps the programmer build secure programs which can’t be invaded by the code in other parts of the program.
- By using the data hiding principle, programmers can create secure programs that can’t be invaded by the code from other areas of the program.
- By using the data hiding principle, programmers can create secure programs that can’t be invaded by the code from other areas of the program.
- By using inheritance, we can reduce redundant code and increase the use of pre-existing classes.
- Because message-passing techniques are utilised for inter-object communication, describing interfaces with external systems is significantly easier.
- The data-centred design approach makes it possible to capture more model details in an implementable form.
Tutoring Lounge professional tutors go through a rigorous selection and training process called a tutoring academy. Only 5% of applicants are good enough to become qualified Tutors.
You can rest assured that only the best tutor will teach you and guide you regarding your subject.
- Native speakers
- University graduates
- Academic writing experts
- Knowledgeable in various fields of study
There are four pillars of object-oriented programming: inheritance, abstraction, polymorphism, and encapsulation. We'll go into more detail about each one of these oop concepts in future paragraphs.
Inheritance in Object-Oriented Programming
Inheritance is one of the key concepts in object-oriented programming. In a nutshell, it allows you to create a new class that inherits all the properties and methods of an existing class. That way, you don't have to start from scratch each time. You can simply reuse the code from an existing class, and tweak it to suit your own needs.
This is a really powerful concept because it allows you to build on the work of others. And it's one of the things that makes object-oriented programming so powerful and scalable. You can keep building on top of existing classes, creating ever-more complex systems, without having to start from scratch each time.
Single Inheritance is a subclass which is derived from only one super class. Behaviour and properties of a single-parent class are inherited by single inheritance.
Example of Single Inheritance
public class Shape
{
int length;
int breadth;
}
public class Rectangle extends Shape
{
int area;
public void calcualteArea()
{
area = length*breadth;
}
public static void main(String args[])
{
Rectangle re = new Rectangle();
re.length = 10;
re.breadth = 20;
//Calculate the area
re.calcualteArea();
System.out.println("The Area of rectangle of length ""
+re.length+"" and breadth ""+re.breadth+"" is ""+re.area+""");
}
}
Output
The Area of rectangle of length "10" and breadth "20" is "200"
Multilevel Inheritance is a class that is inherited from a class which is inherited from another class.
Example of Multiple inheritance
interface Car
{
int speed=60;
public void distanceTravelled();
}
interface Bus
{
int distance=100;
public void speed();
}
public class Vehicle implements Car,Bus
{
int distanceTravelled;
int averageSpeed;
public void distanceTravelled()
{
distanceTravelled=speed*distance;
System.out.println("Total Distance Travelled is : "+distanceTravelled);
}
public void speed()
{
int averageSpeed=distanceTravelled/speed;
System.out.println("Average Speed maintained is : "+averageSpeed);
}
public static void main(String args[])
{
Vehicle v1=new Vehicle();
v1.distanceTravelled();
v1.speed();
}
}
Output
Total Distance Travelled is : 6000 Average Speed maintained is : 100
Hierarchical Inheritance is when several classes are derived from a single base class. The combination of two or more types of inheritance is called Hybrid Inheritance.
Example of Hierarchical
public class ClassA
{
public void dispA()
{
System.out.println("disp() method of ClassA");
}
}
public class ClassB extends ClassA
{
public void dispB()
{
System.out.println("disp() method of ClassB");
}
}
public class ClassC extends ClassA
{
public void dispC()
{
System.out.println("disp() method of ClassC");
}
}
public class ClassD extends ClassA
{
public void dispD()
{
System.out.println("disp() method of ClassD");
}
}
public class HierarchicalInheritanceTest
{
public static void main(String args[])
{
//Assigning ClassB object to ClassB reference
ClassB b = new ClassB();
//call dispB() method of ClassB
b.dispB();
//call dispA() method of ClassA
b.dispA();
//Assigning ClassC object to ClassC reference
ClassC c = new ClassC();
//call dispC() method of ClassC
c.dispC();
//call dispA() method of ClassA
c.dispA();
//Assigning ClassD object to ClassD reference
ClassD d = new ClassD();
//call dispD() method of ClassD
d.dispD();
//call dispA() method of ClassA
d.dispA();
}
}
Output
disp() method of ClassB disp() method of ClassA disp() method of ClassC disp() method of ClassA disp() method of ClassD disp() method of ClassA
Abstraction in Object-Oriented Programming
In object-oriented programming, abstraction is the process of hiding the details of an object or class, leaving only its essential features visible to the user. This is meant to make it easier for developers to work with complex code, by providing a level of simplification.
Think of it this way: abstraction is like a summary, or an overview, of a more detailed set of information. When you're reading a summary, you don't need to know all the little details included in the full text. You get the basic idea, and that's all you need.
The same principle applies to object-oriented programming. By abstracting away the details of an object or class, you can focus on its essential features, without getting bogged down in unnecessary complexity.
Example of Abstraction
// Abstract class
abstract class Animal {
// Abstract method (does not have a body)
public abstract void animalSound();
// Regular method
public void sleep() {
System.out.println("Zzz");
}
}
// Subclass (inherit from Animal)
class Pig extends Animal {
public void animalSound() {
// The body of animalSound() is provided here
System.out.println("The pig says: wee wee");
}
}
class Main {
public static void main(String[] args) {
Pig myPig = new Pig(); // Create a Pig object
myPig.animalSound();
myPig.sleep();
}
}
Output
The pig says: wee wee Zzz
Polymorphism in Object-Oriented Programming
What do you know about polymorphism? Well, it's one of the core pillars of object-oriented programming. Put simply, polymorphism is the ability of an object to act differently depending on its data type.
For example, consider a function that takes two arguments, an integer and a string. Depending on the data types of these two arguments, the function can return different results. If both arguments are integers, it might return the sum of them; if one is an integer and the other is a string, it might return the concatenation of them; and if both are strings, it might return their difference.
The ability of a single piece of code to handle multiple data types like this is what makes polymorphism so powerful. It allows for greater flexibility in code design and reduces redundancy in your application's codebase by letting you reuse logic for different types of data.
Example of Polymorphism
class Helper {
// Method 1
// Multiplication of 2 numbers
static int Multiply(int a, int b)
{
// Return product
return a * b;
}
// Method 2
// // Multiplication of 3 numbers
static int Multiply(int a, int b, int c)
{
// Return product
return a * b * c;
}
}
// Class 2
// Main class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Calling method by passing
// input as in arguments
System.out.println(Helper.Multiply(2, 4));
System.out.println(Helper.Multiply(2, 7, 3));
}
}
Output
8 42
Encapsulation in Object Oriented Programming
Encapsulation is the object-oriented programming principle that refers to bundling related data and functions into a single unit, otherwise known as an ‘object’. This helps to reduce complexity, improve security, and make code easier to read.
Encapsulation is also used to control access to certain data and operations. Private or protected data can only be accessed by other members of the class, while public or package-level members can be accessed by any part of the system that imports it. This allows developers to ensure that only authorised code can view or modify certain variables or functions while maintaining ‘encapsulated’ boundaries throughout the system.
In addition, encapsulation makes code more reusable because parts of the system can easily be changed or reused without affecting other components in the system. This allows for faster development speeds by using existing chunks of code instead of rewriting them from scratch each time a new feature is needed.
Overall, encapsulation is an important feature in object-oriented programming and can help create robust systems with better readability, security and maintainability
Example of Encapsulation
class Encapsulate {
// private variables declared
// these can only be accessed by
// public methods of class
private String geekName;
private int geekRoll;
private int geekAge;
// get method for age to access
// private variable tuAge
public int getAge() { return tuAge; }
// get method for name to access
// private variable tuName
public String getName() { return tuName; }
// get method for roll to access
// private variable tuRoll
public int getRoll() { return tuRoll; }
// set method for age to access
// private variable tuage
public void setAge(int newAge) { tuAge = newAge; }
// set method for name to access
// private variable tuName
public void setName(String newName)
{
tuName= newName;
}
// set method for roll to access
// private variable geekRoll
public void setRoll(int newRoll) { tuRoll = newRoll; }
}
public class TestEncapsulation {
public static void main(String[] args)
{
Encapsulate obj = new Encapsulate();
// setting values of the variables
obj.setName("Rana");
obj.setAge(25);
obj.setRoll(101);
// Displaying values of the variables
System.out.println("Tu name: " + obj.getName());
System.out.println("Tu age: " + obj.getAge());
System.out.println("Tu roll: " + obj.getRoll());
}
}
Output
Tu name: Rana Tu age: 25 Tu roll: 101
Summarising the Four Pillars of OOP
So now that you understand the four crucial pillars of object-oriented programming—inheritance, abstraction, polymorphism, and encapsulation—it's time to review what they all mean.
Inheritance allows you to share attributes, states, and behaviours between objects, making code DRY (Don't Repeat Yourself). Abstraction helps you exclude unnecessary details from your code by dealing with objects at a higher level. Polymorphism allows for streamlined code and results in flexible systems that are able to handle different inputs or data types. And last but not least, encapsulation helps you hide the inner workings of a system and create barriers between the objects in your program.
In other words, these four pillars of object-oriented programming provide a way to design systems with predictability and flexibility. It’s easy to see why OOP is one of the most popular coding paradigms today!
While attending college, students face numerous challenges. Their academic life is complicated by these problems. If you are one of them who can relate, Tutoring Lounge offers its online tutoring service to you.
- You don't understand your subject
- You have part-time work and don't have enough time.
- You are lagging behind your classmates.
