Java Tutorial

OOPs Concepts in Java (Explained With Examples)


Want to learn about the OOPs concepts in Java? Here is a blog explaining key object-oriented programming concepts, including inheritance, encapsulation, abstraction, polymorphism, and more. Some widely-used OOP languages are Python, C++, Ruby, Smalltalk, JavaScript, C#, etc. Let’s discuss concepts of OOPs in Java and much more in detail.

What Is OOPs in Java?

Object-Oriented Programming or OOPs is a widely-used concept in programming languages like Java and revolves around objects. It allows you to create objects you want, along with different methods to manage those objects. 

An object contains functions and properties, such as your car, laptop, house, etc. They are seen by a user or viewer and perform assigned tasks. Objects are a primary source of OOPs to implement what is to happen in a code. The basis of the OOPs Java concepts is based on creating objects, reusing them through programs without compromising security, and manipulating them to generate desired results. 

This programming concept works to implement real-world entities, such as abstraction, inheritance, encapsulation, and polymorphism. It aims at binding the data and functions together that operate them so no section of a code can access it except that specific function. OOP in Java includes key concepts to enable developers to write reusable, modular, and maintainable code.

OOPs Concepts in Java

Object-oriented programming in Java is a paradigm used to design a program using objects or classes. It makes software development and maintenance easier through its various concepts. Have a look at the brief explanation of each OOPs concept in Java with examples, their implementation in Java, and examples. 

1. Class

A class in Java OOPs concepts is a group of similar entities and represents a set of properties common to all objects of one type. It is a user-defined blueprint to create multiple objects without repeatedly writing the same code. 

Hence, classes for code occur multiple times in a code. Classes don’t have a physical entity but are logical components. Also known as a template of an object, classes don’t occupy any space in memory and can be static and instance initialisers.

Components of class

A class declaration includes the following components:

  • Modifiers: They can be public or have default access.

  • Class name: Must begin with a capitalised initial letter.

  • Superclass: Class’s parent preceded by keyword extends. A class can extend to only one parent.

  • Interface: It is a comma-separated list of interfaces preceded by keyword implements. More than one interface can be implemented.

  • Body: It is closed in braces {}.


Here's an example of a class in Java OOPs:

