Methods
## Learning Objectives
- Define and call methods
- Understand parameters and return values
- Master method overloading
- Learn variable arguments
## Defining Methods
### Basic Structure
```java
public static void greet() {
System.out.println("Hello!");
}
```
### Method with Return Type
```java
public static int add(int a, int b) {
return a + b;
}
```
### Calling Methods
```java
public class Main {
public static void main(String[] args) {
greet(); // void method
int sum = add(5, 3); // returns 8
System.out.println(sum);
}
public static void greet() {
System.out.println("Hello!");
}
public static int add(int a, int b) {
return a + b;
}
}
```
## Parameters and Arguments
### Passing Arguments
```java
public static void printName(String name) {
System.out.println("Name: " + name);
}
// Call with argument
printName("Alice");
```
### Multiple Parameters
```java
public static int calculateArea(int width, int height) {
return width * height;
}
int area = calculateArea(5, 10); // 50
```
### Return Values
```java
public static boolean isEven(int number) {
return number % 2 == 0;
}
if (isEven(4)) {
System.out.println("Even");
}
```
## Return Types
### void (No Return)
```java
public static void printHello() {
System.out.println("Hello");
}
```
### Return Early
```java
public static String getGrade(int score) {
if (score >= 90) return "A";
if (score >= 80) return "B";
if (score >= 70) return "C";
return "F";
}
```
### Multiple Returns (Guard Clauses)
```java
public static boolean validate(int age, String name) {
if (age < 0) return false;
if (name == null || name.isEmpty()) return false;
// main validation
return true;
}
```
## Method Overloading
### Same Name, Different Parameters
```java
public static int add(int a, int b) {
return a + b;
}
public static double add(double a, double b) {
return a + b;
}
public static int add(int a, int b, int c) {
return a + b + c;
}
```
### How It Works
```java
add(5, 3); // Calls add(int, int)
add(5.0, 3.0); // Calls add(double, double)
add(1, 2, 3); // Calls add(int, int, int)
```
### Overload Resolution
Java determines which method to call based on:
1. Number of arguments
2. Type of arguments
3. Order of argument types
## varargs (Variable Arguments)
### Syntax
```java
public static int sum(int... numbers) {
int total = 0;
for (int num : numbers) {
total += num;
}
return total;
}
// Can pass any number of arguments
sum(1, 2, 3); // sum of 1, 2, 3 = 6
sum(1, 2, 3, 4, 5); // sum of 1, 2, 3, 4, 5 = 15
sum(); // 0
```
### With Regular Parameters
```java
public static void printAll(String prefix, int... numbers) {
for (int num : numbers) {
System.out.println(prefix + num);
}
}
printAll("Value: ", 1, 2, 3);
// Value: 1
// Value: 2
// Value: 3
```
## Static Methods
### Belong to Class, Not Instance
```java
public class MathUtils {
public static int square(int x) {
return x * x;
}
}
// Call without creating instance
int result = MathUtils.square(5);
```
### When to Use static
- Utility methods (Math.random(), Arrays.sort())
- Methods that don't need instance data
- Constants
## Instance Methods
### Require Object Instance
```java
public class Person {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}
// Must create instance
Person p = new Person();
p.setName("Alice");
System.out.println(p.getName());
```
## Passing Primitives vs References
### Primitives (Pass by Value)
```java
public static void doubleIt(int x) {
x = x * 2; // Only affects local copy
}
int num = 5;
doubleIt(num);
System.out.println(num); // Still 5
```
### Objects (Pass by Reference Value)
```java
public static void changeName(Person p) {
p.setName("Bob"); // Affects original object
}
Person person = new Person();
person.setName("Alice");
changeName(person);
System.out.println(person.getName()); // Bob
```
### Reassigning Reference
```java
public static void reassign(Person p) {
p = new Person(); // Only affects local copy
p.setName("Charlie");
}
Person person = new Person();
person.setName("Alice");
reassign(person);
System.out.println(person.getName()); // Alice
```
## Recursion
### Method Calling Itself
```java
public static int factorial(int n) {
if (n <= 1) return 1;
return n * factorial(n - 1);
}
// factorial(5) = 5 * 4 * 3 * 2 * 1 = 120
```
### Iterative Alternative
```java
public static int factorial(int n) {
int result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
```
## Summary
- Methods: `access_modifier static? return_type name(params) { }`
- Overloading: same name, different parameters
- varargs: `type... name` for variable arguments
- static: belongs to class, called as `ClassName.method()`
- Primitives passed by value; objects passed by reference value
- Recursion: method calls itself (ensure base case)
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →