# Arithmetic operators in Java

25 May 2024
Beginner
2.33K Views
Learn via Video Course & by Doing Hands-on Labs

## Arithmetic Operators in Java: An Overview

We learned the Types of Operators in the previous tutorial Java. In this Java tutorial, we'll explore the syntax, types, and examples of arithmetic operators in Java. To further enhance your understanding and application of arithmetic operator concepts, consider enrolling in the best Java Certification Course, to gain knowledge about the effective utilization of arithmetic operators for improved problem-solving and time management.

## What are the Arithmetic Operators in Java?

Operators in Java, a Java toolkit, are being used as a symbol that performs various operations according to the code. Arithmetic operators are fundamental components of Java that empower developers to perform mathematical operations and manipulate numeric values within their programs. Arithmetic operators are symbols or characters that perform mathematical operations on numeric operands. The primary arithmetic operators in Java include addition (+), subtraction (-), multiplication (*), division (/), and modulus (%).

#### Syntax:

The syntax for using arithmetic operators in Java is straightforward:

``result = operand1 operator operand2;``

Here, operand1 and operand2 are numeric values or variables, and the operator is the arithmetic operator that defines the operation to be performed.

## Types of Arithmetic Operators

Arithmetic Operators in Java are particularly used for performing arithmetic operations on given data or variables. There are various types of operators in Java, such as

 Operators Operations + Addition - Subtraction x Multiplication / Division % Modulus

The addition operator (+) is used to add two numeric values. It can be applied to variables, literals, or a combination of both.

#### Example

``````int a = 5;
int b = 3;
int sum = a + b;
System.out.println("Sum: " + sum);
``````

In this example, the variables a and b are added, and the result is stored in the variable sum. The output will be Sum: 8.

### 2. Subtraction Operator (-)

The subtraction operator (-) is used to subtract the right operand from the left operand.

#### Example

``````int x = 10;
int y = 7;
int difference = x - y;
System.out.println("Difference: " + difference);``````

The output of this code will be Difference: 3.

### 3. Multiplication Operator

The multiplication operator (*) is used to multiply two numeric values.

#### Example

``````int p = 4;
int q = 6;
int product = p * q;
System.out.println("Product: " + product);``````

This code will output Product: 24.

### 4. Division Operator (/)

The division operator (/) is used to divide the left operand by the right operand. It performs floating-point division if the operands are of different numeric types.

#### Example

``````double numerator = 15.0;
int denominator = 3;
double result = numerator / denominator;
System.out.println("Result: " + result);
``````
The output will be Result: 5.0.

### 5. Modulus Operator (%)

The modulus operator (%) returns the remainder of the division of the left operand by the right operand. It is particularly useful for tasks such as checking whether a number is even or odd.

#### Example

``````int num = 17;
int divisor = 5;
int remainder = num % divisor;
System.out.println("Remainder: " + remainder);
``````
The output will be Remainder: 2.

### 6. Operator Precedence

It's important to understand the precedence of arithmetic operators. Multiplication, division, and modulus operations take precedence over addition and subtraction. Parentheses can be used to override the default precedence and explicitly define the order of operations.

#### Example

``````int result = 10 + 2 * 5;
System.out.println("Result: " + result);
``````
In this example, multiplication is performed first, so the output will be Result: 20.

Read More - Java Programmer Salary In India

## Example of Arithmetic Operators in Java

Let's bring it all together with a few examples in our Java Compiler:
`````` public class ArithmeticOperationsExample {
public static void main(String[] args) {
// Given values
int a = 10;
int b = 3;

// Arithmetic operations
int sum = a + b; // 13
int difference = a - b; // 7
int product = a * b; // 30
double quotient = (double) a / b; // 3.333...
int remainder = a % b; // 1

// Displaying results
System.out.println("Sum: " + sum);
System.out.println("Difference: " + difference);
System.out.println("Product: " + product);
System.out.println("Quotient: " + quotient);
System.out.println("Remainder: " + remainder);
}
}
``````

This Java program initializes two variables a and b with values 10 and 3, respectively. It then performs the specified arithmetic operations and prints the results to the console. The explicit casting (double) is used to ensure that the division results in a floating-point value.

#### Output

``````Sum: 13
Difference: 7
Product: 30
Quotient: 3.3333333333333335
Remainder: 1
``````
##### Summary
This was all about the types of arithmetic operators in Java. Arithmetic operators in Java are indispensable tools for performing mathematical computations in programs. From basic addition to complex calculations, understanding these operators is crucial for any Java developer. If you're interested in more tips and guidance, you may also consider our Java Online Course, which can validate your skills and enhance your credibility in the field.

## FAQs

### Q1. What are arithmetic operators in Java?

Arithmetic operators in Java are symbols or characters used to perform mathematical operations on numerical values. The standard arithmetic operators include addition (+), subtraction (-), multiplication (*), division (/), and modulus (%).

### Q2. How does the addition operator work in Java?

The addition operator (+) in Java is used to add two numeric values. It can be applied to variables, literals, or a combination of both.

### Q3. Can I use arithmetic operators with different data types in Java?

Yes, Java supports automatic type conversion (type casting) for certain operations. However, it's essential to be aware of potential loss of precision when working with different data types

### Q4. How does the modulus operator work in Java?

The modulus operator (%) in Java returns the remainder of the division of the left operand by the right operand. It is often used to check for divisibility or to cycle through a range of values.

### Q5. Are parentheses necessary when using arithmetic operators?

Parentheses can be used to control the order of operations and to make expressions more readable.
Share Article

### Live Classes Schedule

Our learn-by-building-project method enables you to build practical/coding experience that sticks. 95% of our learners say they have confidence and remember more when they learn by building real world projects.
 Advanced Full-Stack .NET Developer Certification Training Aug 17 SAT, SUN Filling Fast09:30AM to 11:30AM (IST) ASP.NET Core Certification Training Aug 17 SAT, SUN Filling Fast09:30AM to 11:30AM (IST) Angular Certification Training Aug 18 SAT, SUN Filling Fast08:30PM to 10:30PM (IST) Full-Stack .NET Developer Certification Training Aug 18 SAT, SUN Filling Fast08:30PM to 10:30PM (IST) ASP.NET Core Certification Training Aug 23 MON, WED, FRI Filling Fast07:00AM to 08:30AM (IST) ASP.NET Core Project Aug 24 SAT, SUN Filling Fast07:00AM to 09:00AM (IST) ASP.NET Core Certification Training Sep 01 SAT, SUN Filling Fast08:30PM to 10:30PM (IST) Advanced Full-Stack .NET Developer Certification Training Sep 01 SAT, SUN Filling Fast08:30PM to 10:30PM (IST) .NET Microservices Certification Training Sep 08 SAT, SUN Filling Fast05:30PM to 07:30PM (IST) .NET Solution Architect Certification Training Sep 08 SAT, SUN Filling Fast05:30PM to 07:30PM (IST)

Can't find convenient schedule? Let us know