Table of Contents

1. Introduction to Wrapper Classes
2. What are Wrapper Classes?
   • Primitive Data Types vs. Wrapper Classes
3. The Purpose of Wrapper Classes
   • Converting Between Primitive Types and Objects
4. Commonly Used Wrapper Classes
   • Integer, Double, Character, and Boolean
5. Autoboxing in Java
   • Automatic Conversion Between Primitives and Wrapper Objects
6. Unboxing in Java
   • Converting Wrapper Objects to Primitive Types
7. Wrapper Class Methods
   • Useful Methods in Wrapper Classes
8. When to Use Wrapper Classes
   • Practical Use Cases and Examples
9. Summary

1. Introduction to Wrapper Classes

In Java, wrapper classes are used to represent the primitive data types as objects. Since Java is an object-oriented programming language, many libraries and frameworks rely on objects to pass data around. Wrapper classes allow primitives to behave like objects, enabling their use in collections such as lists and maps, which require objects rather than primitives.

Java provides a wrapper class for each of the eight primitive data types. These classes encapsulate the primitive values as objects, providing methods that allow you to perform operations such as parsing, comparing, and converting.

2. What Are Wrapper Classes?

A wrapper class is simply a class that wraps a primitive data type into an object. For example:

• int is wrapped by the Integer class
• double is wrapped by the Double class
• char is wrapped by the Character class
• boolean is wrapped by the Boolean class

In Java, the eight wrapper classes are:

• Byte for byte
• Short for short
• Integer for int
• Long for long
• Float for float
• Double for double
• Character for char
• Boolean for boolean

These classes are part of the java.lang package and are frequently used for their functionality in object manipulation and conversions.

Example:

int num = 5;
Integer wrappedNum = new Integer(num);  // Using the wrapper class Integer

In the above example, the primitive int is wrapped into an Integer object.

3. The Purpose of Wrapper Classes

Wrapper classes serve multiple purposes in Java programming, such as:

1. Storing Primitives in Collections: Collections like ArrayList, HashMap, etc., only accept objects. Thus, primitive types must be wrapped in their corresponding wrapper classes to be stored in these collections.
2. Utility Methods: Wrapper classes provide various utility methods like parseInt, parseDouble, valueOf, etc., to convert strings to primitive values or to perform other operations.
3. Autoboxing and Unboxing: They simplify the process of converting between primitive types and their object counterparts automatically (autoboxing) or manually (unboxing).
4. Support for Null Values: Unlike primitive types, which cannot hold null, wrapper objects can be assigned null, which is useful when working with databases or collections that may contain missing values.

4. Commonly Used Wrapper Classes

Below are the most commonly used wrapper classes in Java and their corresponding primitive types:

• Integer: Wraps the primitive int.
• Double: Wraps the primitive double.
• Character: Wraps the primitive char.
• Boolean: Wraps the primitive boolean.

Example:

int i = 10;
Integer intWrapper = Integer.valueOf(i);  // Converting primitive to wrapper class

double d = 25.5;
Double doubleWrapper = Double.valueOf(d);  // Converting primitive to wrapper class

Here, Integer.valueOf() and Double.valueOf() are used to convert primitive types to their corresponding wrapper objects.

5. Autoboxing in Java

Autoboxing is the automatic conversion of a primitive type to its corresponding wrapper class by the Java compiler. It eliminates the need for explicit boxing, making the code cleaner and more readable.

Example of Autoboxing:

public class Main {
    public static void main(String[] args) {
        int num = 10;
        Integer wrappedNum = num;  // Autoboxing: int to Integer
        System.out.println(wrappedNum);  // Output: 10
    }
}

In the above code, the primitive int (num) is automatically converted into an Integer object without needing to explicitly call new Integer(num) or Integer.valueOf(num).

Autoboxing is particularly useful when adding primitive values into collections such as ArrayList.

Example with Collection:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);  // Autoboxing: primitive int automatically converted to Integer
        list.add(20);
        
        System.out.println(list);  // Output: [10, 20]
    }
}

