variables assignment in java

The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available. See Java Language Changes for a summary of updated language features in Java SE 9 and subsequent releases. See JDK Release Notes for information about new features, enhancements, and removed or deprecated options for all JDK releases.

As you learned in the previous lesson, an object stores its state in fields .

The What Is an Object? discussion introduced you to fields, but you probably have still a few questions, such as: What are the rules and conventions for naming a field? Besides int , what other data types are there? Do fields have to be initialized when they are declared? Are fields assigned a default value if they are not explicitly initialized? We'll explore the answers to such questions in this lesson, but before we do, there are a few technical distinctions you must first become aware of. In the Java programming language, the terms "field" and "variable" are both used; this is a common source of confusion among new developers, since both often seem to refer to the same thing.

The Java programming language defines the following kinds of variables:

Instance Variables (Non-Static Fields) Technically speaking, objects store their individual states in "non-static fields", that is, fields declared without the static keyword. Non-static fields are also known as instance variables because their values are unique to each instance of a class (to each object, in other words); the currentSpeed of one bicycle is independent from the currentSpeed of another.
Class Variables (Static Fields) A class variable is any field declared with the static modifier; this tells the compiler that there is exactly one copy of this variable in existence, regardless of how many times the class has been instantiated. A field defining the number of gears for a particular kind of bicycle could be marked as static since conceptually the same number of gears will apply to all instances. The code static int numGears = 6; would create such a static field. Additionally, the keyword final could be added to indicate that the number of gears will never change.
Local Variables Similar to how an object stores its state in fields, a method will often store its temporary state in local variables . The syntax for declaring a local variable is similar to declaring a field (for example, int count = 0; ). There is no special keyword designating a variable as local; that determination comes entirely from the location in which the variable is declared — which is between the opening and closing braces of a method. As such, local variables are only visible to the methods in which they are declared; they are not accessible from the rest of the class.
Parameters You've already seen examples of parameters, both in the Bicycle class and in the main method of the "Hello World!" application. Recall that the signature for the main method is public static void main(String[] args) . Here, the args variable is the parameter to this method. The important thing to remember is that parameters are always classified as "variables" not "fields". This applies to other parameter-accepting constructs as well (such as constructors and exception handlers) that you'll learn about later in the tutorial.

Having said that, the remainder of this tutorial uses the following general guidelines when discussing fields and variables. If we are talking about "fields in general" (excluding local variables and parameters), we may simply say "fields". If the discussion applies to "all of the above", we may simply say "variables". If the context calls for a distinction, we will use specific terms (static field, local variables, etc.) as appropriate. You may also occasionally see the term "member" used as well. A type's fields, methods, and nested types are collectively called its members .

Every programming language has its own set of rules and conventions for the kinds of names that you're allowed to use, and the Java programming language is no different. The rules and conventions for naming your variables can be summarized as follows:

Variable names are case-sensitive. A variable's name can be any legal identifier — an unlimited-length sequence of Unicode letters and digits, beginning with a letter, the dollar sign " $ ", or the underscore character " _ ". The convention, however, is to always begin your variable names with a letter, not " $ " or " _ ". Additionally, the dollar sign character, by convention, is never used at all. You may find some situations where auto-generated names will contain the dollar sign, but your variable names should always avoid using it. A similar convention exists for the underscore character; while it's technically legal to begin your variable's name with " _ ", this practice is discouraged. White space is not permitted.
Subsequent characters may be letters, digits, dollar signs, or underscore characters. Conventions (and common sense) apply to this rule as well. When choosing a name for your variables, use full words instead of cryptic abbreviations. Doing so will make your code easier to read and understand. In many cases it will also make your code self-documenting; fields named cadence , speed , and gear , for example, are much more intuitive than abbreviated versions, such as s , c , and g . Also keep in mind that the name you choose must not be a keyword or reserved word .
If the name you choose consists of only one word, spell that word in all lowercase letters. If it consists of more than one word, capitalize the first letter of each subsequent word. The names gearRatio and currentGear are prime examples of this convention. If your variable stores a constant value, such as static final int NUM_GEARS = 6 , the convention changes slightly, capitalizing every letter and separating subsequent words with the underscore character. By convention, the underscore character is never used elsewhere.

