OOPs Concepts in Java with Examples

Do you find it hard to write clean, reusable, and scalable code in Java? Do you find yourself constantly debugging or rewriting the same logic over and over again? What if we told you that the solution to these problems generally lies in Object-Oriented Programming(OOP) concepts in Java? Java is typically one of the most popular programming languages used worldwide, and its power comes from its robust implementation of OOP principles. But still, most programmers think that they know OOPs, only to later realize that they’ve been wasting its potential. Are you one of them?

In this comprehensive Java OOPs tutorial, we will be covering Java OOPs concepts thoroughly, from objects and classes to inheritance, polymorphism, encapsulation, and abstraction, and learn real-world applications, best practices, and many more. Whether you’re new to Java Programming or an experienced Java Developer, this tutorial will help you write clean, scalable, and reusable Java code.

Table of Contents:

• What is OOP in Java?
• Why Java is Preferred for OOP
• History of OOP
• Core OOP Concepts in Java
• The Four Pillars of OOPs
• Important Java-Specific OOP Concepts
• Applications of OOP in Java
• Difference Between OOP and Procedural Programming
• Conclusion

What is OOP in Java?

Object-oriented programming (OOP) is a paradigm for programming that generally structures the program design around objects rather than functions and logic. OOPs simply form the foundation for the development of programs in Java. It is mainly the concept of objects and classes, with the class being the template to create objects, and objects being the instance of a class that represents real-world entities.

Generally, Java is designed in such a way that it supports the principles of OOPs, which makes it a great language for the development of modular, reusable, and scalable Java code. Java also allows programmers to organize code into objects such that it can represent complex systems in an intuitive and efficient way.

Why Java is Preferred for OOP

1. Pure Object-Oriented Language

Almost everything is typically an object in the Java Language. From different data types to some complex structures, Java works on OOP principles. Even primitive data types have their object types like Integer for int that maintain the object-oriented design of Java.

2. Platform Independence

Java is typically a platform-independent programming language that supports the “Write Once Run Anywhere” (WORA) feature that simply allows programmers to write code that can be reused and executed on any platform, which is very helpful when creating a large object-based system.

3. Rich Standard Library

Java also provides a vast collection of built-in classes and methods that simply utilize the OOP concepts. Whether handling different data structures, user interfaces or even networking, Java libraries simply make it easier to use Java OOP concepts.

4. Strong Support for the Principles of OOP

Java syntax and functionality are designed to support the four pillars of OOP:

• Encapsulation: This can be achieved through access modifiers like private, public, and protected.
• Inheritance: Need to use the extends keyword.
• Polymorphism: This can be achieved through method overriding and method overloading.
• Abstraction: This can be implemented through abstract classes and interfaces.

5. Strong Ecosystem

Java has a very big ecosystem, with the support of different frameworks like Spring, Spring Boot, and Hibernate, which are built on the foundations of OOP. They typically support the programmer to develop enterprise-level applications that are scalable and maintainable.

History of OOP

The concept of Object-Oriented Programming (OOP) started in the 1960s with Simula which was the first language to include objects and classes. Smalltalk in the 1970s further advanced OOP to make encapsulation, inheritance, and polymorphism common concepts.

Java, which debuted in 1995, made OOP mainstream with its platform independence and object-first nature. Today, OOP is a standard aspect of programming, with support in various languages like Python, C++, and C#.

Core OOP Concepts in Java

Let’s understand the core OOP principles in Java in a detailed manner:

Classes and Objects in Java

What is a Class in Java?

A class is simply a template or blueprint for the object creation. It generally defines the properties (attributes) and the actions (methods) the objects created by it will have. In simple words, thought of a class like the blueprint or plan, and an object is the actual implementation of the plan.

Important Features of a Class

• Attributes (Variables): They typically describe the state or information about an object. For example, the Car class can have attributes like: color, model, and speed.
• Methods (Functions): Methods in Java simply define the activities or actions of an object. For example, the Car class can have multiple different methods like start(), accelerate(), and stop().
• Constructors: Java Constructors are the type of special methods that are used to initialize objects when they are created.

Syntax of a Class:

class ClassName {
    // Attributes (variables)
    dataType attribute1;
    dataType attribute2;

    // Constructor
    ClassName(parameters) {
        // Initialization code
    }

    // Methods (functions)
    returnType methodName(parameters) {
        // Method body
    }
}

Example of a Class:

In the example shown above, the Car class has three properties, color, model, and speed, a constructor that is used to initialize the object, and three methods such as start, accelerate, and stop.