6. Unboxing in Java

Unboxing is the reverse of autoboxing. It refers to the automatic conversion of a wrapper object back to its corresponding primitive type. Java automatically unboxes wrapper classes to primitive types when needed.

Example of Unboxing:

public class Main {
    public static void main(String[] args) {
        Integer wrappedNum = new Integer(10);
        int num = wrappedNum;  // Unboxing: Integer to int
        System.out.println(num);  // Output: 10
    }
}

In this example, the Integer object wrappedNum is automatically converted to the primitive int (num) without needing explicit code for conversion.

Unboxing simplifies the process of working with wrapper objects and primitive types together.

7. Wrapper Class Methods

Each wrapper class comes with a set of useful methods that allow for conversions, comparisons, and other operations. Some of the commonly used methods in wrapper classes are:

• parseX(String): Converts a string to a corresponding primitive type (parseInt, parseDouble, parseBoolean, etc.). Example: String str = "123"; int num = Integer.parseInt(str); // Converts string to int System.out.println(num); // Output: 123
• valueOf(): Converts a primitive to a wrapper object. Example: int num = 10; Integer wrappedNum = Integer.valueOf(num);
• toString(): Returns the string representation of the primitive value. Example: Integer wrappedNum = new Integer(100); String str = wrappedNum.toString(); // Converts Integer to String System.out.println(str); // Output: "100"
• compareTo(): Compares two wrapper objects (useful for sorting or ordering). Example: Integer a = 10; Integer b = 20; System.out.println(a.compareTo(b)); // Output: -1 (because 10 < 20)

8. When to Use Wrapper Classes

While wrapper classes are incredibly useful, they should be used judiciously. Here are some typical use cases:

1. Working with Collections: Collections like ArrayList, HashMap, and other generic collections require objects, and wrapper classes provide an easy way to store primitive types in these collections. Example: ArrayList<Double> priceList = new ArrayList<>(); priceList.add(12.5); // Autoboxing from primitive double to Double
2. Nullability: If you need to represent the absence of a value (e.g., in databases or configuration data), wrapper objects like Integer, Boolean, or Double can be assigned null (unlike primitives).
3. Working with APIs: Many Java APIs, including JDBC and JavaFX, require wrapper classes for working with primitive values.

9. Summary

In this module, we covered wrapper classes and autoboxing in Java:

• Wrapper Classes provide a way to treat primitive types as objects and are used for tasks like storing primitives in collections and performing object-specific operations.
• Autoboxing automatically converts primitives to their corresponding wrapper objects, making code cleaner and less error-prone.
• Unboxing reverses this process by automatically converting wrapper objects back to primitive values.
• Wrapper classes come with useful methods for conversion, comparison, and string manipulation.

These features are critical for working with collections, APIs, and performing type conversions between primitive types and their object equivalents.

Table of Contents

1. Introduction to Static, Final, and Initialization Blocks
2. The Static Keyword in Java
   • Static Variables
   • Static Methods
   • Static Blocks
3. The Final Keyword in Java
   • Final Variables
   • Final Methods
   • Final Classes
4. Initialization Blocks in Java
   • Instance Initialization Blocks
   • Static Initialization Blocks
5. Best Practices for Using Static, Final, and Initialization Blocks
6. Summary

1. Introduction to Static, Final, and Initialization Blocks

In Java, the static and final keywords, along with initialization blocks, are powerful tools that control the behavior and state of classes, variables, and methods. Each of these concepts serves a specific purpose in structuring your application’s code and optimizing performance.

In this module, we’ll dive into how static can be used to manage class-level data and methods, how final provides immutability and guarantees, and how initialization blocks enable initialization code that can be executed before a class instance is created.

2. The Static Keyword in Java

The static keyword is used in Java to declare class-level variables and methods that belong to the class itself, rather than to instances of the class. This means that static members can be accessed without creating an instance of the class.

a. Static Variables

A static variable is shared by all instances of a class. Instead of each instance having its own copy of the variable, all instances of the class refer to the same variable. Static variables are initialized when the class is loaded into memory.

