Methods in JAVA – JAVA - Zero to Hero

📟 What is a Method?

A method is a block of code that performs a specific task.
It runs only when called.

❔Why Use Methods?

To reuse code
To make the program modular and readable
To separate logic into manageable blocks

🧠 Defining and Calling Methods

🔸 Syntax:

returnType methodName(parameters) {
    // code
}

🔸 Example:

public class Main {
    static void greet() {
        System.out.println("Hello!");
    }

    public static void main(String[] args) {
        greet(); // calling the method
    }
}

Hello!

⚙️ Method With Parameters & Return Type

public class Main {
    static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int result = add(5, 3);
        System.out.println("Sum: " + result);
    }
}

Sum: 8

🛠️ Method Overloading

Same method name, different parameters.
The compiler decides which one to call based on the arguments.

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

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

public class Main {
    public static void main(String[] args) {
        Calculator c = new Calculator();
        System.out.println(c.add(2, 3));       // 2 parameters
        System.out.println(c.add(1, 4, 5));    // 3 parameters
    }
}

5
10

🔍 Why use it?

To increase flexibility by allowing methods to handle different numbers of inputs.

🔧 Method Overriding

Method Overriding is when a child class uses the same method name, return type, and parameters as in the parent class, but provides its own code (implementation) for that method.

🧠 Why Override?

To change or extend the behavior of an inherited method from the parent class.

⚙️ Rules of Method Overriding:

Rule	Description
✅ Same method name	The method in the child class must have the same name as in the parent class.
✅ Same parameters	It must have the same parameter list (number and types).
✅ Inheritance	There must be a parent-child relationship (using `extends`).
✅ Access modifier	Cannot reduce the access level (e.g., `public` cannot be changed to `private`).
✅ Return type	Must be the same or a subtype (called covariant return type).
❌ Cannot override	`final`, `static`, or `private` methods cannot be overridden.
✅ Use of @Override	Recommended to use `@Override` annotation for clarity and error checking.

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 a = new Dog(); // Parent reference, child object
        a.sound();
    }
}

Dog barks

🔍 Why use it?

To achieve runtime polymorphism (dynamic method binding).

💡 What Happened Here?

Animal has a method called sound().
Dog overrides that method with its own version.
Even though the object is of type Animal, the Dog's method is executed — this is runtime polymorphism.

🛠️ Why Use Method Overriding?

To customize or change the behavior of an inherited method.
To implement polymorphism (especially useful in object-oriented design).
To create more specific behavior in child classes.