Java uses **if/else** statement for conditional control flow. It is used to test the conditions and based on the Boolean result (true or false) of the condition the control of the execution is decided.

There are 4 ways to write an if-else statement:
- if statement
- if-else statement
- if-else if statement
- nested if statement

## if statement

Java if statement tests the condition and executed only if the condition is true. It has only if block, no else block.

Syntax:

```java
if(condition) // enter the condition in the parenthesis
{
	// code to be executed when the condition is true.
}
```

![if-else-flowchart](https://firebasestorage.googleapis.com/v0/b/hackinbits.appspot.com/o/image1.png?alt=media&token=76388faa-33c8-442f-96a4-6dd1d95897e1)

**Example:**

```java
public class example{
	public static void main(String arg[]){
		int n = 10;
		if(n > 11){ // condition is false so the if block is not fired
			System.out.println(“Number is greater”);
		}
	}
}
```

## if-else Statement

Java if-else statement tests the condition where if block is fired when the condition is true, if not then the else block is executed.

**Syntax:**

```java
if(condition){
	//code to be executed when the condition is true
}
else{
	//code to be executed when the condition is false
}
```

![if-else-flowchart](https://firebasestorage.googleapis.com/v0/b/hackinbits.appspot.com/o/image2.png?alt=media&token=3e22298f-9187-4e8d-877a-2e87e47e3505)

**Example:**

```java
public class example{
	public static void main(String arg[]){
		int n = 10;
		if( n % 2 == 0){ // condition to check if number is divisible by 2
			System.out.println(“Number is even”);
		}
        else{
	        System.out.println(“Number is odd”);
        }
	}
}
```

## if-else if Statement

Java if-else if ladder executes one block among multiple conditional blocks. This is used when there are different code to be executed based on the conditions.

**Syntax:**

```java
if(condition1){
	//code to be executed when the condition1 is true
}
else if(condition2){
	//code to be executed when the condition2 is true
}
else if(condition3){
	//code to be executed when the condition3 is true
}
…
else{
	//code to be executed when all conditions are false
}

```

![if-else if flowchart](https://firebasestorage.googleapis.com/v0/b/hackinbits.appspot.com/o/image4.png?alt=media&token=0a39312c-7955-4d9c-a033-0d537ddcc75e)

**Example:**

```java
public class example{
	public static void main(String arg[]){

		int marks =55;
		if( marks < 50){
			System.out.println(“Fail”);
		}
else if( marks >= 50 && marks < 60){
			System.out.println(“D grade”);
		}
else if( marks >= 60 && marks < 70){
			System.out.println(“C grade”);
		}
else if( marks >= 70 && marks < 80){
			System.out.println(“B grade”);
		}
else if( marks >= 80 && marks < 90){
			System.out.println(“A grade”);
		}
else if( marks >= 90 && marks < 100){
			System.out.println(“A+ grade”);
		}
else{
	System.out.println(“Invalid”);
}
	}
}
```

## Nested if statement

Java nested if statement represents if block within another if block. Here, the inner if block is executed only if the outer if block condition is true.

**Syntax:**

```java
if(condition){
	// code to be executed
	if(condition){
		// code to be executed
	}
}
```

If you like this article, please click on recommend and share it.

Java If Else Conditional Control Statements 

Symbols that are used to perform a certain operation are known as operators. Examples: +,-,/,* etc.

Different types of operators available in Java are:

- Arithmetic Operator
- Assignment Operator
- Logical Operator
- Bitwise Operator
- Relational Operator
- Shift Operator
- Unary Operator, and
- Ternary Operator

![java operators](https://firebasestorage.googleapis.com/v0/b/hackinbits.appspot.com/o/java_operators.png?alt=media&token=1c81fe50-22a2-437b-9786-6a32734f356d)


## Examples to understand different operators

### Arithmetic Operator

```java
class ArithmeticOperator {
 public static void main(String[] args) {
  int a = 15;
  int b = 5;
  System.out.println(a + b); //20
  System.out.println(a - b); //10
  System.out.println(a * b); //75
  System.out.println(a / b); //3
  System.out.println(a % b); //0
 }
}

class ArithmeticOperatorExpr {
 public static void main(String[] args) {
  System.out.println(10 * 10 / 5 + 3 - 1 * 4 / 2); //21
 }
}
```

### Assignment Operator

```java
class AssignmentOperator {
 public static void main(String[] args) {
  int a = 15;
  int b = 5;
  a += 4; //a=a+4
  b -= 4; //b=b-4
  System.out.println(a); //0
  System.out.println(b); //0
 }
}

class AssignmentOperator {
 public static void main(String[] args) {
  int a = 15;
  a += 4;
  System.out.println(a);
  a -= 4;
  System.out.println(a);
  a *= 2;
  System.out.println(a);
  a /= 2;
  System.out.println(a);
 }
}

class AssignmentOperator {
 public static void main(String[] args) {
  short a = 15;
  short b = 5;
  a = a + b; //Should throw Compile time error because 10+10=20 wiz int
  System.out.println(a);
 }
}
```

### After type casting

```java
class AssignmentOperator {
 public static void main(String[] args) {
  short a = 15;
  short b = 5;
  a = (short) a + b; //20 which is now converted to short
  System.out.println(a);
 }
}
```


### Logical Operator

```java
class LogicalOperator {
 public static void main(String[] args) {
  int a = 10;
  int b = 5;
  int c = 20;
  System.out.println(a < b && a++ < c); //false && true = false
  System.out.println(a); //10 because second condition is checked
  System.out.println(a > b || a++ < c); //true || true = true
  System.out.println(a); //10 because second condition is checked
 }
}
```

### Bitwise Operator

```java
class BitwiseOperator {
 public static void main(String[] args) {
  int a = 10;
  int b = 5;
  int c = 20;
  System.out.println(a < b & a++ < c); //false & true= false
  System.out.println(a); //11 because second condition is checked
  System.out.println(a > b | a++ < c); //true | true = true
  System.out.println(a); //12 because second condition is checked
 }
}
```

![bitwise operator](https://firebasestorage.googleapis.com/v0/b/hackinbits.appspot.com/o/java_operators_2.png?alt=media&token=4f75438e-e228-4a05-88b6-83ed0a029365)

### Relational Operator

```java
class RelationalOperator {
 public static void main(String[] args) {
  int a = 10;
  int b = 5;
  int c = 20;
  if (a >= b)
   System.out.println(a);
  If(b < c)
  System.out.println(b);
  If(a != c)
  System.out.println(c);
 }
}
```

### Shift Operator

- **Left Shift:** << operator is used to shift all bits in the value to the left, the specified number of times.
- **Right Shift:** >> operator is used to shift all bits in the value to the right, the specified number of times.

```java
class ShiftOperator {
 public static void main(String[] args) {
  System.out.println(10 << 2); //10*2^2=10*4=40
  System.out.println(10 << 3); //10*2^3=10*8=80
  System.out.println(20 << 2); //20*2^2=20*4=80
  System.out.println(15 << 4); //15*2^4=15*16=240
  System.out.println(10 >> 2); //10/2^2=10/4=2
  System.out.println(10 >> 3); //10/2^3=10/8=1
  System.out.println(20 >> 2); //20/2^2=20/4=5
  System.out.println(15 >> 4); //15/2^4=15/16=0
 }
}
```

### Unary Operator

**Uses:**

- Incrementing/decrementing a value by one
- Negating an expression
- Inverting the value of a boolean

```java
class UnaryOperator {
 public static void main(String[] args) {
  int a = 10;
  int x = 10;
  int y = -10;
  boolean c = true;
  Boolean d = false;
  System.out.println(x++); //10(11)
  System.out.println(++x); //12
  System.out.println(x--); //12(11)
  System.out.println(--x); //10
  System.out.println(x++ + ++x); //10+12=22
  System.out.println(x++ + x++); //12+13=25
  System.out.println(~x); //-11 (minus of total positive value which starts from 0)
  System.out.println(~y); //9 (positive of total minus, positive starts from 0)
  System.out.println(!c); //false (opposite of Boolean value)
  System.out.println(!d); //true
 }
}
```

### Ternary Operator

```java
class TernaryOperator {
 public static void main(String[] args) {
  int a = 2;
  int b = 5;
  int min = (a < b) ? a : b;
  System.out.println(min);
 }
}
```

----

**If you liked this article, please upvote and recommend it to show your support. Feel free to ask any questions in the comments below.** 

----

**We publish articles on web development and technology frequently. Consider subscribing to our newsletter or follow us on our social channels ([twitter](https://twitter.com/hackinbits), [Facebook](https://www.facebook.com/hackinbits/), [LinkedIn](https://www.linkedin.com/company/hackinbits)).**

Different types of operators in Java

Java switch statement executes one statement out of multiple conditions. Java switch statement is similar to **if-else if** ladder.

The switch statement supports multiple data types in the condition like byte, short, int, long, enumerations, some wrapper types like Byte, Short, Integer, Long. Since, the release of Java 7, the use of Strings is also supported in the switch conditions.

## Points to remember about a Switch Statement

- Switch statement works by comparing the equality of a variable against multiple values.

- You can have N number of case statements within a switch. Each case is followed by the value to be compared to and a colon (‘:’).

- The value for a case must be the same data type as the variable in the switch and it must be a constant or a literal. It doesn’t allow variables.

- When the variable being switched on is equal to a case, the statements following that case will execute until a break statement is reached.

- When a break statement is reached, the switch terminates, and the flow of control jumps to the next line following the switch statement.

- Not every case needs to contain a break. If no break appears, the flow of control will fall through to subsequent cases until a break is reached.

- A switch statement can have an optional default case, which must appear at the end of the switch. The default case can be used for performing a task when none of the cases is true. No break is needed in the default case.

## Syntax

```java
switch(expression){
	case value1:
		//code to be executed;
		break;
	case value2:
		//code to be executed;
		break;
	……..
	default:
		//code to be executed when all cases are unmatched;
}
```

![Switch statement](https://firebasestorage.googleapis.com/v0/b/hackinbits.appspot.com/o/switch_statement.png?alt=media&token=40113a72-04cb-4540-baaf-cc8b1687edff)

## Examples

### Finding the month

```java
public class example {
 public static void main(String[] args) {
  int month = 7;
  String monthString = "";
  switch (month) {
   case 1:
    monthString = "1 - January";
    break;
   case 2:
    monthString = "2 - February";
    break;
   case 3:
    monthString = "3 - March";
    break;
   case 4:
    monthString = "4 - April";
    break;
   case 5:
    monthString = "5 - May";
    break;
   case 6:
    monthString = "6 - June";
    break;
   case 7:
    monthString = "7 - July";
    break;
   case 8:
    monthString = "8 - August";
    break;
   case 9:
    monthString = "9 - September";
    break;
   case 10:
    monthString = "10 - October";
    break;
   case 11:
    monthString = "11 - November";
    break;
   case 12:
    monthString = "12 - December";
    break;
   default:
    System.out.println("Invalid Month!");
  }
  System.out.println(monthString);
 }
}
```

### Switch with fall-through

The **case** will be executed until a break statement is encountered.

```java
public class example {
 public static void main(String[] args) {
  int number = 20;
  switch (number) {
   case 10:
    System.out.println("10");
   case 20:
    System.out.println("20");
   case 30:
    System.out.println("30");
   default:
    System.out.println("Not in 10, 20 or 30");
  }
 }
}
```

### Switch with String expression since Java SE 7

```java
public class example {
 public static void main(String[] args) {
  String levelString = "Expert";
  int level = 0;
  switch (levelString) {
   case "Beginner":
    level = 1;
    break;
   case "Intermediate":
    level = 2;
    break;
   case "Expert":
    level = 3;
    break;
   default:
    level = 0;
    break;
  }
  System.out.println("Your Level is: " + level);
 }
}
```

### Nested Switch Statement

```java
public class example {
 public static void main(String args[]) {
  char branch = 'M';
  int collegeYear = 3;
  switch (collegeYear) {
   case 1:
    System.out.println("English, Maths, Science");
    break;
   case 2:
    switch (branch) {
     case 'C':
      System.out.println("Operating System, Java, Data Structure");
      break;
     case 'E':
      System.out.println("Micro processors, Logic switching theory");
      break;
     case 'M':
      System.out.println("Drawing, Manufacturing Machines");
      break;
    }
    break;
   case 3:
    switch (branch) {
     case 'C':
      System.out.println("Computer Organization, MultiMedia");
      break;
     case 'E':
      System.out.println("Fundamentals of Logic Design, Microelectronics");
      break;
     case 'M':
      System.out.println("Internal Combustion Engines, Mechanical Vibration");
      break;
    }
    break;
   case 4:
    switch (branch) {
     case 'C':
      System.out.println("Data Communication and Networks, MultiMedia");
      break;
     case 'E':
      System.out.println("Embedded System, Image Processing");
      break;
     case 'M':
      System.out.println("Production Technology, Thermal Engineering");
      break;
    }
    break;
  }
 }
}
```

### Switch statement with Enumeration

```java
public class JavaSwitchEnumExample {
 public enum Month {
  Jan,
  Feb,
  Mar,
  Apr,
  May,
  Jun,
  Jul,
  Aug,
  Sept,
  Oct,
  Nov,
  Dec
 }
 public static void main(String args[]) {
  Month[] monthNow = Month.values();
  for (Month Now: monthNow) {
   switch (Now) {
    case Jan:
     System.out.println("January");
     break;
    case Feb:
     System.out.println("February");
     break;
    case Mar:
     System.out.println("March");
     break;
    case Apr:
     System.out.println("April");
     break;
    case May:
     System.out.println("May");
     break;
    case Jun:
     System.out.println("June");
     break;
    case Jul:
     System.out.println("July");
     break;
    case Aug:
     System.out.println("August");
     break;
    case Sept:
     System.out.println("September");
     break;
    case Oct:
     System.out.println("October");
     break;
    case Nov:
     System.out.println("November");
     break;
    case Dec:
     System.out.println("December");
     break;
   }
  }
 }
}
```

### Switch with wrapper classes

Java switch statement uses Byte, Short, Integer and Long wrapper classes.

```java
public class example {
 public static void main(String args[]) {
  Integer number = 35;
  switch (number) {
   case (16):
    System.out.println("You are under 18.");
    break;
   case (18):
    System.out.println("You are eligible for vote.");
    break;
   case (65):
    System.out.println("You are senior citizen.");
    break;
   default:
    System.out.println("Please give the valid age.");
    break;
  }
 }
}
```

----

**If you liked this article, please upvote and recommend it to show your support. Feel free to ask any questions in the comments below.** 

----

**We publish articles on web development and technology frequently. Consider subscribing to our newsletter or follow us on our social channels ([twitter](https://twitter.com/hackinbits), [Facebook](https://www.facebook.com/hackinbits/), [LinkedIn](https://www.linkedin.com/company/hackinbits)).**
