---
# System prepended metadata

title: Functions 2

---

# Functions 2

#### Few things to know about functions
1. When will a function end?
    * When all the statements of that function are executed
    * When we execute the return statement
2. What happens when the function ends?
    * We go back to where it was called from [the function call]

Code1:
```java 
Line1:    static boolean IsEven(int N){
Line2:        if(N % 2 == 0){
Line3:            return true;
Line4:        }
Line5:        System.out.println("Hey");
Line6:        return false;
Line7:    }
Line8:    public static void main(String[] args){
Line9:        System.out.println(IsEven(8);)
Line10:   }
```
Output
``` java 
true
```
Explanation:
```
Here, we are calling the function with N = 8 
the condition N%2==0 gives true
So, the if block gets executed and we execute Line 3.
Line 3 helps us exit the function.
And we come back to the function call at Line 9.
```
Code2:
```java 
Line1:    static void printHello(){
Line2:        System.out.println("Hello Everyone");
Line3:        System.out.println("Good Morning");
Line4:    }
Line5:    public static void main(String[] args){
Line6:        printHello();
Line7:        System.out.println("Bye");        
Line8:    }
```
Output
``` java 
Hello Everyone
Good Morning
Bye
```
Explanation:
```
Line 6 calls the printHello() function.
So, we start executing from Line 1.
Line 2 prints "Hello Everyone" in the output.
Line 3 prints "Good Morning" in the output.
Since there are no more statements to execute.
The function ends and we come back to Line 6.
With Line 7 we print "Bye" in the output.
```
### Rule 1 : When we create a function which has some mistake in it, we will get error irrespective of whether that function is being called or not.

Code : 
```java 
static int check(int N){ 
    System.out.println(N+10); 
}		
public static void main(String[] args){
    int a = 10; 
    System.out.println(a+10);
}
```

Output : 
``` java 
error: missing return statement
```

Explanation : 
```
In the check function, the return type is int. 
But we are not returning an integer value from that function.
```

### Rule 2 : We can use return keyword when the return type is void without returning anything

Code 1: 
``` java
Line1:    static void test2(){
Line2:        System.out.println("Hi");
Line3:        return;
Line4:    }
Line5:    public static void main(String args[]) {
Line6:        test2();
Line7:    }
``` 
Output: 
```java 
Hi
```
Explanation: 
```
Here, we are not returning anything with return keyword.
Hence it can be used with void type as well.

```

Code 2:
```java 
Line1:    static void evenodd(int N){
Line2:        if(N%2==0){
Line3:            System.out.println("Even");
Line4:            return;
Line5:        }
Line6:        System.out.println("Odd");
Line7:    }
Line8:    public static void main(String args[]) {
Line9:        evenodd(14);
Line10:       System.out.println("Done");
Line11:   }
```

Output:
```java 
Even
Done
```

Explanation:
```
Line 9 calls evenodd() function.
The execution starts from Line 1, we recieve N = 14
Line 2 condition is true. So, if block gets executed.
Line 3 prints "Even" in the output.
Line 4 executes and exits the function and comes back to Line 9.
Then Line 10 prints Done in the output.
```

### Rule 3 : If function has a return type which is not void, then we need to return a value in all the cases.

> Protip : Assume all the conditions are false and check whether we have a return statement or not. 


Code : 
``` java 
static int even(int N){ 
    if(N%2==0){
        return 2;
    }
}	
public static void main(String args[]) {
    System.out.println(even(27));
}
```
Output : 
``` java
error: missing return statement
```
Explanation : 
```
Here, we are returning a value in the case when condition is true
So, we are missing a return statement when condition is false
```

### Rule 4 : Having unreachable statements in the code gives us error

The statements which never get executed are called unreachable statements.

Code : 
```java 
Line1:    static int sum(int a,int b){
Line2:        return a+b;  
Line3:        System.out.println("Hey"); 
Line4:    }	
Line5:    public static void main(String args[]) {
Line6:        System.out.println(sum(10, 5));
Line7:    }
```

Output : 
``` java 
error: unreachable statement
        System.out.println("Hey"); 
        ^
```
Explanation : 
```
With the help of Line 2, we exit the sum function
Hence, Line 3 never gets executed making it a unreachable statement
```