About Oracle | Contact Us | Legal Notices | Terms of Use | Your Privacy Rights

Java Tutorial
What is Java?
Installing the Java SDK
Your First Java App
Java Main Method
Java Project Overview, Compilation and Execution
Java Core Concepts
Java Syntax

Java Variables

Java Data Types
Java Math Operators and Math Class
Java Arrays
Java String
Java Operations
Java if statements
Java Ternary Operator
Java switch Statements
Java instanceof operator
Java for Loops
Java while Loops
Java Classes
Java Fields
Java Methods
Java Constructors
Java Packages
Java Access Modifiers
Java Inheritance
Java Nested Classes
Java Record
Java Abstract Classes
Java Interfaces
Java Interfaces vs. Abstract Classes
Java Annotations
Java Lambda Expressions
Java Modules
Java Scoped Assignment and Scoped Access
Java Exercises

Java Variable Types

Java variable declaration, java variable assignment, java variable reading, java variable naming conventions, java local-variable type inference.

A Java variable is a piece of memory that can contain a data value. A variable thus has a data type. Data types are covered in more detail in the text on Java data types .

Variables are typically used to store information which your Java program needs to do its job. This can be any kind of information ranging from texts, codes (e.g. country codes, currency codes etc.) to numbers, temporary results of multi step calculations etc.

In the code example below, the main() method contains the declaration of a single integer variable named number . The value of the integer variable is first set to 10, and then 20 is added to the variable afterwards.

In Java there are four types of variables:

Non-static fields
Static fields
Local variables

A non-static field is a variable that belongs to an object. Objects keep their internal state in non-static fields. Non-static fields are also called instance variables, because they belong to instances (objects) of a class. Non-static fields are covered in more detail in the text on Java fields .

A static field is a variable that belongs to a class. A static field has the same value for all objects that access it. Static fields are also called class variables. Static fields are also covered in more detail in the text on Java fields .

A local variable is a variable declared inside a method. A local variable is only accessible inside the method that declared it. Local variables are covered in more detail in the text on Java methods .

A parameter is a variable that is passed to a method when the method is called. Parameters are also only accessible inside the method that declares them, although a value is assigned to them when the method is called. Parameters are also covered in more detail in the text on Java methods .

Exactly how a variable is declared depends on what type of variable it is (non-static, static, local, parameter). However, there are certain similarities that

In Java you declare a variable like this:

Instead of the word type , you write the data type of the variable. Similarly, instead of the word name you write the name you want the variable to have.

Here is an example declaring a variable named myVariable of type int .

Here are examples of how to declare variables of all the primitive data types in Java:

Here are examples of how to declare variables of the object types in Java:

Notice the uppercase first letter of the object types.

When a variable points to an object the variable is called a "reference" to an object. I will get back to the difference between primitive variable values and object references in a later text.

The rules and conventions for choosing variable names are covered later in this text.

Assigning a value to a variable in Java follows this pattern:

Here are three concrete examples which assign values to three different variables with different data types

The first line assigns the byte value 127 to the byte variable named myByte . The second line assigns the floating point value 199.99 to the floating point variable named myFloat . The third line assigns the String value (text) this is a text to the String variable named myString .

You can also assign a value to a variable already when it is declared. Here is how that is done:

You can read the value of a Java variable by writing its name anywhere a variable or constant variable can be used in the code. For instance, as the right side of a variable assignment, as parameter to a method call, or inside a arithmetic expression. For instance:

There are a few rules and conventions related to the naming of variables.

The rules are:

Java variable names are case sensitive. The variable name money is not the same as Money or MONEY .
Java variable names must start with a letter, or the $ or _ character.
After the first character in a Java variable name, the name can also contain numbers (in addition to letters, the $, and the _ character).
Variable names cannot be equal to reserved key words in Java. For instance, the words int or for are reserved words in Java. Therefore you cannot name your variables int or for .

