5. Methods and Parameter Passing in Java

A method is a block of code that performs a specific task. It helps you organize code, avoid repetition, and reuse logic.

✅ Why use methods? ● To divide a program into smaller parts ● To make the code readable, reusable, and maintainable ● To follow the principle of modularity

A method is essentially a mini-program within a larger program. It allows programmers to encapsulate code that performs specific functions, which leads to better organization of the code. By breaking a program into methods, each can be understood and tested individually. This improves code readability and makes it easier to maintain or update. The principle of modularity means each part can be developed and tested independently before being integrated into the larger system.

Think of a method like a recipe. Each recipe provides specific instructions (the method) to create a dish (the task). Just like following a recipe helps you manage your cooking without mixing everything together, methods help manage programming tasks.

📌 Syntax: returnType methodName(parameterList) { // method body // return statement (if needed) }

✅ Example: int add(int a, int b) { int sum = a + b; return sum; }

Declaring a method involves defining the return type, method name, and any parameters it requires. The return type indicates what kind of value the method will return after execution. The method name is how you will refer to it when you call it. Parameters are input values provided to the method. In the example 'int add(int a, int b)', the method 'add' takes two integers, adds them, and then returns the result.

Consider a vending machine as a method declaration. You press a button (method name) to get a specific drink (return type) by inserting coins (parameters). The machine takes your input, processes it, and gives you back your drink (the result).

To use a method, you must call it from main() or another method.

public class Main { int multiply(int x, int y) { return x * y; } public static void main(String[] args) { Main obj = new Main(); // Create object int result = obj.multiply(4, 5); System.out.println("Result: " + result); } }

🧾 Output: Result: 20

To execute a method, you 'call' it from within the program, specifically from a main method or another method. This involves creating an object of the class containing the method if it is not static. In the 'Main' class, we create an object 'obj', then call 'multiply(4, 5)' to get the product, which is printed out as the result.

Imagine dialing a phone number to get through to someone. The phone number is like the method name, and once you dial it (call the method), you can talk to the person (perform the task). After your conversation (execution), you get results like new information or a connection.

1⃣ Predefined Methods – Already provided by Java (like System.out.println()). 2⃣ User-defined Methods – Created by the programmer.

In Java programming, there are two main types of methods: predefined methods, which are already included in the Java language (like printing to the console), and user-defined methods, which programmers create based on specific requirements. Predefined methods save time and effort as programmers can utilize them directly.

Think of predefined methods like appliances in your kitchen, such as a blender or a microwave; they come with specific functions built-in. User-defined methods are like recipes you create yourself; they tailor to your personal preferences and needs.

📘 Parameter: Variable listed inside method declaration 📘 Argument: Actual value passed when calling method void greet(String name) { // parameter System.out.println("Hello, " + name); } greet("Ankit"); // argument

Parameters are variables that allow data to be passed into methods, while arguments are the actual values provided to those parameters when the method is called. For example, in 'greet(String name)', 'name' is the parameter. When we call 'greet("Ankit")', 'Ankit' is the argument. This allows methods to be flexible and reusable with different data inputs.

Think of a method as a mail envelope. The parameter is like the address written on the envelope; it tells the postal service where to send the message. The argument is the actual recipient's name that you put into the envelope.

Method Overloading = Multiple methods with same name but different parameters in same class.

✅ Example: class Calculator { int add(int a, int b) { return a + b; } double add(double a, double b) { return a + b; } int add(int a, int b, int c) { return a + b + c; } }

🔍 Why use method overloading? ● Improves code readability ● Allows similar actions to be grouped

Method overloading is a feature in Java that allows you to define multiple methods with the same name, but with different parameter lists. This can include variations in the number or type of parameters. The advantage of this feature is that it provides clarity and facilitates the logical grouping of similar functionalities, making the code easier to read.

Consider a Swiss army knife with multiple tools. Each tool is like a method; despite having the same shape (name), each tool serves a different purpose—like cutting, opening bottles, or screwing. This versatility is similar to method overloading.

A method can return: ● A value (like int, String, etc.) ● Nothing (void)

✅ Example 1: Return int int square(int x) { return x * x; }

✅ Example 2: Return nothing void sayHi() { System.out.println("Hi there!"); }

Methods can either return a value or not return anything at all. If a method returns a value, it must declare a return type such as int or String. If it does not, it uses the keyword 'void'. For instance, the method 'square' returns an integer, while 'sayHi' performs its action without returning anything.

Think of a restaurant: when you order food (invoke a method), the waiter brings your meal (the return value). In contrast, if you simply ask how the day is (a method that doesn't return a value), you receive an answer but nothing tangible to take home.

In Java, all arguments are passed by value. That means: a copy of the variable is passed, not the actual variable.

✅ Example: class Demo { void changeValue(int x) { x = x + 10; } public static void main(String[] args) { int num = 5; Demo d = new Demo(); d.changeValue(num); System.out.println("num = " + num); } }

🧾 Output: num = 5 ● x is a copy → num remains unchanged.

In Java, when you pass an argument to a method, a copy of that argument is made rather than passing the original. This is called 'call by value'. Therefore, any changes made to the parameter within the method do not affect the original variable. In the example provided, 'num' remains 5 even after attempting to change it in the method 'changeValue'.

Imagine lending a friend a piece of your artwork; it’s like giving them a copy. You both can modify the copy, but the original artwork stays unchanged. Similarly, the method can alter the parameter, but the original argument remains intact.

✅ Example: class Student { String name; void displayName() { System.out.println("Name: " + name); } }

public class Main { public static void main(String[] args) { Student s = new Student(); s.name = "Priya"; s.displayName(); } }

🧾 Output: Name: Priya ● Method displayName() works on object s.

This example showcases how methods can operate on class instances or objects. The 'Student' class has a method 'displayName' that prints the name of the student instance. When 's.displayName()' is called, it accesses the 'name' property of the object 's', illustrating how methods can manage object data and behaviors.

Think of a class as a blueprint for building a house. Each house (object) built from that blueprint can have specific features like a name or color. When someone enters your house (calls a method), they can see the unique features (properties) that belong to that specific house.

📌 Static methods can be called without creating an object. class MathUtils { static int square(int x) { return x * x; } }

public class Main { public static void main(String[] args) { System.out.println(MathUtils.square(6)); } }

🧾 Output: 36

Static methods belong to the class rather than any instance of the class. This means they can be called directly using the class name without creating an object first. In the example, 'square' is defined as a static method in the 'MathUtils' class, allowing it to be executed directly without instantiating the class.

Consider a university offering courses (static methods). Students don’t need to enroll (create an object) every time they want to access course materials; they can simply browse the university website directly. Static methods function similarly, accessible without instantiation.

Concept Example Method A machine in a factory Parameter Raw material for machine Return Output from the machine value Overloading Same machine with different tools

This analogy provides a tangible way to understand the concepts of methods and their functionalities in Java. In a factory, a machine operates (method), it requires raw materials (parameters) to function, and its output (return value) can vary. The factory setup represents how programming concepts translate to real-world scenarios.

In a kitchen, the chef (method) uses various ingredients (parameters) to create dishes (return values), with some dishes requiring special tools (overloading). The chef can prepare multiple restaurant specials using the same set of tools.

--