Example:

class Counter {
    static int count = 0;  // Static variable

    public Counter() {
        count++;  // Increment count whenever an object is created
    }

    public static void displayCount() {
        System.out.println("Count: " + count);  // Static method to display the count
    }
}

public class Main {
    public static void main(String[] args) {
        new Counter();  // Object created
        new Counter();  // Another object created
        Counter.displayCount();  // Output: Count: 2
    }
}

In the example above, the count variable is static. No matter how many instances of Counter are created, the value of count is shared among all of them.

b. Static Methods

A static method can be called without creating an instance of the class. Static methods can only access static variables and other static methods within the class. They cannot directly access instance variables or instance methods.

Example:

class MathUtils {
    static int square(int number) {
        return number * number;  // Static method to calculate square
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(MathUtils.square(5));  // Output: 25
    }
}

The square method is static and can be invoked using the class name, without the need to create an instance of MathUtils.

c. Static Blocks

A static block is used for static initialization of a class. It runs when the class is first loaded into memory, before any instances are created or static methods are called. Static blocks are useful when you need to perform initialization that is complex or requires exception handling.

Example:

class Database {
    static {
        System.out.println("Static block executed!");
        // Perform static initialization (e.g., database connection)
    }
}

public class Main {
    public static void main(String[] args) {
        // The static block will be executed when the class is first loaded
        new Database();
    }
}

In this case, the static block will be executed the first time the Database class is referenced in the program. This allows you to perform one-time initialization tasks.

3. The Final Keyword in Java

The final keyword in Java is used to restrict the modification of variables, methods, and classes. It can be applied in three ways:

a. Final Variables

A final variable is a constant whose value cannot be changed once it has been initialized. If a variable is declared as final, it must be assigned a value at the time of declaration or inside the constructor (for instance variables).

Example:

class Circle {
    final double PI = 3.14159;  // Final variable

    public double area(double radius) {
        return PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle();
        System.out.println(circle.area(5));  // Output: 78.53975
    }
}

In this example, the PI variable is final, meaning its value cannot be changed once assigned. This ensures that the value of PI remains constant throughout the program.

b. Final Methods

A final method cannot be overridden by subclasses. This is useful when you want to ensure that a specific method’s behavior is preserved in all subclasses.

Example:

class Animal {
    final void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    // Attempting to override the sound method will result in a compile-time error
    // void sound() { System.out.println("Dog barks"); }
}

Since sound is marked as final, it cannot be overridden in the Dog subclass.

c. Final Classes

A final class cannot be subclassed. This ensures that the class cannot be extended, preventing any modification of its behavior.

Example:

final class FinalClass {
    void display() {
        System.out.println("Final class cannot be subclassed");
    }
}

// The following would cause a compile-time error:
// class SubClass extends FinalClass {}

Here, the FinalClass cannot be extended by any other class because it is declared as final.

4. Initialization Blocks in Java

Initialization blocks are used to initialize objects or classes before any constructor or method is called. There are two types of initialization blocks in Java: instance initialization blocks and static initialization blocks.

a. Instance Initialization Blocks

An instance initialization block is executed every time an object is created. It is placed outside of constructors and is run before the constructor code.

Example:

class Example {
    {
        System.out.println("Instance initialization block executed!");
    }

    public Example() {
        System.out.println("Constructor executed!");
    }
}

public class Main {
    public static void main(String[] args) {
        new Example();  // Instance initialization block executed!
                        // Constructor executed!
    }
}

In this case, the instance initialization block is executed before the constructor.

b. Static Initialization Blocks

A static initialization block is executed only once, when the class is first loaded into memory. It is typically used for static variables that need to be initialized in a more complex way.

Example:

class Config {
    static String environment;

    static {
        environment = "Production";  // Static initialization block
        System.out.println("Static block executed. Environment set to: " + environment);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Main method executed");
    }
}

Here, the static block runs when the class is loaded, setting the environment variable.

5. Best Practices for Using Static, Final, and Initialization Blocks