Here are a few valid Java variable name examples:

There are also a few Java variable naming conventions. These conventions are not necessary to follow. The compiler to not enforce them. However, many Java developers are used to these naming conventions. Therefore it will be easier for them to read your Java code if you follow them too, and easier for you to read the code of other Java developers if you are used to these naming conventions. The conventions are:

Variable names are written in lowercase. For instance, variable or apple .
If variable names consist of multiple words, each word after the first word has its first letter written in uppercase. For instance, variableName or bigApple .
Even though it is allowed, you do not normally start a Java variable name with $ or _ .
Static final fields (constants) are named in all uppercase, typically using an _ to separate the words in the name. For instance EXCHANGE_RATE or COEFFICIENT .

From Java 10 it is possible to have the Java compiler infer the type of a local variable by looking at what actual type that is assigned to the variable when the variable is declared. This enhancement is restricted to local variables, indexes in for-each loops and local variables declared in for-loops.

To see how the Java local-variable type inference works, here is first an example of a pre Java 10 String variable declaration:

From Java 10 it is no longer necessary to specify the type of the variable when declared, if the type can be inferred from the value assigned to the variable. Here is an example of declaring a variable in Java 10 using local-variable type inference:

Notice the var keyword used in front of the variable name, instead of the type String . The compiler can see from the value assigned that the type of the variable should be String , so you don't have to write it explicitly.

Here are a few additional Java local-variable type inference examples:

Variables in Java

In this lesson, we will explore the concept of variables in Java. A variable is a container that holds values that are used in a Java program. Every variable is assigned a data type, which tells the compiler what type of data the variable can hold.

In this module, we will cover:

Variable declaration: We will discuss how to declare variables in Java, and why it's necessary.

Java data types :

We will delve into the different data types available in Java, such as

integers (int),

floating-point numbers (float and double),

characters (char),

and booleans (boolean).

Assigning values to variables :

We will explain how to assign values to declared variables and how you can change these values later in your program.

Understanding and using operators :

We will discuss how to use basic operators in Java, such as

addition (+),

subtraction (-),

multiplication (*),

division (/),

and the modulus operator (%) ,

to manipulate the values in variables.

Creating your own variables :

At the end of the lesson, we'll put what you've learned into practice and guide you through creating your own variables and using them in simple mathematical operations.

Remember, variables are one of the foundational concepts of programming, so gaining a strong understanding of them is crucial as you continue your Java learning journey.

Java Variables Example

In this example, we're going to create some variables, assign values to them, and perform a simple operation.

When you run this program, it will print:

The sum of x and y is: 30.

Understanding the Code:

int x; and int y;:

Here we're declaring two integer variables, x and y. At this point, they don't have a value yet.

x = 10; and y = 20;:

Here we're assigning the values 10 and 20 to the variables x and y, respectively.

int result = x + y;:

Here we're declaring a new integer variable called result and assigning it the sum of x and y.

System.out.println("The sum of x and y is: " + result);: Finally, we're printing the result to the console.

Exercise for you

Variable Declaration and Assigning Values:

Declare variables of each data type mentioned (int, float, double, char, boolean) and assign them values. Then, print each of the variables.

int myInteger = 10; float myFloat = 20.5f; double myDouble = 30.25; char myChar = 'A'; boolean myBoolean = true;

System.out.println(myInteger); System.out.println(myFloat); System.out.println(myDouble); System.out.println(myChar); System.out.println(myBoolean);

Changing Values of Variables:

Change the values of the variables you have declared above and print them again.

myInteger = 15; myFloat = 25.5f; myDouble = 35.25; myChar = 'B'; myBoolean = false;

Basic Operations with Variable s:

Use the basic operators to perform mathematical operations using the variables you have declared. Print the results.

int num1 = 10; int num2 = 5;

int sum = num1 + num2; int difference = num1 - num2; int product = num1 * num2; double quotient = (double) num1 / num2; int remainder = num1 % num2;

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);

Remember, these exercises are just to get you started. You should try to create more complex programs using these concepts to deepen your understanding. Happy coding!

