This article covers basic operators of Java syntax, and how they function. By thorough discussion and coding examples, you’ll be able to use basic operators in your programs like a pro.

### What are basic operators?

Java provides different sets of operators to perform simple computations like addition/ subtraction and other advanced operators for decision making or individual bitwise calculations.

Here are some major categories of operators

- Arithmetic Operators (
`+`

,`-`

,`*`

,`/`

) - Relational Operators (
`==`

,`!=`

) - Logical Operators (
`&&`

,`||`

) - Assignment Operators (
`=`

,`+=`

,`-=`

) - Unary Operators (pre/post-fix)
- Shift Operators (
`>>`

,`<<`

) - Bitwise Operators (
`&`

,`|`

,`^`

) - Ternary/Conditional Operator (
`?:`

) - Misc Operators

The scope of this article encompass arithmetic, relational and logical operators only.

### Arithmetic Operators

You can use basic arithmetic operators to perform a mathematical calculation and impact the value of any variable. Let’s see how it works in Java.

```
package com.basicoperators.core;
public class ArithmeticOperators {
public static void main(String[] args) {
// Addition
int apples = 5;
int oranges = 7;
int totalFruits = apples + oranges;
System.out.println("\n-------------Addition---------------- " );
System.out.println("Apples: " + apples);
System.out.println("Oranges: " + oranges);
System.out.println("Total Fruits: " + totalFruits);
// Subtraction
int totalBananas = 24;
int bananasSold = 12;
int bananasLeft = totalBananas - bananasSold;
System.out.println("\n----------------Subtraction--------------- " );
System.out.println("Total Bananas: " + totalBananas);
System.out.println("Bananas Sold: " + bananasSold);
System.out.println("Bananas Left: " + bananasLeft);
// Multiplication
int weeks = 3;
int daysInAWeek = 7;
int totalNumberOfDays = weeks * daysInAWeek;
System.out.println("\n--------------Multiplication-------------- " );
System.out.println("Days In A Week: " + daysInAWeek);
System.out.println("Days In A Week: " + daysInAWeek);
System.out.println("Total Number Of Days: " + totalNumberOfDays);
// Division
int totalMinutesConsumed = 420;
int minutesInOneHour = 60;
int numOfHours = totalMinutesConsumed / minutesInOneHour;
System.out.println("\n----------------Division---------------- " );
System.out.println("Total Minutes: " + totalMinutesConsumed);
System.out.println("Minutes In One Hour: " + minutesInOneHour);
System.out.println("Num Of Hours: " + numOfHours);
}
}
```

**Output**

```
----------------------Addition----------------------
Apples: 5
Oranges: 7
Total Fruits: 12
---------------------Subtraction---------------------
Total Bananas: 24
Bananas Sold: 12
Bananas Left: 12
--------------------Multiplication-------------------
Days In A Week: 7
Days In A Week: 7
Total Number Of Days: 21
----------------------Division----------------------
Total Minutes Consumed: 420
Minutes In One Hour: 60
Num Of Hours: 7
```

### Relational Operators

As the name implies, relational operators define the relationship of one instance with another. This means you can compare two numbers and see what relationship do they share. If they are equal to each other, one is greater than or smaller than the other number. Like 2 is less than 3. According to Java syntax, both instances should be of the same data type. For example, you can not compare if an integer is less than a string. Here is a small snippet explaining how you can use basic relational operators in Java.

```
package com.basicoperators.core;
public class RelationalOperators {
public static void main(String[] args) {
int even = 2;
int odd = 3;
System.out.println("Even = " + even);
System.out.println("Odd = " + odd);
// prints if even is equal to odd
boolean check = even == odd;
System.out.println("Is Even equal to Odd? " + check);
// prints if even is not equal to odd
check = even != odd;
System.out.println("Is Even not equal to Odd? " + check);
// prints if even is greater than odd
check = even > odd;
System.out.println("Is Even greater than Odd? " + check);
// prints if even is less than odd
check = even < odd;
System.out.println("Is Even less than Odd? " + check);
// prints if even is greater than equal to odd
check = even >= odd;
System.out.println("Is Even greater than equal to Odd? " + check);
// prints if even is less than equal to odd
check = even <= odd;
System.out.println("Is Even less than equal to Odd? " + check);
}
}
```

**Output**

```
Even = 2
Odd = 3
Is Even equal to Odd? false
Is Even not equal to Odd? true
Is Even greater than Odd? false
Is Even less than Odd? true
Is Even greater than equal to Odd? false
Is Even less than equal to Odd? true
```

### Logical Operators

Logical Operators in Java are used for decision making. They allow the programmer to test if the combination of given expressions are true or false. Based on the result of your expression, you can make a decision.

- AND – returns “true” only if both expressions are true
- OR – returns “true” if any of the given expressions is true
- NOT – returns the “inverse” of any given boolean expression

For your better understanding, let’s look at the following snippet.

```
package com.basicoperators.core;
public class LogicalOperators {
public static void main(String[] args) {
String myPet1 = "doggo";
String myPet2 = "kitty";
System.out.println("Pet1: " + myPet1);
System.out.println("Pet2: " + myPet2);
// implements AND
boolean check = myPet1.equals("doggo") && myPet2.equals("kitty");
// returns true only when both conditions are true
System.out.println("Does my first pet name \"doggo\", and second one \"kitty\"? " + check);
check = myPet1.equals("dog") && myPet2.equals("kitty");
// returns "false" even if single condition is false
// remember these conditions are case sensitive
System.out.println("Does my first pet name \"dog\", and second one \"kitty\"? " + check);
// implements OR
check = myPet1.equals("doggo") || myPet2.equals("lion");
// returns "true" even when single condition is true
System.out.println("Does any of my pet name \"doggo\"? " + check);
check = myPet1.equals("cat") || myPet2.equals("tiger");
// returns "false" because both conditions are false
System.out.println("Does any of my pet name \"tiger\"? " + check);
// implements NOT
check = !(myPet1.equals("bingo") && myPet2.equals("kate"));
// returns "true" when both conditions are true (inverse of statement)
System.out.println("Does my first pet name \"bingo\", and second one \"kate\"? " + check);
check = !(myPet1.equals("doggo") && myPet2.equals("kitty"));
// returns "false" because both conditions are true
System.out.println("Does my first pet name \"doggo\", and second one \"kitty\"? " + check);
}
}
```

**Output**

```
Pet1: doggo
Pet2: kitty
Does my first pet name "doggo", and second one "kitty"? true
Does my first pet name "dog", and second one "kitty"? false
Does any of my pet name "doggo"? true
Does any of my pet name "tiger"? false
Does my first pet name "bingo", and second one "kate"? true
Does my first pet name "doggo", and second one "kitty"? false
```

### Conclusion

The basic operators in Java are pretty simple to learn and easy to use. You might get overwhelmed by studying the different operators all at once. However, we recommend you practicing one set at a time. This way, you’ll master all of them soon. As always, you’re welcome to plug-in in case of any confusion. Happy learning!