• Static Members: Use static members when the data or behavior should be shared among all instances of the class. However, overuse of static variables can lead to poor code design, as it introduces global state that can be modified unexpectedly.
• Final Variables: Use the final keyword to define constants. It is a good practice to make variables that should not be changed constant and to use uppercase naming conventions (e.g., PI).
• Final Methods and Classes: Use final to prevent subclasses from modifying critical methods or extending certain classes, ensuring that important functionality remains unchanged.
• Initialization Blocks: Use instance initialization blocks for common initialization code that must run whenever an object is created. Use static initialization blocks for class-level initialization, especially when handling complex setups like static resources.

6. Summary

In this module, we covered the use of the static and final keywords, along with initialization blocks in Java:

• Static: Helps manage class-level variables and methods that are shared across all instances of a class.
• Final: Provides immutability by restricting changes to variables, methods, and classes.
• Initialization Blocks: Offer flexibility in initializing instances and static resources in a class.

Together, these concepts provide powerful tools for designing maintainable, efficient, and secure Java programs.

Table of Contents

1. Introduction to Encapsulation
2. Benefits of Encapsulation
3. How Encapsulation Works in Java
4. Access Modifiers in Java
   • Public
   • Private
   • Protected
   • Default (Package-Private)
5. Choosing the Right Access Modifier
6. Encapsulation in Action: Code Examples
7. Summary

1. Introduction to Encapsulation

Encapsulation is one of the four fundamental principles of Object-Oriented Programming (OOP) — the others being inheritance, polymorphism, and abstraction. Encapsulation is the concept of wrapping or bundling the data (variables) and the methods (functions) that operate on the data into a single unit known as a class. It also involves restricting access to certain components of an object to ensure that the internal state is protected and only modified in a controlled manner.

By restricting direct access to the object’s data and providing controlled access through getter and setter methods, encapsulation helps protect the integrity of the object. This practice ensures that changes to an object’s state are done in a well-defined, predictable way, and unintended interference is avoided.

2. Benefits of Encapsulation

Encapsulation provides several key benefits that contribute to code maintainability, readability, and security:

a. Control over Data

Encapsulation allows you to control how the data in an object is accessed or modified. You can make certain fields read-only, write-only, or read-write, depending on the needs of your application.

b. Improved Maintainability

Since an object’s internal state is hidden, developers can change the internal implementation of an object without affecting its external interface. This promotes loose coupling and makes the code easier to maintain.

c. Increased Security

By hiding the internal implementation of an object, you can restrict access to sensitive data. This minimizes the risk of external code accidentally or maliciously altering the object’s state in an invalid way.

d. Better Data Integrity

Encapsulation helps maintain the integrity of the object’s state. For example, by using setter methods with validation, you can ensure that the object’s properties are only set to valid values, preventing invalid data from being assigned.

3. How Encapsulation Works in Java

In Java, encapsulation is achieved by making the instance variables of a class private and providing public getter and setter methods to access and update their values.

a. Private Variables

Variables within a class should be made private to ensure they cannot be directly accessed from outside the class. This restricts unauthorized access to the object’s state.

b. Public Getter and Setter Methods

These methods are used to provide controlled access to the private variables. A getter method returns the value of a private variable, while a setter method allows the modification of a private variable in a controlled manner.

Example:

public class Person {
    // Private instance variables
    private String name;
    private int age;

    // Getter method for 'name'
    public String getName() {
        return name;
    }

    // Setter method for 'name'
    public void setName(String name) {
        this.name = name;
    }

    // Getter method for 'age'
    public int getAge() {
        return age;
    }

    // Setter method for 'age'
    public void setAge(int age) {
        if(age > 0) {
            this.age = age;
        } else {
            System.out.println("Age must be positive.");
        }
    }
}

In this example, name and age are private, and we access them via public getter and setter methods. The setter for age includes validation to ensure the value is positive before assigning it.

4. Access Modifiers in Java

Access modifiers in Java determine the visibility and accessibility of classes, methods, and variables. Java provides four types of access modifiers, which are used to define the scope of access for class members.