Java Operators and Type Conversion

In this lesson, we're going to explore Java operators and learn about type conversion. Operators allow us to perform different operations on variables such as arithmetic, comparison, logical, and more. Type conversion, also known as type casting, is a way of changing an entity from one data type to another.

Here's what we will cover:

Arithmetic Operators : We will start with the basic arithmetic operators like addition (+), subtraction (-), multiplication (*), division (/), and modulus (%).

Comparison Operators : Next, we'll learn about comparison operators. These include equal to (==), not equal to (!=), greater than (>), less than (<), greater than or equal to (>=), and less than or equal to (<=).

Logical Operators : We'll delve into logical operators like AND (&&), OR (||), and NOT (!) and learn how they can be used to form more complex boolean expressions.

Type Conversion : Lastly, we'll discuss type conversion in Java. We'll learn the difference between implicit and explicit conversion, and when to use each.

By the end of this lesson, you should have a good understanding of how to use operators in Java and how to convert between different data types

Java Operators and Type Conversion Example

In this example, we're going to create some variables and perform operations using Java operators. We'll also demonstrate type conversion.

------------------------------------------------------------------------------

public class OperatorsExample { public static void main(String[] args) { // Declare two integer variables int x = 10; int y = 20; // Use of arithmetic operator int sum = x + y; System.out.println("The sum of x and y is: " + sum); // Use of comparison operator boolean compare = x > y; System.out.println("Is x greater than y? " + compare); // Use of logical operator boolean logical = (x > 5) && (y > 15); System.out.println("Is x greater than 5 AND y greater than 15? " + logical); // Type conversion double z = (double) x; System.out.println("The value of x as a double is: " + z); } }

When you run this program, it will output:

The sum of x and y is: 30 Is x greater than y? false Is x greater than 5 AND y greater than 15? true The value of x as a double is: 10.0

Understanding the Code :

The first section declares two integer variables, x and y, and assigns them the values 10 and 20 , respectively.
We then use the arithmetic + operator to calculate the sum of x and y .
The > comparison operator is used to check if x is greater than y .
We then use the logical && operator to check if both x > 5 and y > 15 are true.
Finally, we convert the integer x to a double using type casting (double) x .

clear sunny desert yellow sand with celestial snow bridge

1.7 Java | Assignment Statements & Expressions

An assignment statement designates a value for a variable. An assignment statement can be used as an expression in Java.

After a variable is declared, you can assign a value to it by using an assignment statement . In Java, the equal sign = is used as the assignment operator . The syntax for assignment statements is as follows:

An expression represents a computation involving values, variables, and operators that, when taking them together, evaluates to a value. For example, consider the following code:

You can use a variable in an expression. A variable can also be used on both sides of the = operator. For example:

In the above assignment statement, the result of x + 1 is assigned to the variable x . Let’s say that x is 1 before the statement is executed, and so becomes 2 after the statement execution.

To assign a value to a variable, you must place the variable name to the left of the assignment operator. Thus the following statement is wrong:

Note that the math equation x = 2 * x + 1 ≠ the Java expression x = 2 * x + 1

Java Assignment Statement vs Assignment Expression

Which is equivalent to:

And this statement

is equivalent to:

Note: The data type of a variable on the left must be compatible with the data type of a value on the right. For example, int x = 1.0 would be illegal, because the data type of x is int (integer) and does not accept the double value 1.0 without Type Casting .

◄◄◄BACK | NEXT►►►

What's Your Opinion? Cancel reply

Enhance your Brain

Subscribe to Receive Free Bio Hacking, Nootropic, and Health Information

HTML for Simple Website Customization My Personal Web Customization Personal Insights

DISCLAIMER | Sitemap | ◘

HTML for Simple Website Customization My Personal Web Customization Personal Insights SEO Checklist Publishing Checklist My Tools

01 Career Opportunities

Java Developer Salary
Top 50 Java Interview Questions and Answers

02 Beginner

Best Java Developer Roadmap 2024
Hierarchical Inheritance in Java
Arithmetic operators in Java
Unary operator in Java
Ternary Operator in Java
Relational operators in Java

Assignment operator in Java

Logical operators in Java
Single Inheritance in Java
Primitive Data Types in Java
Multiple Inheritance in Java
Hybrid Inheritance in Java
Parameterized Constructor in Java
Constructor Chaining in Java
Constructor Overloading in Java
What are Copy Constructors In Java? Explore Types,Examples & Use
What is a Bitwise Operator in Java? Type, Example and More
Top 10 Reasons to know why Java is Important?
What is Java? A Beginners Guide to Java
Differences between JDK, JRE, and JVM: Java Toolkit
Variables in Java: Local, Instance and Static Variables
Data Types in Java - Primitive and Non-Primitive Data Types
Conditional Statements in Java: If, If-Else and Switch Statement
What are Operators in Java - Types of Operators in Java ( With Examples )
Java VS Python
Looping Statements in Java - For, While, Do-While Loop in Java
Jump Statements in JAVA - Types of Statements in JAVA (With Examples)
Java Arrays: Single Dimensional and Multi-Dimensional Arrays
What is String in Java - Java String Types and Methods (With Examples)

03 Intermediate

OOPs Concepts in Java: Encapsulation, Abstraction, Inheritance, Polymorphism
Access Modifiers in Java: Default, Private, Public, Protected
What is Class in Java? - Objects and Classes in Java {Explained}
Constructors in Java: Types of Constructors with Examples
Polymorphism in Java: Compile time and Runtime Polymorphism
Abstraction in Java: Concepts, Examples, and Usage
What is Inheritance in Java: Types of Inheritance in Java
Exception handling in Java: Try, Catch, Finally, Throw and Throws

04 Training Programs

Java Programming Course
C++ Programming Course
MERN: Full-Stack Web Developer Certification Training
Data Structures and Algorithms Training
Assignment Operator In Ja..

Java Programming For Beginners Free Course

Assignment operators in java: an overview.

We already discussed the Types of Operators in the previous tutorial Java. In this Java tutorial , we will delve into the different types of assignment operators in Java, and their syntax, and provide examples for better understanding. Because Java is a flexible and widely used programming language. Assignment operators play a crucial role in manipulating and assigning values to variables. To further enhance your understanding and application of Java assignment operator's concepts, consider enrolling in the best Java Certification Course .

What are the Assignment Operators in Java?

Assignment operators in Java are used to assign values to variables . They are classified into two main types: simple assignment operator and compound assignment operator.

The general syntax for a simple assignment statement is:

And for a compound assignment statement:

Read More - Advanced Java Interview Questions

Types of Assignment Operators in Java

Simple Assignment Operator: The Simple Assignment Operator is used with the "=" sign, where the operand is on the left side and the value is on the right. The right-side value must be of the same data type as that defined on the left side.
Compound Assignment Operator: Compound assignment operators combine arithmetic operations with assignments. They provide a concise way to perform an operation and assign the result to the variable in one step. The Compound Operator is utilized when +,-,*, and / are used in conjunction with the = operator.

1. Simple Assignment Operator (=):

The equal sign (=) is the basic assignment operator in Java. It is used to assign the value on the right-hand side to the variable on the left-hand side.

Explanation

2. addition assignment operator (+=) :, 3. subtraction operator (-=):, 4. multiplication operator (*=):.

5. Division Operator (/=):

6. modulus assignment operator (%=):, example of assignment operator in java.

Let's look at a few examples in our Java Playground to illustrate the usage of assignment operators in Java:

Unary Operator in Java
Arithmetic Operators in Java
Relational Operators in Java
Logical Operators in Java

Q1. Can I use multiple assignment operators in a single statement?

Q2. are there any other compound assignment operators in java, q3. how many types of assignment operators.

1. (=) operator
1. (+=) operator
2. (-=) operator
3. (*=) operator
4. (/=) operator
5. (%=) operator

About Author

Upcoming Master Classes

We use cookies to make interactions with our websites and services easy and meaningful. Please read our Privacy Policy for more details.

Enterprise Java
Web-based Java
Data & Java
Project Management
Visual Basic
Ruby / Rails
Java Mobile
Architecture & Design
Open Source
Web Services

Developer.com content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More .

Java provides many types of operators to perform a variety of calculations and functions, such as logical , arithmetic , relational , and others. With so many operators to choose from, it helps to group them based on the type of functionality they provide. This programming tutorial will focus on Java’s numerous a ssignment operators.

Before we begin, however, you may want to bookmark our other tutorials on Java operators, which include:

Arithmetic Operators
Comparison Operators
Conditional Operators
Logical Operators
Bitwise and Shift Operators

Assignment Operators in Java

As the name conveys, assignment operators are used to assign values to a variable using the following syntax:

The left side operand of the assignment operator must be a variable, whereas the right side operand of the assignment operator may be a literal value or another variable. Moreover, the value or variable on the right side must be of the same data type of the operand on the left side. Otherwise, the compiler will raise an error. Assignment operators have a right to left associativity in that the value given on the right-hand side of the operator is assigned to the variable on the left. Therefore, the right-hand side variable must be declared before assignment.

You can learn more about variables in our programming tutorial: Working with Java Variables .

Types of Assignment Operators in Java

Java assignment operators are classified into two types: simple and compound .

The Simple assignment operator is the equals ( = ) sign, which is the most straightforward of the bunch. It simply assigns the value or variable on the right to the variable on the left.

Compound operators are comprised of both an arithmetic, bitwise, or shift operator in addition to the equals ( = ) sign.

Equals Operator (=) Java Example

First, let’s learn to use the one-and-only simple assignment operator – the Equals ( = ) operator – with the help of a Java program. It includes two assignments: a literal value to num1 and the num1 variable to num2 , after which both are printed to the console to show that the values have been assigned to the numbers:

The += Operator Java Example

A compound of the + and = operators, the += adds the current value of the variable on the left to the value on the right before assigning the result to the operand on the left. Here is some sample code to demonstrate how to use the += operator in Java:

The -= Operator Java Example

Made up of the – and = operators, the -= first subtracts the variable’s value on the right from the current value of the variable on the left before assigning the result to the operand on the left. We can see it at work below in the following code example showing how to decrement in Java using the -= operator:

The *= Operator Java Example

This Java operator is comprised of the * and = operators. It operates by multiplying the current value of the variable on the left to the value on the right and then assigning the result to the operand on the left. Here’s a program that shows the *= operator in action:

The /= Operator Java Example

A combination of the / and = operators, the /= Operator divides the current value of the variable on the left by the value on the right and then assigns the quotient to the operand on the left. Here is some example code showing how to use the /= operator in Java:

%= Operator Java Example

The %= operator includes both the % and = operators. As seen in the program below, it divides the current value of the variable on the left by the value on the right and then assigns the remainder to the operand on the left:

Compound Bitwise and Shift Operators in Java

The Bitwise and Shift Operators that we just recently covered can also be utilized in compound form as seen in the list below:

&= – Compound bitwise Assignment operator.
^= – Compound bitwise ^ assignment operator.
>>= – Compound right shift assignment operator.
>>>= – Compound right shift filled 0 assignment operator.
<<= – Compound left shift assignment operator.

The following program demonstrates the working of all the Compound Bitwise and Shift Operators :

Final Thoughts on Java Assignment Operators

This programming tutorial presented an overview of Java’s simple and compound assignment Operators. An essential building block to any programming language, developers would be unable to store any data in their programs without them. Though not quite as indispensable as the equals operator, compound operators are great time savers, allowing you to perform arithmetic and bitwise operations and assignment in a single line of code.

Read more Java programming tutorials and guides to software development .

Get the Free Newsletter!

Subscribe to Developer Insider for top news, trends & analysis

Latest Posts

What is the role of a project manager in software development, how to use optional in java, overview of the jad methodology, microsoft project tips and tricks, how to become a project manager in 2023, related stories, understanding types of thread synchronization errors in java, understanding memory consistency in java threads.