Control flow

Data types

Variables


Operators are a fundamental aspect of programming that allow you to manipulate and compare data in
your programs.

**3 main types of operators:**

- arithmetic
- comparison
- logical

## Arithmetic operators

Arithmetic operators are symbols or words used to perform basic math operations, such as

- addition
- subtraction
- multiplication
- division

You can use them to perform calculations and manipulate data.

### Addition

Use `+` operator to add two numbers together.

```java
int x = 5;
int y = 10;
int sum = x + y; // sum is 15
```

### Subtraction

Use `-` operator to subtract one number from another.

```java
int x = 10;
int y = 5;
int difference = x - y; // difference is 5
```

### Multiplication

Use `*` operator to multiply two numbers together.

```java
int x = 5;
int y = 10;
int product = x * y; // product is 50
```

### Division

Use `/` operator to divide one number by another.

```java
int x = 10;
int y = 5;
int quotient = x / y; // quotient is 2
```

Note: these are just a few examples of arithmetic operators. There are others you can
use for more advanced math operations.

## Comparison operators

Comparison operators are used to compare two values and determine how they relate (are
they equal, greater than, or less than each other). They are often used in conditional
statements to determine the flow of the program.

### Equal

Use `==` operator to check if two values are equal.

```java
int x = 5;
int y = 10;

if (x == y) {
	// this code will not execute because
	// x is not equal to y
}
```

### Greater than

Use `>` operator to check if one value is greater than another.

```java
int x = 5;
int y = 10;

if (x > y) {
	// this code will not execute because
	// x is not greater than y
}
```

### Greater than or equal to

Use `>=` operator to check if one value is greater than or equal to another.

```java
int x = 5;
int y = 10;

if (x >= y) {
	// this code will not execute because
	// x is not greater than or equal y
}
```

### Less than

Use `<` operator to check if one value is less than another.

```java
int x = 5;
int y = 10;

if (x < y) {
	// this code will execute because x is less than y
}
```

### Less than or equal to

Use `<=` operator to check if one value is less than or equal to another.

```java
int x = 5;
int y = 10;

if (x <= y) {
	// this code will execute because
	// x is less than or equal to y
}
```

**Important**: comparison operators always return a boolean value - `true` or `false`. This is often used in
conditional statements to determine the program flow.


## Logical operators

You can use logical operators to combine multiple comparison operators or other logical expressions.

**3 main logical operators:**

- `&&` (and)
- `||` (or)
- `!` (not)

### AND

The `&&` operator is used to check if two conditions are **both** true.

```java
if (x > 0 && y > 0) {
	// this code will execute if both x and y are greater than 0
}
```

### OR

The `||` operator is used to check if **at least one** of two conditions is true.

```java
if (x > 0 || y > 0) {
	// this code will execute if
	// either x or y (or both) are greater than 0
}
```

### NOT

The `!` operator is used to negate a condition.

```java
if (!(x > 0)) {
	// this code will execute if x is not greater than 0
}
```

## Other

In addition to these common operators, there are also specialized operators that serve specific
purposes. In many languages, you can use the `++` operator to increment a value by 1, and `--` operator
to decrement a value by 1.

The `&` operator is used to perform a bitwise and operation, while the `|` operator is used to
perform a bitwise or operation.

## Precedence

It's important you pay attention to operator _precedence_. No, that's not yet another operator.
Precedence means certain operators have a higher priority than others and will be executed first.

In the expression `x + y * z`, multiplication will be performed before the addition because `*`
has a higher precedence than `+`.

`&&` and `||` operators also have different precedence levels.

The `&&` operator has a higher precedence level than the `||` operator, so it will be evaluated first.

```java
if (x > 0 && y > 0 || z > 0) {
	// this code will execute if
	// x and y are both greater than 0
	// or if z is greater than 0
}
```

To specify a different order of evaluation, you can use parentheses to group conditions.

```java
if ((x > 0 && y > 0) || z > 0) {
	// this code will execute if
	// either x and y are both greater than 0
	// or if z is greater than 0
}
```

## Summary

Operators are symbols or words used in programming to perform various actions on data. There
are three main types: arithmetic, comparison, and logical.

**Arithmetic operators** are used to perform basic math operations.

**Comparison operators** are used to compare two values and determine their relationship.

**Logical operators** are used to combine comparison operators or other logical expressions.



Programmers' Garden

Operators

More concepts you should know about

Control flow

Data types

Variables