a. Public Modifier

A public class, method, or variable is accessible from anywhere in the program. There are no restrictions on its access.

Example:

public class Example {
    public int number;

    public void display() {
        System.out.println("Public method");
    }
}

Here, the variable number and the method display are public and can be accessed from any class.

b. Private Modifier

A private variable or method is only accessible within the class in which it is declared. It cannot be accessed from outside the class, ensuring that the class’s internal state is hidden from other classes.

Example:

class Example {
    private int number;

    private void display() {
        System.out.println("Private method");
    }

    public void accessPrivateMethod() {
        display(); // Allowed inside the class
    }
}

In this case, the method display() and the variable number are private and cannot be accessed from outside the Example class.

c. Protected Modifier

A protected variable or method is accessible within the same package and by subclasses, even if they are in different packages.

Example:

class Animal {
    protected String name;

    protected void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    public void display() {
        sound(); // Accessing protected method from superclass
        System.out.println("Dog's name is: " + name);
    }
}

Here, the name variable and the sound() method are protected, and can be accessed within the Dog subclass, which extends the Animal class.

d. Default (Package-Private) Modifier

If no access modifier is specified, the default access level is package-private (or default). This means the class, method, or variable is accessible only within the same package.

Example:

class Example {
    int number;  // default access modifier

    void display() {
        System.out.println("Default method");
    }
}

Here, the variable number and the method display() have default access, meaning they can be accessed only within the same package.

5. Choosing the Right Access Modifier

Choosing the right access modifier is crucial for maintaining the integrity of an object’s state and the overall design of your system. Here are some general guidelines:

• Public: Use public for methods and variables that need to be accessed by any other class, such as utility methods or constants.
• Private: Use private for variables and methods that should not be accessed from outside the class. This is essential for encapsulation and data protection.
• Protected: Use protected when you want subclasses to access certain variables or methods but do not want them to be exposed outside the class hierarchy.
• Default (Package-Private): Use default access when you want members to be accessible only within the same package.

6. Encapsulation in Action: Code Examples

Let’s look at a more comprehensive example demonstrating encapsulation in Java.

class BankAccount {
    private double balance;

    // Getter for balance
    public double getBalance() {
        return balance;
    }

    // Setter for balance
    public void deposit(double amount) {
        if(amount > 0) {
            balance += amount;
        } else {
            System.out.println("Amount should be positive.");
        }
    }

    public void withdraw(double amount) {
        if(amount > 0 && amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("Invalid withdrawal amount.");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(1000);  // Depositing money
        account.withdraw(500);  // Withdrawing money

        System.out.println("Current balance: " + account.getBalance());  // Accessing balance through getter
    }
}

In this example, the balance is private, and its access is restricted to the getter and setter methods. The setter methods ensure that only valid values can be assigned to balance, preserving the integrity of the object’s state.

7. Summary

In this module, we have explored encapsulation and access modifiers in Java. Encapsulation allows for better data protection, easier maintenance, and more flexible code. By using private variables and public getter and setter methods, you can ensure controlled access to an object’s internal state.

We have also looked at the different access modifiers (public, private, protected, and default), each with its own use case for controlling visibility and access. Understanding when and how to use these modifiers is essential for creating robust and secure Java applications.

Table of Contents

1. Introduction to Abstraction
2. Types of Abstraction in Java
   • Abstract Classes
   • Interfaces
3. Abstract Classes: Deep Dive
   • Syntax and Usage
   • Abstract vs Concrete Methods
   • Constructors and Abstract Classes
4. Interfaces: Deep Dive
   • Syntax and Usage
   • Default Methods and Static Methods in Interfaces
   • Functional Interfaces and Lambda Expressions
5. Differences Between Abstract Classes and Interfaces
6. When to Use Abstract Classes vs Interfaces
7. Abstraction in Action: Code Examples
8. Summary

1. Introduction to Abstraction

Abstraction is one of the key principles of Object-Oriented Programming (OOP), along with encapsulation, inheritance, and polymorphism. Abstraction focuses on hiding the implementation details of a system and exposing only the essential features. In Java, abstraction is implemented through abstract classes and interfaces.

Abstraction allows you to define the “what” (the behavior) while leaving the “how” (the implementation) to be handled by subclasses or implementing classes. This reduces complexity and increases the reusability and maintainability of the code.

2. Types of Abstraction in Java

Java provides two ways to achieve abstraction:

1. Abstract Classes
2. Interfaces

Each method has its own set of advantages, and both are used for specific design purposes in Java applications.

3. Abstract Classes: Deep Dive

a. Syntax and Usage

An abstract class is a class that cannot be instantiated on its own. It may contain both abstract methods (methods without a body) and concrete methods (methods with a body). Abstract classes are used when you want to define a common structure for subclasses, while still allowing them to define their specific implementations of certain behaviors.

Syntax of an abstract class:

abstract class Animal {
    abstract void sound(); // Abstract method (no implementation)