What is an Object?

An object is typically an instance of a class, which represents the real-world entity that can interact with other objects. Whenever you create any object in Java, you are just representing the blueprint of the particular class.

Main Characteristics of an Object:

• State: They are typically represented by attributes of the object.
• Behavior: Their behavior is typically shown by the object’s methods.
• Identity: It is a name given to the object references that generally differentiates one object from another.

Syntax of Object Creation:

ClassName objectName = new ClassName(arguments);

Example of Object Creation:

In the code above myCar is an object of class Car, which holds its state such as color = “Red”, model = “Toyota”, and also can perform different actions like start, accelerate, and stop.

Why Are Classes and Objects Important?

• Modularity: Classes in Java simply let you break down complex problems into small, manageable parts.
• Reusability: Once you have created a class, you can also create many objects from it, which simply results in avoiding code repetition.
• Real-World Modeling: Objects and classes also help with modeling real-world entities and the way they interact in the real world.

Methods and Constructors in Java

Methods and constructors are the two most important components of a class in Java OOP. They generally define the operations that objects perform and the way objects are created. Now, let’s learn about them in detail:

What is a Method?

A method in Java is a block of code that does any specific task. It typically defines the overall behavior of an object and can be called whenever you want to execute its functionality. Methods are reusable since you can call them several times without having to repeat the whole code.

Main Features of Methods:

• Reusability: These Java Methods let you write code once and use it numerous times.
• Parameters: Methods can be provided with inputs (parameters) in order to perform tasks dynamically.
• Return Value: These methods can also give the return value after finishing any task.

Syntax of a Method:

returnType methodName(parameterList) {
    // Method body
    return value; // Optional (if returnType is not void)
}

Example of a Method:

In the example discussed above, the add() method takes two integers as arguments and returns the sum. The displayMessage method takes a String argument and then prints it.

Types of Methods

• Instance Methods: These methods belong to an object and can utilize instance variables.
• Static Methods: They typically belong to the class and can be accessed without the need to create an object.
• Constructor Methods: They are just special methods that are used to initialize objects.

Example:

Output:

What is a Constructor?

Constructor is a special method that is used for initializing objects at the creation time. Its name is the same as the class name and it does not return anything.

Key Characteristics of Constructors:

• Initialization: Constructors initialize the state of an object by simply assigning its attributes with values.
• Automatic Invocation: When you use the new keyword to create an object, the constructor is invoked automatically.
• Overloading: You can also declare multiple constructors with different parameters.

Syntax of a Constructor:

ClassName(parameterList) {
    // Initialization code
}

Example of a Constructor:

Output:

In the above code example, the constructor for the Student class typically initializes the age and name properties when the object is created.

Types of Constructors

• Default Constructor: Default constructors are typically provided by Java internally. If no constructor has been created explicitly, then it will be called automatically. It initializes the fields with default values (i.e., 0, null).
• Parameterized Constructor: These constructors accept arguments in order to initialize the attributes with specific values.
• Copy Constructor: It generally makes an object by copying the properties of another object.

Example:

Output:

Why Are Methods and Constructors Important?

• Code Reusability: Methods allow code reusability, reducing duplication.
• Initialization of Objects: With Constructors it is guaranteed that objects are initialized when they are created.
• Modularity: Methods and constructors typically help to break down large and complex processes into small, workable parts.

The Four Pillars of OOPs

1. Encapsulation in Java

One of the four principles used in Object-Oriented Programming (OOP) is encapsulation. Encapsulation is the bundling together of the data (attributes) and the methods (behaviors) that operate on the data into one entity, typically a class. Encapsulation also involves restricting direct access to specific parts of an object, which is achieved by the use of access modifiers.

In simple terms, encapsulation is all about:

• Masking the internal processes by which an object operates.
• Protect the information against tampering or unauthorized use.
• Making the information publicly accessible with controlled access.

Why is Encapsulation Important?

• Data Protection: Prevents unauthorized access to sensitive information.
• Flexibility: Allows you to change the internal implementation without having to alter the rest of the code.
• Maintainability: It makes code more easily maintainable and debuggable.
• Reusable: Encapsulated classes can be reused throughout different parts of the program or even in other programs.

How Encapsulation Works in Java

Encapsulation is achieved in Java using:

• Private Access Modifier: It restricts the use of the class’s methods and properties.
• Public getter and setter methods: Provide controlled access to the private properties.

Example of Encapsulation:

Output:

Main Features of Encapsulation