public class Car {
    // Class variables (also known as fields or attributes)
    private String make;
    private String model;
    private int year;
    // Constructor
    public Car(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;
    // Getter methods
    public String getMake() {
        return make;
    public String getModel() {
        return model;
    public int getYear() {
        return year;
    // Setter methods
    public void setMake(String make) {
        this.make = make;
    public void setModel(String model) {
        this.model = model;
    public void setYear(int year) {
        this.year = year;
    // Method that returns a formatted string representation of the object
    public String toString() {
        return year + " " + make + " " + model;

Code Explanation:

Here, the Car class has three instance variables (make, model, and year) that store information about a car. The class also has a constructor that takes in values for these instance variables and sets them accordingly. Additionally, there are getter and setter methods that allow access to these instance variables from outside the class.

The toString method is also overridden to return a string representation of the Car object in a specific format.

2. Method 

A method is a collection of multiple statements used to perform a specific task and give results to the caller. It is like a function to expose the behaviour of an object. 

As the important concept of OOPs in Java, the method can also perform a task without returning a result. Users can reuse code without re-writing the code. Also, each method is a part of a class in Java. 

  • Example 

Here's an example of a method in Java OOPs:

public class Calculator {
    // Method to add two integers and return the result
    public int add(int a, int b) {
        return a + b;
    // Method to subtract two integers and return the result
    public int subtract(int a, int b) {
        return a - b;
    // Method to multiply two integers and return the result
    public int multiply(int a, int b) {
        return a * b;
    // Method to divide two integers and return the result
    public double divide(int a, int b) {
        // Check for divide-by-zero error
        if (b == 0) {
            throw new IllegalArgumentException("Cannot divide by zero");
        return (double) a / b;

Code Explanation:

Here, the Calculator class has four methods (add, subtract, multiply, and divide) that perform basic arithmetic operations on integers. The add, subtract, and multiply methods simply return the result of adding, subtracting, or multiplying the two input integers, respectively.

The divide method, on the other hand, checks for a divide-by-zero error and throws an exception if the second input integer (b) is zero. If b is not zero, the method returns the result of dividing a by b as a double.

3. Object

It is among the most important OOPs concepts in Java. Also classed instances, an object is a basic concept of OOPs representing real-life entities, i.e., they correspond to things we come across in the real world. Hence, they are also known as run-time entities of the world. There can be multiple objects in a class. 

Objects are self-contained, comprising various properties and methods which make useful data. They can be both logical and physical, including addresses, and occupy memory space. A typical Java program creates various objects, which interact by invoking methods and are part of code visible to users or viewers. 

An object comprises the following:

  • State: The features and properties of an object define it.

  • Behaviour: Reflects an object’s response to other objects. It is represented by object methods.

  • Identity: A unique name for an object which allows it to interact with other objects.


Here's an example of an object in Java OOPs:

public class Car {
    // Instance variables
    private String make;
    private String model;
    private int year;

    // Constructor
    public Car(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;

    // Getter methods
    public String getMake() {
        return make;

    public String getModel() {
        return model;

    public int getYear() {
        return year;

    // Setter methods
    public void setMake(String make) {
        this.make = make;

    public void setModel(String model) {
        this.model = model;

    public void setYear(int year) {
        this.year = year;

Code Explanation:

In this example, the Car class defines a blueprint for a car object. Each car object created from this class will have its own set of instance variables (make, model, and year) that can be accessed and modified through getter and setter methods.

To create an object of the Car class, you can use the new keyword followed by the class name and constructor arguments, like this:

Car myCar = new Car("Toyota", "Corolla", 2022);

This creates a new Car object with the make set to "Toyota", model set to "Corolla", and year set to 2022. You can then access and modify the object's instance variables using the getter and setter methods, like this:

String carMake = myCar.getMake(); // returns "Toyota"
myCar.setYear(2023); // sets the year to 2023
int carYear = myCar.getYear(); // returns 2023

In this way, objects in Java OOPs are used to represent specific instances of a class, with their own unique set of attributes and behaviors.

4. Abstraction

Data Abstraction is a method of displaying essential information without highlighting other trivial or non-essential background details. It is a crucial concept and makes your introduction to OOP in Java effective. 

This OOPS concept in Java is used to create a new type of data suited for specific apps. It is one of the key object-oriented features of Java. Abstraction also means identifying only the required or key features of an object without focusing on irrelevant details. 

These properties, behaviours, and attributes of an object make it stand out from other similar objects and make it possible to classify them. 

There are abstract classes and abstract methods. The former declares one or more abstract methods, while the latter defines the method but not the implementation. Once you create an object based on data abstraction, the same details can be used for other applications, such as OOP hierarchy and abstract classes. 

An abstract class can have regular and abstract methods. Moreover, abstract methods are used when two or more classes perform the same task differently through different implementations. 

Benefits of Abstraction in Java OOPs

  • Enhances application maintainability and modularity.

  • Facilitates code reusability and organisation.

  • Offers data hiding feature, which enhances security and protects sensitive details from unauthorised access. It hides details related to implementation and exposes only important and relevant information.

  • Mitigates the risk of code duplication. 

  • Offers a simple and clear user interface.

  • Reduces complexity and enhances code readability.

  • Provides only essential details to users and keeps the application secure.

  • Improves productivity by hiding irrelevant or trivial details.

  • Ensures hassle-free software maintenance.

  • Any updates in code rarely change the abstraction.

  • As users can make changes in the internal system without affecting end-users, enhancement is quite easy.

  • Allows to divide a complex system into small and manageable components.

  • As it allows modularity and separation of concerns, it is easier to maintain and debug code.

  • Hides complex details related to implementation from users, making it easier for them to understand and use details.

  • Makes it possible to make changes to the implementation details without affecting the user-facing interface. Hence, allowing more flexibility in the program implementation. 

How to Implement Abstraction in Java OOPs?

In Java, abstraction is implemented through interfaces and abstract classes. The algorithm for abstract implementation is:

  • Identify the interfaces or classes to be a part of abstraction.

  • Create an abstract class with common behaviours and attributes of all included classes.

  • Define the abstract methods within the classes without any implementation details.

  • Implement the concrete classes that implement the interface or extend the abstract class.

  • To provide a specific implementation for each class, override the abstract methods in the concrete classes.

  • Implement the program logic using the concrete classes. 

Example of abstraction in Java OOPs

Here's an example of abstraction in Java OOPs:

public abstract class Shape {
    // Abstract methods
    public abstract double getArea();
    public abstract double getPerimeter();

public class Circle extends Shape {
    // Instance variable
    private double radius;

    // Constructor
    public Circle(double radius) {
        this.radius = radius;

    // Implementing abstract methods
    public double getArea() {
        return Math.PI * radius * radius;

    public double getPerimeter() {
        return 2 * Math.PI * radius;

public class Rectangle extends Shape {
    // Instance variables
    private double length;
    private double width;

    // Constructor
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;

    // Implementing abstract methods
    public double getArea() {
        return length * width;

    public double getPerimeter() {
        return 2 * (length + width);

Code Explanation:

In this example, the Shape class is an abstract class that defines two abstract methods (getArea and getPerimeter) that must be implemented by any concrete subclass of Shape. This abstract class encapsulates the common attributes and behaviors of different shapes, without specifying their concrete implementation.

The Circle and Rectangle classes are concrete subclasses of Shape, which implement the getArea and getPerimeter methods for circles and rectangles, respectively. These classes provide their own implementation of the abstract methods, while inheriting the common attributes and behaviors from the Shape class.

5. Encapsulation

Encapsulation is the process of wrapping or binding data and code in a single unit to keep them safe from any misuse or interference. It is like a protective shield that eliminates the chances of data being accessed by outsiders. It keeps data hidden from other classes and allows access only through current class methods. 

Hence, it is also called data hiding. The access is controlled through a meticulously defined interface. Encapsulation is among the main OOPs concepts in Java and is achieved by declaring variables in a class as private and providing public methods to view and alter the values of variables. 

Here, fields are either read-only or write-only. Code in encapsulation is easy to test, and it enhances code reusability. 

  • The variables in a class are hidden from other classes, and access is allowed through the member function of that class.

  • Data is hidden from other classes, a process similar to data hiding. So, we can use encapsulation and data-hiding interchangeably. 

Benefits of Encapsulation

  • Hides internal state and implementation details of a class to prevent unauthorised data access and manipulation. This enhances data security and protects it from the outside world.

  • Encapsulated code is easier to test for unit testing.

  • New fields and methods can be easily added without affecting the existing code.

  • Provides a controlled interface to interact with a class. Hence, allowing changes to the internal implementation without affecting external implementation.

  • Its support of the object-oriented principle of information hiding allows users to modify implementation without making changes to the rest of the code.

  • Breaks down complex systems into smaller and more manageable components so the codebase is easier and more modular to maintain.

  • Its support for data abstraction allows objects to be treated as one unit.

  • Enhances code reusability and adapts to new requirements.

How encapsulation is implemented in Java?

In Java, encapsulation is implemented by declaring instance variables as private. Hence, they can be accessed within the class. To make instance variables accessible to outsiders, you must use public methods, getters and setters, which retrieve and modify the values of variables, respectively. The methods also allow the class to enforce its data validation rule and check that its internal state is consistent. 

  • Example of encapsulation

Here's an example of encapsulation in Java OOPs:

public class BankAccount {
    // Private instance variables
    private String accountNumber;
    private double balance;
    private String customerName;
    private String email;
    private String phoneNumber;

    // Constructor
    public BankAccount(String accountNumber, double balance, String customerName, String email, String phoneNumber) {
        this.accountNumber = accountNumber;
        this.balance = balance;
        this.customerName = customerName; = email;
        this.phoneNumber = phoneNumber;

    // Public methods for accessing and modifying private variables
    public String getAccountNumber() {
        return accountNumber;

    public double getBalance() {
        return balance;

    public String getCustomerName() {
        return customerName;

    public String getEmail() {
        return email;

    public String getPhoneNumber() {
        return phoneNumber;

    public void setBalance(double balance) {
        this.balance = balance;

    public void deposit(double amount) {
        balance += amount;

    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            System.out.println("Insufficient funds.");

Code Explanation:

Here, the BankAccount class encapsulates the data related to a bank account, such as the account number, balance, customer name, email, and phone number. These variables are marked as private, so they can only be accessed and modified within the BankAccount class.

To allow other classes to interact with the BankAccount object, public methods are defined that provide controlled access to the private variables. These methods, such as getBalance, deposit, and withdraw, hide the implementation details of the BankAccount object and ensure that the object is used in a safe and controlled way.

6. Inheritance

Inheritance is a pillar of OOPs concepts in Java, in which one object acquires or inherits features, such as fields and methods, of another class. It also supports hierarchical classification and is achieved using the extends keyword. 

The object that inherits properties is called a subclass, and the one getting inherited is known as a superclass. The idea behind inheritance is that we can build a new class by reusing fields and methods of an existing or parent class. 

This represents the parent-child relationship. Some frequently used terminologies in inheritance are:

  • Superclass: The class whose attributes are inherited, also known as a parent or base class.

  • Subclass: Also known as derived, child, or extended class, it inherits features of a parent class. The child class can have its own methods and fields added to that of a parent class.

  • Reusability: Inheritance supports reusability when a new class is created by reusing some of the attributes of a parent class. 

Benefits of Inheritance in Java

  • Inheritance supports polymorphism, where different subclass objects are treated as the same superclass objects. Hence, making it easier to write generic code.

  • Through inheritance from a superclass, a subclass can reuse the code and functionality defined in the superclass. This makes writing and maintaining code easier.

  • Makes it possible to add new features to the existing class hierarchy without making changes to the existing code. 

How inheritance is implemented in Java?

Inheritance is implemented in Java using ‘extends’ keywords. Implementation of parent class recreates a new class, called a child class. To inherit properties of the parent class, a child class must use ‘extends’ keywords as it enables compilers to know that the latter derives attributes and functionalities of the former. 

  • Example of Inheritance

Here's an example of inheritance in Java OOPs:

public class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) { = name;
        this.age = age;

    public void speak() {
        System.out.println("I am an animal.");

    public String getName() {
        return name;

    public int getAge() {
        return age;

public class Dog extends Animal {
    private String breed;

    public Dog(String name, int age, String breed) {
        super(name, age);
        this.breed = breed;

    public void bark() {
        System.out.println("Woof woof!");

    public void speak() {
        System.out.println("I am a dog.");

    public String getBreed() {
        return breed;

Code Explanation:

In this example, the Animal class is a superclass that defines the common attributes and behaviors of all animals. The Dog class is a subclass of Animal, which inherits the attributes and behaviors of Animal and adds some additional attributes and behaviors that are specific to dogs.

The Dog class overrides the speak method of the Animal class to provide a specialized implementation for dogs. It also defines a bark method that is specific to dogs.

7. Polymorphism

Polymorphism is an important feature of OOPs, which allows users to define a single interface and have multiple implementations. ‘Poly’ means ‘many’, and ‘morphs’ means ‘forms’. 

Hence, polymorphism refers to many forms and is defined as the ability to perform a single action in multiple ways. It allows OOPs to differentiate between various entities with the same name with the help of their declaration and signature. It happens when various classes are associated with each other through inheritance. 

Types of Polymorphism in Java OOPs

Polymorphism is of two types- 

  • Compile-time: Also known as static polymorphism, it is achieved through operator or function overloading. The term overloading refers to different functions sharing the same name but having distinct parameters. They can be overloaded because of the changes in the number of arguments or type of arguments.

  • Run-time: Also known as dynamic method dispatch, it is achieved by overriding, which occurs when a subclass has a definition of one of the member functions of a superclass. 

Benefits of Polymorphism

  • Supports code reusability as classes can inherit properties of other classes and share methods and attributes.

  • Allows more flexibility and adaptability of code by treating objects of different classes as objects of a common class.

  • Enables using generic code to manage different objects, simplifying code and treating objects as a single type.

  • Enhances code readability and maintainability by reducing the amount of code.

How polymorphism is implemented in Java?

In Java, polymorphism can be achieved in the following ways:

  • Method Overloading 

It is the process where classes have two or more methods that share the same name. Any specific method is implemented according to the number of parameters in a method call. 

  • Method Overriding

If a child class has the same method as the parent class, it is known as method overriding. In this procedure, the compiler allows a child class to have the same method provided in the parent class.  

  • Example of Polymorphism

Here's an example of polymorphism in Java OOPs:

public class Animal {

    public void speak() {

        System.out.println("I am an animal.");



public class Dog extends Animal {


    public void speak() {

        System.out.println("I am a dog.");



public class Cat extends Animal {


    public void speak() {

        System.out.println("I am a cat.");



public class Main {

    public static void main(String[] args) {

        Animal animal1 = new Animal();

        Animal animal2 = new Dog();

        Animal animal3 = new Cat();

        animal1.speak(); // Output: I am an animal.

        animal2.speak(); // Output: I am a dog.

        animal3.speak(); // Output: I am a cat.



Code Explanation:

In this example, the Animal class has a speak method that prints "I am an animal." The Dog class and Cat class are subclasses of Animal, which override the speak method to provide specialized implementations for dogs and cats.

In the Main class, we create three Animal objects: animal1 of type Animal, animal2 of type Dog, and animal3 of type Cat. We then call the speak method on each of these objects. 

Even though all of these objects are of type Animal, they each have their own implementation of the speak method based on their specific type. This is an example of polymorphism in Java OOPs concepts.

Benefits of OOPs Concepts in Java

Some of the common benefits of OOPs concepts are:

1. Security 

It allows data hiding and abstraction, hiding complex or irrelevant details and exposing only critical and relevant information. As only necessary data is available to view, it ensures data security and protection.

2. Reusability 

This is one of the major benefits of object-oriented programming. Reusability refers to writing only once while using it multiple times. So, rather than building or writing code repeatedly, you can use the same code again and again whenever required using class. 

3. Easy Code Maintenance 

You can change and maintain existing code easily as new objects. They are some minor changes in the existing code to create new ones. Hence, saving a lot of rework, effort, and time for users.

4. Easy Troubleshooting

As encapsulation is self-constrained, developers can solve any issue without hassle. It eliminates the chances of code duplicity as well. 

5. Data Redundancy

This is another key benefit of OOPs. Data redundancy occurs in data storage when the same piece of information is stored in two different places. If users want to use the same functionality in multiple classes, they simply need to write common class definitions for those functionalities by inheriting them.

6. Seamless Design

With an extensive and long design phase, designers can attain way better results. When a program reaches its critical limit, it is easier to program all non-OOPs separately. 

More advantages of OOPs are as follows:

  • Easy and clear modular structure for programs.

  • You can build programs using standard working modules that interact with one another instead of writing the code repeatedly from scratch. Hence, saving ample development time and enhancing productivity.

  • Makes it easier to divide the work in a project according to objects.

  • Through OOP language, you can break down a program into small-sized problems that are easier to solve. You can focus on one object at a time.

  • Objects created in OOPs can be reused in other programs as well, which saves a significant amount of development cost.

  • Inheritance eliminates code redundancy and extends the use of existing classes.

  • As each object exists independently, it improves program modularity.

  • Provides a data-centred design approach so you can collect more details related to a model in an implementable form.

  • It ensures improved software quality, greater productivity, and lower maintenance cost.

  • It is difficult to write large programs, but when developers and designers adhere to OOPs concepts, they can design better with no or minimal flaws.

  • As objects communicate with each other through a message-passing technique, it simplifies interface descriptions with external systems. 

  • Multiple objects can co-exist without any interference.

  • Through the data hiding principle, programmers can build secure programs, ensuring they can’t be hampered by the code used in other sections of a program.

  • It is easier to upgrade small OOP systems to larger ones.

All the listed benefits can be incorporated into a single OOP, but their usability or importance may vary based on the project or preference of a programmer.

Disadvantages of Java OOPs Concepts

Some of the drawbacks of the OOPs concept are:

  • Demands intensive testing procedure.

  • Programs developed using OOP languages are larger than the procedural approach. Hence, needs a lot of time to be executed, resulting in slow execution.

  • As everything is treated as an object in OOP, you need to think from an object’s perspective to apply it successfully.

  • OOP code is complicated, making it difficult to understand, especially if you don’t have the corresponding class documentation.

  • Needs a lot of time to address an issue.

  • Programs in OOP are slower than other programs.

  • Developing programs in OOPs demands a lot of work and effort.

  • Users may need additional time to get used to OOPs because the thought process involved in it may not come naturally to many people.

  • Software developed using OOPs needs a significant amount of pre-work and planning.

  • As OOP is a bit tricky, programmers need excellent designing and programming skills and proper planning before using it.

  • It can consume a massive memory in some situations.

  • Not a great option for solving small problems. 

  • OOP is not a universal language. Hence, it can’t be applied everywhere. It is suitable only when it is required exclusively.

Additional OOPs Concepts in Java

1. Aggregation

Aggregation is a technique where all objects have a separate lifecycle, but there is ownership. So, a child object can’t belong to any other parent object. In simple terms, when there is a ‘HAS-A’ relationship between objects and ownership, it’s called aggregation. 

For example, a single teacher can’t belong to different departments. However, if we remove a department, the teacher will continue to exist. 

2. Composition

It is a more restrictive form of aggregation and is also known as a death relationship. Composition is when a ‘HAS-A’ relationship can’t exist on its own. Child objects do not have a lifecycle of their own, so when parent objects are deleted, child objects are deleted automatically. 

For example, a house has several rooms. No room can exist without that house. As soon as a house is deleted, its room will be deleted too. 

3. Interfaces

In Java, an interface is an abstract that specifies the behaviour of a class. It is like a blueprint of class behaviour and consists of static constants and abstract methods. An interface is a mechanism to attain abstraction and multiple inheritance in Java. 

Similar to a class, an interface has abstract methods and variables. It can have abstract methods but not a method body. Moreover, interfaces represent the IS-A relationship. When you define an entity based on its behaviour and not attribute, it is called an interface. Methods declared in an interface are abstract by default. 

4. Coupling

Coupling is the relationship between two classes and indicates the direct knowledge that one class has of another. To explain further, it shows how frequent changes in the properties of one class impact the dependent changes in another class. These changes will vary based on the degree of interdependence of the two classes. There are two types of coupling:

  • Tight coupling: When two classes are strongly interrelated and often change together. So, if class A has extensive knowledge of how class B was implemented, they are tightly coupled.

  • Loose coupling: If two classes are independent, it is called loose coupling. If class A only knows what class B has exposed through its interface, then they are loosely coupled. 

5. Cohesion

Cohesion in Java measures how a class's attributes and methods are strongly connected. It also defines their focus while performing a single well-defined task. This indicates the extent of responsibility of a class. 

  • Low Cohesion: Low cohesion classes have a less logical relationship. Thereby, they are difficult to maintain. It comprises less focused and independent methods and properties.

  • High Cohesion: These classes are good for code reusability and keep classes focused on a single work. 

6. Association

The association is the relationship between objects. This OOP concept defines diversity between objects. Also, all objects in the association have an individual lifecycle with no owner. It can be a one-to-many relationship, like in a teacher and student relationship, where numerous students can associate with one teacher.

OOPs in Java FAQs

1. What is object-oriented programming?

Object-oriented programming (OOP) is a programming paradigm that is based on the concept of "objects," which are instances of classes that contain data and behavior. In OOP, classes are used to define objects, and objects are used to interact with each other to perform various tasks.

OOP is based on four fundamental concepts: encapsulation, inheritance, polymorphism, and abstraction. These concepts allow developers to create modular, reusable, and maintainable code that can be easily extended and modified.

2. What are the commonly-used OOP languages?

Various OOP languages that are used widely are:

  • Python

  • Java

  • C#

  • Ruby

  • Dart

  • Go

  • C++

3. Why is OOP popular?

OOP is considered a better and more efficient style of programming that enables you to write complex code easily and maintain them effectively. Its four main pillars- Data Abstraction, Encapsulation, Inheritance, and Polymorphism, help programmers to solve complex problems. Other reasons that make OOP popular among programmers are:

  • It is suitable for relatively big software.

  • Enhances the overall understanding of software as the gap between the language spoken by users and that spoken by developers.

  • Encapsulation makes code maintenance easier. You can change underlying code easily while keeping methods the same.

4. What are the key features of OOPs?

The main features of OOPs are also known as its four pillars or principles. They are as follows:

  • Encapsulation

  • Data Abstraction

  • Polymorphism

  • Inheritance

5. Why do we use OOPs concepts in Java?

In Java, OOPs concepts are used to implement different real-world entities, such as abstraction and inheritance, into programming. It is also used to secure code by binding data functions. Here are a few more uses of OOPs:

  • Data hiding

  • Make programming clearer and easier

  • Reduce data redundancy

  • Facilitate program flexibility through polymorphism

  • Make problem-solving more concise

  • Code reusability through inheritance

  • Divide a complex problem into subproblems. 

6. What is pure object-oriented language? Why is Java not a pure object-oriented programming language?

A pure object-oriented programming language treats everything within a problem as an object. It doesn’t support primitive types. Other features that a pure OOP language must satisfy are:

  • Abstraction

  • Inheritance

  • Polymorphism

  • Encapsulation

  • All user-defined, and pre-defined types are objects

  • Operations performed on objects must be through methods exposed to objects

Java is not counted as a pure object-oriented programming language because pre-defined data is not treated as objects. Thus, it doesn’t fulfil all the conditions required to be pure OOP language. 

7. What is the difference between overloading and overriding?

Overloading is a compile-time polymorphism feature with two or more implementation methods with the same name but different parameters. Examples include method overloading and operator overloading.

Overriding a type of run-time polymorphism and an important OOPs concept. It allows entities or sub-classes to have a specific implementation method provided by its parent class. 

8. What is a real-life example of data abstraction?

A perfect example of data abstraction is when you drive a car. When you press the accelerator, you know the speed will increase but have no idea how exactly it happens. So, irrelevant details are concealed in this case. 

9. What are the different types of inheritance?

Inheritance is of five types, which are as follows:

  • Single Inheritance: It is the child class derived from the base class.

  • Multiple Inheritance: This child class is derived from multiple base classes.

  • Multilevel Inheritance: Here, the child class is derived from another class, which is derived from a base class.

  • Hierarchical Inheritance: Multiple child classes are derived from one base class.

  • Hybrid Inheritance: It includes multiple inheritance types from the ones mentioned above. 

10. What is the difference between object-oriented programming and structural programming?

Structural programming is a subset of procedural programming and is considered a precursor to OOP. It consists of separate modules that are well structured. 

Here are a few differences between object-oriented and structural programming.

Object-Oriented Programming

Structural Programming

It is object-oriented programming built on objects with a state and behaviour.

Provides a logical structure by dividing programs into their corresponding functions.

Allows data hiding feature, providing data security.

Doesn’t support data hiding, which provides less security.

Follows a bottom-to-top approach.

Follows a top-to-down approach.

Helpful in solving complex problems.

Helpful in solving moderate problems. 

Data is more important.

Code is more important.

Restricts the flow of data to authorized parts, which ensures data security.

No restriction on the flow of data, and anyone can access the data.

Code reusability is possible due to polymorphism and inheritance. This reduces code redundancy.

Code reusability is possible through functions and loops.

Focuses on data.

Focuses on logical structure or procedure.

Easy to modify and update code.

Code modification is more difficult than OOPs.

More abstraction means more flexibility.

Less abstraction means less flexibility. 


Did you find this article helpful?