    void eat() { // Concrete method
        System.out.println("This animal is eating.");
    }
}

b. Abstract vs Concrete Methods

• Abstract Methods: These methods do not have a body. Subclasses are required to provide a concrete implementation for these methods.
• Concrete Methods: These methods have an implementation. Subclasses can either use the inherited implementation or override it if needed.

Example of subclass implementing an abstract class:

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

In the example above, Dog must implement the abstract method sound() because it extends the abstract class Animal.

c. Constructors and Abstract Classes

An abstract class can have constructors, but you cannot create an instance of an abstract class directly. Constructors in abstract classes are invoked when a subclass is instantiated.

Example:

abstract class Animal {
    Animal() {
        System.out.println("Animal created");
    }
    abstract void sound();
}

class Dog extends Animal {
    Dog() {
        super();  // Calls the constructor of Animal
        System.out.println("Dog created");
    }

    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

When you create an instance of Dog, the constructor of Animal is called first, followed by the constructor of Dog.

4. Interfaces: Deep Dive

a. Syntax and Usage

An interface in Java is a completely abstract class that can have abstract methods (methods without a body) and default or static methods (methods with a body). Unlike an abstract class, an interface cannot have instance fields (variables) but can define constants. Classes implement interfaces using the implements keyword.

Syntax of an interface:

interface Animal {
    void sound(); // Abstract method
    
    default void sleep() { // Default method
        System.out.println("Animal is sleeping");
    }
}

A class implements an interface by providing concrete implementations of the methods declared in the interface:

class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

b. Default Methods and Static Methods in Interfaces

• Default Methods: Introduced in Java 8, default methods allow you to provide a body for methods in interfaces. This enables backward compatibility when adding new methods to an interface without breaking the implementing classes.

Example of a default method:

interface Animal {
    void sound();

    default void eat() {
        System.out.println("This animal is eating");
    }
}

• Static Methods: Interfaces can also contain static methods, which can be called without needing an instance of the implementing class. Static methods in interfaces behave similarly to static methods in regular classes.

Example of a static method:

interface Animal {
    static void describe() {
        System.out.println("Animals are living organisms");
    }
}

You can call static methods using the interface name:

Animal.describe();

c. Functional Interfaces and Lambda Expressions

A functional interface is an interface with exactly one abstract method. It may have multiple default or static methods. These interfaces can be used with lambda expressions to provide a clear and concise way to implement the interface.

Example of a functional interface:

@FunctionalInterface
interface Calculator {
    int add(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = (a, b) -> a + b; // Lambda expression
        System.out.println(calc.add(5, 10));  // Output: 15
    }
}

Here, Calculator is a functional interface, and its abstract method add is implemented using a lambda expression.

5. Differences Between Abstract Classes and Interfaces

Both abstract classes and interfaces allow you to achieve abstraction, but there are significant differences between the two:

6. When to Use Abstract Classes vs Interfaces

• Use an abstract class when you want to provide a common base with shared functionality or state (fields) among related classes, and you want to control the inheritance hierarchy.
• Use an interface when you want to represent a common behavior that can be adopted by classes from different class hierarchies. Interfaces are ideal for defining “capabilities” that can be implemented by any class, regardless of its position in the class hierarchy.

7. Abstraction in Action: Code Examples

Example 1: Using Abstract Classes

abstract class Vehicle {
    abstract void drive();