1. Private Attributes: Private properties can only be accessed within the class. This does not let the data be accessed by anyone outside the class.

Example:

private String accountHolder;
private double balance;

2. Public Getter Methods: Getter methods provide read-only access to private attributes.

Example:

public String getAccountHolder() {
    return accountHolder;
}

public double getBalance() {
    return balance;
}

3. Public Setter Methods: Setter methods offer to write operations to private properties, sometimes with validation to guarantee the integrity of the information.

Example:

public void setAccountHolder(String accountHolder) {
    this.accountHolder = accountHolder;
}

4. Public Methods for Operations: Public methods announce the class’s actions and provide controlled access to the class’s internal information.

Example:

public void deposit(double amount) {
    if (amount > 0) {
        balance += amount;
    }
}

public void withdraw(double amount) {
    if (amount > 0 && amount <= balance) {
        balance -= amount;
    }
}

Advantages of Encapsulation

• Data Hiding: Hides sensitive information from unwanted access.
• Controlled Access: This enables you to manage the way information is accessed or altered.
• Flexibility: You can change the internal structure of the class without having to alter the rest of the program.
• Reusability: Encapsulated classes can be reused in other programs.

2. Inheritance in Java

One of the four pillars of Object Oriented Programming (OOP) is Inheritance. It allows a class (sub-class or child class) to inherit the properties and the methods (behaviors) of another class (super class or parent class). Inheritance promotes code reusability and develops a hierarchical class structure.

In simple terms, inheritance enables you to declare a new class that is derived from another class, inheriting its methods and properties and also allowing you to add new elements or override the existing ones.

Why is Inheritance Important?

• Code Reusability: You can reuse the code for the class without having to recreate it.
• Hierarchical Classification: Inheritance enables the modeling of real-world relations (for example, a Dog is a type of Animal).
• Extensibility: New methods and properties can be added to a class to make it extensible.
• Maintainability: Changes to the superclass are inherited in all the subclasses with minimal duplication.

How Inheritance Works in Java

Java implements inheritance by using the extends keyword. Non-private methods and properties are inherited by the subclass from the superclass.

Syntax:

class Superclass {
    // Attributes and methods
}

class Subclass extends Superclass {
    // Additional attributes and methods
}

Example of Inheritance:

Output:

Main Concepts in Inheritance

1. Superclass and Subclass

• Superclass (Parent Class): A class whose properties and methods are inherited.
• Subclass (Child Class): A class that inherits the superclass.

Example:

2. Single Inheritance

Java supports only a single inheritance, whereby the derived class can inherit only one superclass.

Example:

class A { }
class B extends A { } // Valid
class C extends A, B { } // Invalid (multiple inheritance not allowed)

3. Multilevel Inheritance

One class can be the superclass for another class, creating an inheritance chain.

Example:

class A { }
class B extends A { }
class C extends B { } // Multilevel inheritance

4. Method Overriding

A subclass can override an individual method that is already available in its superclass. This is method overriding.

Example:

Output:

5. The super Keyword

The super keyword is used to make reference to the superclass. It can be used to

• Call the superclass constructor.
• Accessing superclass properties and methods.

Example:

Output:

Advantages of Inheritance

• Code Reusability: Repurpose code without having to recreate it.
• Extensibility: Add new functionality to the existing classes.
• Polymorphism: Support method overriding for dynamic behavior.
• Hierarchical Organization: Accurately portray real-world relations.

Common Mistakes to Avoid

• Avoid deep inheritance hierarchies since they can make code hard to work with and to maintain.
• Ignoring method overriding: Always use the @Override annotation to avoid errors.
• Violating the principle of Liskov Substitution: Ensure the derived class can replace the base class without losing functionality.

3. Polymorphism in Java

One of the four pillars of OOP is polymorphism. Polymorphism comes from the Greek term meaning “many forms.” Polymorphism in Java allows methods to perform different actions based on the invoking object. It makes it possible to use one interface to represent different underlying forms (data types).

Polymorphism is achieved in Java through:

• Method Overloading (Compile-time polymorphism).
• Method Overriding (Runtime polymorphism).

Why is Polymorphism Important?

• Flexibility: Allows methods to perform in numerous different ways for different objects.
• Code Reusability: Reduces repetition of code by using the same method name for multiple operations.
• Extensibility: Facilitates the extension and amendment of code.
• Simplified Code: Improves readability and maintainability by utilizing a common interface.

Types of Polymorphism

1. Compile-Time Polymorphism (Method Overloading)

