1. Parameters and Arguments in Java
Parameters and arguments are used to pass data into methods.
They allow methods to work with dynamic values instead of fixed data.
This makes methods flexible and reusable.
2. Why Parameters and Arguments are Used
Without parameters, methods would always work with hardcoded values.
- a. Pass dynamic input values
- b. Reuse methods with different data
- c. Reduce duplicate methods
- d. Improve flexibility
- e. Simplify program design
- f. Make applications interactive
3. Where Parameters and Arguments are Used
Parameters and arguments are used in almost every Java program.
- a. Calculator applications
- b. Banking systems
- c. Login systems
- d. Web applications
- e. Data processing systems
- f. Mobile applications
4. Understanding Parameters and Arguments
Parameters and arguments are related but different concepts.
| Concept | Description |
| Parameter | Variable declared in method definition |
| Argument | Actual value passed during method call |
4.1 Basic Example
public class Main {
static void greet(String name) {
System.out.println("Welcome " + name);
}
public static void main(String[] args) {
greet("Rahul");
}
}
name is the parameter and Rahul is the argument.
Parameters receive values from arguments during method calls.
5. Single Parameter Methods
A method can accept one parameter.
5.1 Integer Parameter Example
public class Main {
static void square(int number) {
System.out.println(number * number);
}
public static void main(String[] args) {
square(5);
}
}
The method receives the value 5 and prints its square.
5.2 String Parameter Example
public class Main {
static void printCity(String city) {
System.out.println(city);
}
public static void main(String[] args) {
printCity("Delhi");
}
}
The argument Delhi is stored inside the city parameter.
6. Multiple Parameters
Methods can receive multiple input values.
6.1 Two Parameter Example
public class Main {
static void add(int a, int b) {
System.out.println(a + b);
}
public static void main(String[] args) {
add(10, 20);
}
}
The method receives two integer values and prints their sum.
6.2 Different Data Types
public class Main {
static void studentInfo(String name, int age) {
System.out.println(name + " " + age);
}
public static void main(String[] args) {
studentInfo("Amit", 21);
}
}
Methods can accept parameters of different data types.
Arguments must match the parameter order and data types.
7. Parameters with Return Values
Methods can use parameters and also return results.
7.1 Returning Calculation Result
public class Main {
static int multiply(int a, int b) {
return a * b;
}
public static void main(String[] args) {
int result = multiply(4, 5);
System.out.println(result);
}
}
The method receives two parameters and returns the multiplication result.
8. Default Behavior of Parameters
Parameters behave like local variables inside methods.
8.1 Local Scope Example
public class Main {
static void show(int number) {
System.out.println(number);
}
public static void main(String[] args) {
show(100);
}
}
The parameter exists only during method execution.
9. Internal Working of Parameters and Arguments
When a method is called, Java copies argument values into parameters.
9.1 Memory Flow
- a. Method call occurs
- b. Stack memory is created
- c. Arguments are copied into parameters
- d. Method logic executes
- e. Stack memory is removed after completion
9.2 Example of Argument Passing
public class Main {
static void display(int value) {
System.out.println(value);
}
public static void main(String[] args) {
int number = 50;
display(number);
}
}
The value of number is copied into the value parameter during method execution.
10. Primitive Type Arguments
Primitive variables store actual values directly.
When primitive arguments are passed to methods, Java copies their values.
10.1 Example of Primitive Argument Passing
public class Main {
static void changeValue(int number) {
number = 100;
System.out.println(number);
}
public static void main(String[] args) {
int value = 50;
changeValue(value);
System.out.println(value);
}
}
The original variable remains unchanged because only the copied value is modified.
Primitive arguments are passed by value in Java.
11. Reference Type Arguments
Objects and arrays are reference types.
When reference variables are passed, Java copies the reference value.
11.1 Example Using Array
public class Main {
static void modifyArray(int[] numbers) {
numbers[0] = 999;
}
public static void main(String[] args) {
int[] values = {10, 20, 30};
modifyArray(values);
System.out.println(values[0]);
}
}
The array data changes because both references point to the same object.
11.2 Example Using Object
class Student {
int marks;
}
public class Main {
static void update(Student s) {
s.marks = 95;
}
public static void main(String[] args) {
Student obj = new Student();
update(obj);
System.out.println(obj.marks);
}
}
The object data changes because the copied reference still points to the same object.
Java always uses pass by value, even for objects.
12. Understanding Pass by Value in Java
Java does not support true pass by reference.
Instead, Java copies values during method calls.
12.1 Primitive Copy Behavior
| Original Variable | Copied into Parameter |
| 50 | 50 |
Changing the parameter does not affect the original primitive variable.
12.2 Reference Copy Behavior
| Original Reference | Copied Reference |
| Object Address | Same Object Address |
Both references point to the same object in memory.
13. Changing Object References Inside Methods
Changing the copied reference itself does not affect the original reference.
13.1 Example of Reference Reassignment
class Student {
int marks = 50;
}
public class Main {
static void change(Student s) {
s = new Student();
s.marks = 100;
}
public static void main(String[] args) {
Student obj = new Student();
change(obj);
System.out.println(obj.marks);
}
}
The original object remains unchanged because only the copied reference was reassigned.
14. Variable Scope with Parameters
Parameters are accessible only inside their method.
14.1 Scope Example
public class Main {
static void show(int number) {
System.out.println(number);
}
public static void main(String[] args) {
show(10);
System.out.println(number);
}
}
This code causes an error because number exists only inside the show() method.
Method parameters are local to their own method body.
15. Nested Method Calls with Arguments
Methods can pass arguments to other methods.
15.1 Example of Nested Argument Passing
public class Main {
static int square(int number) {
return number * number;
}
static void display(int value) {
System.out.println(value);
}
public static void main(String[] args) {
display(square(5));
}
}
The square() method result becomes the argument for display().
16. Internal Stack Memory Behavior
Each method call creates its own stack frame.
16.1 Stack Frame Example
public class Main {
static void first(int x) {
second(x);
}
static void second(int y) {
System.out.println(y);
}
public static void main(String[] args) {
first(10);
}
}
Separate stack frames are created for first() and second() during execution.
Deep nested method calls can increase stack memory usage.
17. Common Beginner Mistakes
17.1 Wrong Number of Arguments
Methods must receive the exact number of required arguments.
public class Main {
static void add(int a, int b) {
System.out.println(a + b);
}
public static void main(String[] args) {
add(10);
}
}
This code causes a compilation error because one argument is missing.
The number of arguments must match the number of parameters.
17.2 Wrong Data Type Arguments
public class Main {
static void display(int number) {
System.out.println(number);
}
public static void main(String[] args) {
display("Java");
}
}
This code causes a type mismatch error because the method expects an integer.
17.3 Confusing Parameter and Argument
static void test(int value) {
}
value is the parameter, not the argument.
17.4 Assuming Primitive Values Change Outside Method
public class Main {
static void update(int x) {
x = 100;
}
public static void main(String[] args) {
int number = 50;
update(number);
System.out.println(number);
}
}
The original variable remains unchanged because Java copies primitive values.
18. Edge Cases in Parameters and Arguments
18.1 Methods Without Parameters
public class Main {
static void welcome() {
System.out.println("Welcome");
}
public static void main(String[] args) {
welcome();
}
}
Methods can work without parameters.
18.2 Passing Null as Argument
public class Main {
static void printText(String text) {
System.out.println(text);
}
public static void main(String[] args) {
printText(null);
}
}
The method receives a null reference value.
18.3 Empty String Argument
public class Main {
static void show(String text) {
System.out.println(text.length());
}
public static void main(String[] args) {
show("");
}
}
The output becomes 0 because the String contains no characters.
19. Best Practices for Parameters and Arguments
19.1 Use Meaningful Parameter Names
Clear parameter names improve readability.
static void printStudentName(String studentName) {
}
Descriptive names make code easier to understand.
19.2 Keep Parameter Count Small
Methods with too many parameters become difficult to manage.
static void login(String username, String password) {
}
Simple parameter lists improve maintainability.
19.3 Validate Important Arguments
Methods should validate critical input values before processing.
public class Main {
static void setAge(int age) {
if(age < 0) {
return;
}
System.out.println(age);
}
public static void main(String[] args) {
setAge(20);
}
}
Validation prevents invalid data processing.
Good parameter design improves code quality and flexibility.
20. Important Points to Remember
- a. Parameters receive input values
- b. Arguments are actual passed values
- c. Java uses pass by value
- d. Primitive values are copied
- e. Object references are also copied
- f. Parameters exist only inside methods
- g. Methods can accept multiple parameters
- h. Correct argument order is important
Parameters and arguments are essential for building flexible and reusable Java methods because they allow methods to work with dynamic input values. Understanding how Java passes primitive values and object references helps developers avoid confusion and write reliable, maintainable Java programs.