    void fuel() {
        System.out.println("Filling fuel");
    }
}

class Car extends Vehicle {
    @Override
    void drive() {
        System.out.println("Driving a car");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle car = new Car();
        car.drive();  // Calls Car's drive method
        car.fuel();   // Calls Vehicle's fuel method
    }
}

Example 2: Using Interfaces

interface Shape {
    void draw();

    default void color() {
        System.out.println("Coloring the shape");
    }
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle();
        circle.draw();  // Calls Circle's draw method
        circle.color(); // Calls Shape's default color method
    }
}

In both examples, abstraction is used to define a general blueprint (abstract class or interface) for specific behaviors (like drawing a circle or driving a car).

8. Summary

In this module, we’ve explored abstraction in Java, focusing on abstract classes and interfaces. Both of these concepts allow you to define common behaviors while hiding implementation details, making your code more modular, flexible, and maintainable.

We’ve also discussed key differences between abstract classes and interfaces, as well as when to use each of them. The practical examples provided demonstrate how abstraction allows for more general, reusable, and flexible code in real-world scenarios.

Table of Contents

1. Introduction to Polymorphism
2. Types of Polymorphism
   • Compile-time Polymorphism (Method Overloading)
   • Runtime Polymorphism (Method Overriding)
3. Method Overriding
4. Dynamic Binding
5. Benefits of Polymorphism
6. Polymorphism in Action: Examples
7. Common Pitfalls and Best Practices
8. Summary

1. Introduction to Polymorphism

Polymorphism is another core principle of object-oriented programming (OOP), along with encapsulation, inheritance, and abstraction. Derived from the Greek words “poly” (many) and “morph” (forms), polymorphism allows one object to take many forms.

In the context of Java, polymorphism allows an object to behave in multiple ways based on the method call, either by overloading methods at compile-time or overriding them at runtime. In this module, we will focus on runtime polymorphism, achieved through method overriding and dynamic binding.

2. Types of Polymorphism

a. Compile-time Polymorphism (Method Overloading)

Compile-time polymorphism refers to method overloading, where multiple methods in a class can have the same name but different parameters (either in number or type). The decision of which method to invoke is made at compile time.

Example of method overloading:

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
}

Here, the method add is overloaded with two versions: one for integers and one for doubles. The compiler decides which method to call based on the arguments passed.

b. Runtime Polymorphism (Method Overriding)

Runtime polymorphism, also known as dynamic polymorphism, happens when a subclass provides a specific implementation of a method that is already defined in its superclass. The specific method to call is determined at runtime.

3. Method Overriding

Method overriding occurs when a subclass provides its own implementation of a method that is already defined in its parent class, but with the same method signature (name, return type, and parameters).

The method in the parent class is called a base method, and the method in the subclass is called an overridden method. The overriding method provides its own definition, which replaces the inherited version when the method is called on the object of the subclass.

Example:

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog(); // Upcasting
        animal.sound();  // Calls Dog's overridden sound method
    }
}

In this example:

• Dog overrides the sound method of Animal.
• The sound method called on an Animal reference (which points to a Dog object) invokes the Dog’s overridden method, not the parent class version.

4. Dynamic Binding

Dynamic binding (or late binding) refers to the runtime decision-making process of selecting the method to be invoked. When a method is called on an object, the JVM determines which method to invoke based on the actual object type (not the reference type) at runtime.

In the example above, the reference type is Animal, but the object type is Dog. Since Dog overrides the sound method, the JVM dynamically binds the method call to Dog‘s version of sound at runtime.

This mechanism is what allows polymorphic behavior in Java. The method invocation happens based on the actual object that the reference points to, even if the reference is of a superclass type.