Method overloading occurs when two or more methods having the same method name with different parameters (different types or numbers) are present in the same class. A proper method is selected at the compilation level based on the arguments passed.

Example of Method Overloading:

Output:

2. Runtime Polymorphism (Method Overriding)

Method overriding occurs when the subclass provides an implementation for a method that the superclass already contains. During runtime, the method to be executed is resolved by the type of the object.

Example of Method Overriding:

Output:

Main Concepts in Polymorphism

1. Upcasting: Upcasting is when we assign an object of the subclass to the superclass reference. This allows the superclass reference to call the overridden methods in the subclass.

Example:

Animal myAnimal = new Dog(); // Upcasting
myAnimal.sound(); // Calls Dog's sound() method

2. Dynamic Method Dispatch: Dynamic method dispatch is the mechanism by which the method to be called at runtime is determined by the type of the object.

Example:

Animal myAnimal = new Dog();

myAnimal.sound(); // Calls Dog's sound() method

3. The instanceof Operator: The instanceof operator is used to check whether an object is an instance of a specific class or interface.

Example:

if (myAnimal instanceof Dog) {

System.out.println("myAnimal is a Dog.");

}

Advantages of Polymorphism

• Flexibility: Enables techniques to perform in varying manners according to the object.
• Code Reusability: Reduces code repetition by having one method name perform many tasks.
• Extensibility: Allows new functionality to be added with minimal code changes.
• Simplified code: Enhances readability and maintainability.

Mistakes to Be Avoided

• Confusing Overloading and Overriding: Overloading occurs in the same class, while overriding occurs in a subclass.
• Ignoring the @Override Annotation: Always use @Override to avoid errors when overriding methods.
• Overusing Polymorphism: Avoid excessive use of polymorphism, as it can make code harder to understand.

4. Abstraction in Java

Abstraction is the method by which the implementation details are hidden and only the required parts of the object are exposed. That is, abstraction allows you to focus on what an object does, and not on how it does it.

In Java, abstraction is achieved by:

• Abstract Classes: Classes that can’t be instantiated and can have abstract methods (methods with no body).
• Interfaces: A blueprint class that determines the contract for what the class can do but does not specify how.

Why is Abstraction Important?

• Simplifies the complexity: Conceals extraneous details and reveals only the salient characteristics.
• Improves Maintainability: External interfaces are not affected by implementation changes.
• Makes it more reusable: Abstract classes and interfaces can be reused across various parts of the program.
• Ensures Security: Prevents internal implementation details being accessed by unintended individuals.

How Abstraction is Implemented in Java

1. Abstract Classes: As discussed above, an abstract class in Java is a type of class that can never be instantiated, which means that you cannot create its objects. It simply can have multiple abstract methods without a body and concrete methods with a body.

Syntax of an Abstract Class:

abstract class ClassName {
    // Abstract method (no body)
    abstract returnType methodName(parameters);

    // Concrete method (with body)
    returnType methodName(parameters) {
        // Method body
    }
}

Example of an Abstract Class:

Output:

2. Interfaces: An interface in Java is a type of complete abstract class that simply defines what a class can do. Generally, it can only contain abstract methods (before Java 8) and constants. Since Java 8, interfaces can also contain default and static methods.

Syntax of an Interface:

interface InterfaceName {
    // Abstract method (no body)
    returnType methodName(parameters);

    // Default method (with body)
    default returnType methodName(parameters) {
        // Method body
    }

    // Static method (with body)
    static returnType methodName(parameters) {
        // Method body
    }
}

Example of an Interface:

Output:

Key Concepts in Abstraction

1. Abstract Methods: Abstract methods are typically declared without a body and are to be implemented by the subclass.

Example:

abstract void sound();

2. Concrete Methods: Concrete methods are declared with a body and can be directly used by subclasses.

Example:

void sleep() {
    System.out.println("This animal is sleeping.");
}

3. Default Methods in Interfaces: Default methods generally provide a default implementation for methods in an interface. They were introduced to Java 8 to make it possible to add new methods to interfaces without breaking the implementations.

Example:

default void stop() {
    System.out.println("Vehicle stopped.");
}

4. Static Methods in Interfaces: Static methods in interfaces are very similar to static methods in a class and can be called by the use of the interface name.

static void honk() {
    System.out.println("Honk honk!");
}

Important Java-Specific OOP Concepts

These concepts go beyond the fundamental OOP principles and also provide advanced techniques and many tools to handle real-world problems. Let’s explore them in detail.

1. Object Class in Java

