Method Overloading and Method Overriding

Method Overloading

Method Overloading is an Object-Oriented Programming (OOP) feature that allows a class to have multiple methods with the same name but different parameter lists. The methods must differ in the number, type, or order of parameters. This enables the same method name to perform different tasks based on the arguments passed to it. Method Overloading is an example of Compile-time Polymorphism (Static Polymorphism).

Characteristics of Method Overloading

• Methods have the same name.
• Methods must have different parameter lists (number, type, or order of parameters).
• Return type alone cannot distinguish overloaded methods.
• It occurs within the same class.
• It is resolved during compile time.

Example

Suppose a class has a method named add().
add(int a, int b) → Adds two integers.
add(int a, int b, int c) → Adds three integers.
add(double a, double b) → Adds two decimal numbers.

Although all methods have the same name add(), they perform different operations depending on the parameters supplied.

Method Overriding

Method Overriding is an Object-Oriented Programming (OOP) feature in which a subclass provides its own implementation of a method that is already defined in its superclass. The overriding method must have the same name, same parameter list, and compatible return type as the parent method. Method Overriding is an example of Run-time Polymorphism (Dynamic Polymorphism).

Characteristics of Method Overriding

• Occurs between a superclass and a subclass.
• The method name, parameters, and return type remain the same.
• The child class provides a new implementation of the inherited method.
• It is resolved during runtime using dynamic method dispatch.

Example

Suppose a parent class Animal contains a method named sound() that prints "Animal makes a sound".
A child class Dog overrides the sound() method to print "Dog barks".
When the sound() method is called using a Dog object, the overridden method in the Dog class is executed.

Difference Between Method Overloading and Method Overriding

Object-Oriented Programming (OOP) is a programming style where the code is built around objects. An object is a self-contained unit that holds both data (called attributes or properties) and the actions that can be performed on that data (called methods or functions). OOP helps organize large programs by breaking them into smaller, reusable, and manageable pieces.

Main Principles of OOP

1. Encapsulation
Encapsulation means hiding the internal details of an object and only showing the necessary parts to the outside world. It protects data from being changed directly and keeps the code safe.

Example: A bank account class hides the balance variable and only allows deposit or withdraw methods to change it.

2. Abstraction
Abstraction means showing only the essential features of an object while hiding the complex background details. It helps reduce complexity and makes the program easier to use.

Example: When you drive a car, you only use the steering and brakes. You do not need to know how the engine works inside.

3. Inheritance
Inheritance is a mechanism where a new class can take on the properties and methods of an existing class. It promotes code reuse and builds a relationship between parent and child classes.

Example: A Dog class inherits from an Animal class. Dog gets all properties like name and age, plus its own method like bark().

4. Polymorphism
Polymorphism means the same method name can behave differently in different situations. It allows one interface to be used for different data types or classes.

Example: A Shape class has a draw() method. Circle, Square, and Triangle classes override draw() to show different shapes.

Difference Between Method Overloading and Method Overriding

Code Example of Method Overloading:

Code Example of Method Overriding:

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

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

Inheritance:
Inheritance is an important concept of Object-Oriented Programming (OOP) where one class (child class) can acquire the properties and methods of another class (parent class). It helps in code reuse and creates a relationship between classes.

Example (C++):

#include <iostream>
using namespace std;

class Animal {
public:
    void eat() {
        cout << "Animal is eating" << endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        cout << "Dog is barking" << endl;
    }
};

int main() {
    Dog d;
    d.eat();   // inherited function
    d.bark();  // own function
}

In this example, the Dog class inherits the eat() function from the Animal class.

Polymorphism:
Polymorphism means “many forms”. It allows the same function name to perform different tasks depending on the situation. It improves flexibility and reusability in programs.

Example (Function Overloading in C++):

#include <iostream>
using namespace std;

class Math {
public:
    int add(int a, int b) {
        return a + b;
    }

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

int main() {
    Math m;
    cout << m.add(5, 3) << endl;
    cout << m.add(4.5, 2.3) << endl;
}

Here the function add() works in different ways depending on the data type of the arguments. This is an example of polymorphism.

Inheritance in Object-Oriented Programming (OOP)

Inheritance is an OOP concept where a child (derived) class inherits properties and behaviors from a parent (base) class. It helps reuse existing code and represents real-world hierarchical relationships (like Animal → Dog).

Types of Inheritance

1) Single Inheritance

One child class inherits from one parent class.

Animal
  |
 Dog

Here, Dog inherits features (like eating, breathing) from Animal.

2) Multiple Inheritance

One child class inherits from more than one parent class.

Printer     Scanner
     \     /
      \   /
     AllInOne

Here, AllInOne inherits features of both Printer and Scanner.

3) Multilevel Inheritance

A class is derived from another derived class, forming a chain.

Vehicle
   |
  Car
   |
ElectricCar

Here, ElectricCar indirectly inherits features from Vehicle through Car.

Advantages of Object-Oriented Programming (OOP) over Structured Programming

Object-Oriented Programming (OOP) provides several advantages over traditional structured programming languages, especially for developing large and complex software systems.