Dynamic Binding Example:

class Shape {
    void draw() {
        System.out.println("Drawing a generic shape");
    }
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }
}

class Square extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a square");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Circle();  // Upcasting
        Shape shape2 = new Square();  // Upcasting
        
        shape1.draw();  // Circle's draw method
        shape2.draw();  // Square's draw method
    }
}

In the code above:

• shape1 is a reference of type Shape but holds a Circle object.
• shape2 is a reference of type Shape but holds a Square object.
• The draw method is invoked polymorphically, and the actual method executed is based on the object type (Circle or Square), not the reference type (Shape).

This dynamic method invocation is a core feature of polymorphism in Java.

5. Benefits of Polymorphism

Polymorphism provides several benefits, particularly in the context of object-oriented design and development:

1. Flexibility: It allows one interface to be used for different underlying forms of data. This is particularly useful when you need to write code that can work with objects of different classes.
2. Code Reusability: You can write more generic code, as a superclass reference can point to objects of any subclass, thus minimizing redundancy.
3. Ease of Maintenance: Modifying the behavior of a subclass method does not affect the rest of the program as long as the method signature remains the same.
4. Decoupling: Polymorphism decouples the class behavior, making the codebase easier to understand and modify.

6. Polymorphism in Action: Examples

Example 1: Employee Class Hierarchy

Let’s consider a real-world example of an employee hierarchy:

abstract class Employee {
    abstract void work();
}

class Developer extends Employee {
    @Override
    void work() {
        System.out.println("Writing code");
    }
}

class Manager extends Employee {
    @Override
    void work() {
        System.out.println("Managing the team");
    }
}

public class Main {
    public static void main(String[] args) {
        Employee emp1 = new Developer();  // Developer object
        Employee emp2 = new Manager();    // Manager object

        emp1.work();  // Calls Developer's work method
        emp2.work();  // Calls Manager's work method
    }
}

In this example:

• Employee is an abstract class with an abstract method work().
• Developer and Manager are subclasses that override work().
• At runtime, based on the actual object (Developer or Manager), the appropriate work() method is called.

Example 2: Payment System

Consider a payment system where different types of payment methods (credit card, PayPal, etc.) are used:

class Payment {
    void pay() {
        System.out.println("Making a payment");
    }
}

class CreditCardPayment extends Payment {
    @Override
    void pay() {
        System.out.println("Paying with Credit Card");
    }
}

class PayPalPayment extends Payment {
    @Override
    void pay() {
        System.out.println("Paying with PayPal");
    }
}

public class Main {
    public static void main(String[] args) {
        Payment payment1 = new CreditCardPayment();  // CreditCardPayment object
        Payment payment2 = new PayPalPayment();     // PayPalPayment object

        payment1.pay();  // Calls CreditCardPayment's pay method
        payment2.pay();  // Calls PayPalPayment's pay method
    }
}

This example shows how polymorphism allows different types of payments to be processed through a common interface, which enhances flexibility and scalability.

7. Common Pitfalls and Best Practices

Pitfalls

• Incorrect Method Signature: The overridden method in the subclass must have the same method signature (name, return type, and parameters) as the method in the superclass.
• Overriding Non-Overridable Methods: You cannot override final, static, or private methods, as they are not subject to polymorphism.
• Casting Issues: Misusing references (incorrect casting) can lead to ClassCastException.

Best Practices

• Always use the @Override annotation when overriding a method. This improves readability and helps catch errors at compile time.
• Avoid deep inheritance hierarchies; prefer interface-based polymorphism when possible.
• Be cautious when using polymorphism in performance-critical sections of code, as dynamic binding can introduce overhead.

8. Summary

In this module, you have learned about polymorphism, particularly method overriding and dynamic binding, which are key features of runtime polymorphism. These mechanisms allow Java to execute the appropriate method based on the actual object type at runtime, providing flexibility, scalability, and ease of maintenance in object-oriented design.

By leveraging polymorphism, you can write more generic, reusable, and maintainable code, enhancing both design and performance in larger applications.