The Object class is typically the root of all classes present in Java Code. All the Java classes either directly or indirectly inherit the Object class. Thus, all the objects in Java inherit the methods that are declared by the Object class, which can be overridden to tailor their functionality.

Key Methods Used in the Object Class

1. toString(): This method simply returns the string representation of any object. It returns the class name and the hash code of the object by default. It is also widely overridden to return a more useful representation of the object.
2. equals(): It is generally used for comparing two objects for equality. It defaults to reference equality checking if two objects refer to the same object. It is often overridden to check for the contents of the objects.
3. hashCode(): This method also returns the hash code value for the object. Hash code is typically used in hash-based collections like HashMap and HashSet.
4. getClass(): This method simply returns the class at runtime for the object, which can be used to get information about the class.
5. clone(): It creates and returns the clone of the object. It is used for cloning the objects, but the class must implement the Cloneable interface.
6. finalize(): This method is typically called by the garbage collector before it reclaims an object. It can be overridden to perform the cleanup operations, but its use is not recommended due to the chances of causing performance and reliability issues..

Example:

Output:

2. Design Patterns in Java

Java Design patterns are reusable solutions to common problems in the design of computer programs. They make the code more readable, easier to maintain, and scalable. Some popular Java design patterns include:

a. Singleton Pattern

The Singleton pattern typically ensures that a class can only have one instance and provides global access to it. It is very useful when you need to control the access to some global resource, such as a database connection or settings manager.

Example:

Output:

b. Factory Pattern

The Factory pattern is a creational pattern that typically provides an interface for creating objects in the superclass but allows the subclasses to override the type of objects to be created. It comes into use when you need to decouple the creation of the objects and the utilization of the objects.

Example:

Output:

c. Observer Pattern

The Observer pattern creates a one-to-many dependency between objects so that when the state changes in one object, its dependents are informed. It is used to build event-handling systems.

Example:

Output:

3. Static vs Dynamic Binding in Java

Binding is the process by which the method call is linked with the method definition.

a. Static Binding (Early Binding)

Static binding or early binding occurs at the time of compilation. It is used for static, final, and private methods. In static binding, the method that needs to be called is simply determined at the compilation level based on the type reference.

Example:

Output:

b. Dynamic Binding

Dynamic binding or Late binding occurs at runtime. It is used, for instance, in methods. Dynamic binding resolves the method to be called at runtime based on the actual type of the object.

Example:

Output:

4. Enums in Java

Enums are typically used to define a set of constants. Enums provide type safety and also make the code more readable. Enums can even have fields, methods, and even constructors, which makes them more than simple constants.

Example:

Output:

5. Common Mistakes in OOP Implementation

• Overusing Inheritance: Do not use deep class hierarchies. Instead, use composition
• Ignoring Encapsulation: Never skip the use of the access modifiers.
• Violating SOLID Principles: Avoid violating the principles of SOLID to make your code more structured.

Applications of OOP in Java

Object-oriented programming (OOP) is widely used in Java to build robust, scalable, and maintainable applications. Here are some key areas where OOP principles are applied:

1. Enterprise Applications

Java is a popular choice for building enterprise-level applications like Customer Relationship Management (CRM) systems, Enterprise Resource Planning (ERP) systems, and banking software. OOP principles like encapsulation and inheritance help manage complex business logic and ensure data security.

2. Web Development

Frameworks like Spring and JavaServer Faces (JSF) leverage OOP concepts to create modular and reusable web applications. Encapsulation ensures data integrity, while polymorphism allows for flexible and dynamic behavior.

3. Mobile Development

Java is used in Android app development, where OOP principles help create modular and reusable components. For example, activities and fragments in Android are designed using OOP concepts.

4. Game Development

Java is used to develop games, where OOP helps model real-world entities like characters, weapons, and environments. Inheritance and polymorphism enable dynamic behavior and code reuse.

5. Desktop Applications

Java’s Swing and JavaFX libraries use OOP to create graphical user interfaces (GUIs). Classes like JFrame and JButton encapsulate functionality, making it easier to build interactive applications.

Difference Between OOP and Procedural Programming

Conclusion

With this, we have come to the end of this Java OOP Tutorial in which you have learned about Object Oriented Programming in Java from fundamental concepts like classes, objects, and the four pillars of OOP to advanced concepts like design patterns, method overloading, and enums. Whether you are creating any enterprise applications, web applications, or even mobile games, these OOP concepts of Java are very important for you to write clean, efficient, and reusable code. Apply these principles in your Java projects and take your Java Skills to the next level!