• Modularity: OOP organizes programs into objects, making code easier to manage and understand.
• Reusability: Classes and objects can be reused through inheritance, reducing code duplication.
• Encapsulation: Data and methods are bundled together, improving data security and control.
• Abstraction: OOP hides complex implementation details and shows only essential features.
• Maintainability: Programs are easier to update, debug, and modify.
• Scalability: OOP supports the development of large-scale applications efficiently.
• Real-World Modeling: OOP closely represents real-world entities using objects.

Programming

Programming is the process of writing instructions (code) that a computer follows to perform specific tasks.

Examples of Programming Languages

• C
• Java
• Python
• C++

Difference Between Structured Programming and OOP

Polymorphism means “having many forms.” It allows the same method or function to perform different tasks based on the context. In simpler terms, it enables a single interface to represent different functionalities.

Polymorphism can be broadly categorized into two types:

1. Compile-time Polymorphism (Static Polymorphism)
2. Runtime Polymorphism (Dynamic Polymorphism)

1. Compile-time Polymorphism (Static Polymorphism)

Compile-time polymorphism is achieved through method overloading and operator overloading. The method to be executed is determined at compile time based on the method signature.

2. Runtime Polymorphism (Dynamic Polymorphism)

Runtime polymorphism is achieved through method overriding. The method to be executed is determined at runtime based on the object being referred to.

🎥 Video Solution: Polymorphism & its types.

Errors in programming can occur at two main stages: when the code is being translated into machine language (compile-time) and when the program is actually running (runtime). Understanding the difference helps in faster debugging and writing more reliable code.

1. Compile-Time Error

A compile-time error is detected by the compiler before the program is executed. It means the code violates the rules of the programming language and cannot be translated into an executable program.

• When detected: During compilation, before the program runs
• Cause: Syntax mistakes, type mismatches, missing declarations, or incorrect language structure
• Fix: The programmer must correct the code and recompile
• Program state: No executable file is generated

Examples:

• Missing semicolon at the end of a statement
• Using a variable that is not declared
• Calling a method with incorrect arguments
• Type mismatch (e.g., assigning a string to an integer variable)

Code Example:

int x = "hello"; // Type mismatch
System.out.println(y); // y is not declared

2. Runtime Error

A runtime error occurs while the program is executing. The code compiles successfully, but execution fails due to unexpected conditions or invalid operations.

• When detected: During program execution
• Cause: Invalid operations, unexpected input, missing resources, or logic errors
• Fix: Add error handling, validate input, or correct logic
• Program state: Program may crash or behave unexpectedly during execution

Examples:

• Division by zero
• Accessing an invalid array index
• Opening a file that does not exist
• Running out of memory

Code Example:

int[] arr = {1, 2, 3};
System.out.println(arr[5]); // ArrayIndexOutOfBoundsException

int result = 10 / 0; // ArithmeticException

Comparison Table:

Advantages of Encapsulation:

Data Security: It hides internal details, preventing unauthorized access and misuse.
Easy Maintenance: Since data access is controlled, changes in the code don’t affect other parts.
Better Flexibility: Internal workings of a class can be modified without affecting how others interact with it.
Less Complexity: Users only need to know how to use the class, not its internal details.
Improved Debugging: Restricting access to data makes it easier to find and fix bugs.

Advantages of Inheritance:

Code Reusability: A new class can use the properties and methods of an existing class, reducing duplicate code.
Clear Structure: It helps in organizing code by creating a hierarchy of classes.
Easy Expansion: New functionality can be added to a class without modifying existing code.
Simplifies Management: Subclasses inherit properties from the parent class, making code more organized and efficient.

🎥 Video Solution: How encapsulation and inheritance are advantageous in OOP

Method Overloading, Method Overriding, and Method Hiding

1. Method Overloading

Method overloading occurs when multiple methods in the same class have the same method name but different parameter lists (different number, type, or order of parameters).

• Resolved at compile time
• Improves code readability and flexibility

Example:

int add(int a, int b)
int add(int a, int b, int c)

2. Method Overriding

Method overriding happens when a subclass provides a new implementation of a method that is already defined in its superclass with the same method signature.

• Occurs in inheritance
• Resolved at runtime (runtime polymorphism)
• Method must be non-static

Example:

class Parent {
  void show() { }
}
class Child extends Parent {
  void show() { }
}

3. Method Hiding (Hiding Superclass Method)

Method hiding occurs when a static method in a subclass has the same name and signature as a static method in the superclass.

• Applies only to static methods
• Resolved at compile time
• Not true overriding

Example:

class Parent {
  static void display() { }
}
class Child extends Parent {
  static void display() { }
}

Summary Comparison

• Overloading: Same class, same method name, different parameters
• Overriding: Subclass redefines superclass method (non-static)
• Hiding: Static method in subclass hides static method of superclass

Dynamic Memory Allocation in C

Dynamic memory allocation in C refers to allocating memory at runtime using standard library functions. Unlike static memory, dynamic memory can be allocated and freed as needed during program execution.

Functions used:

• malloc(): Allocates a block of memory.
• calloc(): Allocates memory and initializes it to zero.
• realloc(): Changes the size of previously allocated memory.
• free(): Releases allocated memory.

Example:

int *ptr;
ptr = (int*)malloc(5 * sizeof(int));

Here, memory for 5 integers is allocated dynamically.