Java's basic assignment operator is a single equals-to (=) sign that assigns the right-hand side value to the left-hand side operand. On left side of the assignment operator there must be a variable that can hold the value assigned to it. Assignment operator operates on both primitive and reference types. It has the following syntax:
var = expression;Note that the type of var must be compatible with the type of expression.
Chaining of assignment operator is also possible where we can create a chain of assignments in order to assign a single value to multiple variables. For example,
int x, y, z; x = y = z = 100; // set x, y, and z to 100
The above piece of code sets the variables x, y, and z to 100 using a single statement. This works because the
= is an operator that yields the value of the right-hand expression. Thus, the value of
z = 100 is 100, which is then assigned to
y, which in turn is assigned to
x. Using a "chain of assignment" is an easy way to set a group of variables to a common value.
A variable referring to an object is a reference variable not an object. We can assign a newly created object to an object reference variable as follows:
Student st1 = new Student();
The above line of code performs three tasks
st1, of type
Studentobject on the heap.
Studentobject to the reference variable
We can also assign
null to an object reference variable, which simply means the variable is not referring to any object:
Student st2 = null;
Above line of code creates space for the
Student reference variable
st2 but doesn't create an actual
Note that, we can also use a reference variable to refer to any object that is a subclass of the declared reference variable type.
Primitive variables can be assigned either by using a literal or the result of an expression. For example,
int x = 130; // literal assignment int y = x + 2; // assignment with an expression including a literal int z = x * y; // assignment with an expression
The most important point that we should keep in mind, while assigning primitive types is if we are going to assign a bigger value to a smaller type, we have to typecast it properly. In Above piece of code the literal integer 130 is implicitly an
int but it is acceptable here because the variable
x is of type
int. It gets weird if you try 130 to assign to a
byte variable. For example, The below piece of code will not compile because literal 130 is implicitly an integer and it does not fit into a smaller type
byte x. Likewise,
byte c = a + b will also not compile because the result of an expression involving anything int-sized or smaller is always an
byte x = 130; // error: possible loss of precision byte a = 2; byte b = 3; byte c = a + b; // error: possible loss of precision
Casting lets us convert primitive values from one type to another (specially from bigger to smaller types). Casts can be implicit or explicit. An implicit cast means we don't have to write code for the cast; the conversion happens automatically. Typically, an implicit cast happens when we do a widening conversion. In other words, putting a smaller thing (say, a
byte) into a bigger container (like an
int). Remember those "possible loss of precision" compiler errors we saw during assignments. Those happened when we tried to put a larger thing (say, an
int) into a smaller container (like a
byte). The large-value-into-small-container conversion is referred to as narrowing and requires an explicit cast, where we tell the compiler that we are aware of the danger and accept full responsibility.
As a final note on casting, it is very important to note that the shorthand assignment operators let us perform addition, subtraction, multiplication or division without putting in an explicit cast. In fact, +=, -=, *=, and /= will all put in an implicit cast. Below is an example:
byte b = 3; b += 7; // No problem - adds 7 to b (result is 10) // and is equivalent to byte c = 3; c = (byte) (c + 7); // Won't compile without the cast, since c + 7 results in an int
In addition to the basic assignment operator, Java also defines 12 shorthand assignment operators that combine assignment with the 5 arithmetic operators (
%=) and the 6 bitwise and shift operators (
>>>=). For example, the
+= operator reads the value of the left variable, adds the value of the right operand to it, stores the sum back into the left variable as a side effect, and returns the sum as the value of the expression. Thus, the expression
x += 2 is almost the same
x = x + 2.
The difference between these two expressions is that when we use the
+= operator, the left operand is evaluated only once. This makes a difference when that operand has a side effect. Consider the following two expressions
a[i++] += 2; and
a[i++] = a[i++] + 2;, which are not equivalent:
In this tutorial we discussed basic and shorthand (compound) assignment operators of Java. Hope you have enjoyed reading this tutorial. Please do write us if you have any suggestion/comment or come across any error on this page. Thanks for reading!
The 70-storey tower would be 90% wood and have trees and other foliage on every level.Probe after 'drone made helicopter crash'Posted on Monday February 19, 2018
Investigations are launched after a helicopter reportedly crashed after swerving to avoid a consumer drone.Dark web paedophile Matthew Falder jailed for 32 yearsPosted on Monday February 19, 2018
Matthew Falder blackmailed victims into sending sexual images that he then shared on the dark web.Courtesy BBC News