Consider Java expressions with operators

June 12, 2024

1

On this tutorial, you’ll learn to write expressions on your Java packages. In lots of circumstances, you may use operators to jot down your Java expressions, and there are lots of operator varieties to know use. I am going to briefly introduce Java’s operator varieties, together with the additive, bitwise, logical, conditional, shift, and equality varieties and their operands. You will additionally study operator overloading and operator priority, and you will see an illustration of primitive-type conversion. I am going to conclude with a small Java program that you should utilize to follow primitive-type conversions by yourself.

What you may be taught on this Java tutorial

What’s a Java expression?
Methods to write easy expressions
Methods to write compound expressions
About Java operators and operands
All of the operator varieties in Java, with examples
About operator priority and associativity
Methods to work with primitive-type conversions

obtain

Obtain the supply code for instance purposes on this tutorial. Created by Jeff Friesen.

What’s a Java expression?

Expressions are mixtures of literals, methodology calls, variable names, and operators. Java purposes consider expressions. Evaluating an expression produces a brand new worth that may be saved in a variable, used to decide, and extra.

Methods to write easy expressions

A easy expression is a literal, variable title, or methodology name. No operators are concerned. Listed here are some examples of easy expressions:


52                         // integer literal
age                        // variable title
System.out.println("ABC"); // methodology name
"Java"                     // string literal
98.6D                      // double precision floating-point literal
89L                        // lengthy integer literal

A easy expression has a sort, which is both a primitive sort or a reference sort. In these examples, 52 is a 32-bit integer (int); System.out.println("ABC"); is void (void) as a result of it returns no worth; "Java" is a string (String); 98.6D is a 64-bit double-precision floating-point worth (double); and 89L is a 64-bit lengthy integer (lengthy). We do not know age‘s sort.

Use jshell to experiment

You may simply check out these and different easy expressions utilizing jshell. For instance, enter 52 on the jshell> immediate and you will obtain one thing like the next output:

$1 ==> 52

$1 is the title of a scratch variable that jshell creates to retailer 52. (Scratch variables are created at any time when literals are entered.) Execute System.out.println($1) and you will see 52 because the output.

You may run jshell with the -v command-line argument (jshell -v) to generate verbose suggestions. On this case, getting into 52 would consequence within the following message, revealing that scratch variable $1 has int (32-bit integer) sort:

|  created scratch variable $1 : int

Subsequent, strive getting into age. On this case, you may in all probability obtain an error message that the image was not discovered. The Java Shell assumes that age is a variable, nevertheless it does not know its sort. You would need to embrace a kind; for instance, see what occurs in the event you enter int age.

Methods to write compound expressions

A compound expression consists of a number of easy expressions built-in into a bigger expression through an operator, which is a sequence of directions symbolically represented in supply code. The operator transforms its expression operand(s) into one other worth. For instance, in 6 * 5, the multiplication operator (*) transforms operands 6 and 5 into 30.

Compound expressions could be mixed into bigger expressions. For instance, 6 * 5 + 10 presents compound expression 6 * 5 and a compound expression consisting of their product, addition operator +, and the quantity 10. The order of analysis (multiply first after which add) is dictated by Java’s rule of priority, which we’ll get to shortly.

About Java operators and operands

Java’s operators are labeled by their variety of operands:

A unary operator has one operand, for instance, unary minus (e.g., -5).
A binary operator has two operands, examples are multiplication and addition.
A ternary operator has three operands; an instance is the conditional operator (?:).

Java’s operators are additionally labeled by place:

A prefix operator is a unary operator that precedes its operand (e.g., -5).
A postfix operator is a unary operator that follows its operand (e.g., age++; — add 1 to age‘s numeric worth).
An infix operator is a binary or ternary operator between the operator’s operands (e.g., age + 5).

One other jshell instance

I am going to introduce extra operators within the following sections, the place I current examples within the type of purposes. You could possibly additionally check out these operators with jshell, like so:

jshell> 6 + 2
$1 ==> 8

jshell> 7 * $1
$2 ==> 56

On this case, we first enter the expression 6 + 2, which jshell evaluates, assigning the ensuing 8 to scratch variable $1. Subsequent, we multiply $1 by 7, which shops 56 in scratch variable $2. This instance demonstrates that you should utilize scratch variables in Java expressions.

Operator varieties in Java

Subsequent, we’ll tour all of the operator varieties in Java. After introducing every operator sort, I am going to current an instance that exhibits you the way it’s utilized in Java expressions.

Additive operators

The additive operators improve or lower a numeric worth by means of addition and subtraction. Additive operators embrace addition (+), subtraction (-), postdecrement (--), postincrement (++), predecrement (--), and preincrement (++). String concatenation (+) can also be thought-about to be additive. This is a proper definition for every of those operators:

Addition: Given operand1 + operand2, the place every operand should be of character or numeric sort, add operand2 to operand1 and return the sum. Instance: 4 + 6.
Subtraction: Given operand1 - operand2, the place every operand should be of character or numeric sort, subtract operand2 from operand1 and return the distinction. Instance: 4 - 6.
Postdecrement: Given variable--, the place variable should be of character or numeric sort, subtract 1 from variable‘s worth (storing the end in variable) and return the unique worth. Instance: x--;.
Postincrement: Given variable++, the place variable should be of character or numeric sort, add 1 to variable‘s worth (storing the end in variable) and return the unique worth. Instance: x++;.
Predecrement: Given --variable, the place variable should be of character or numeric sort, subtract 1 from its worth, retailer the end in variable, and return the brand new decremented worth. Instance: --x;.
Preincrement: Given ++variable, the place variable should be of character or numeric sort, add 1 to its worth, retailer the end in variable, and return the brand new incremented worth. Instance: ++x;.
String concatenation: Given operand1 + operand2, the place at the very least one operand is of String sort, append operand2‘s string illustration to operand1‘s string illustration and return the consequence. Instance: "A" + "B".

The addition, subtraction, postdecrement, postincrement, predecrement, and preincrement operators can generate values that overflow the boundaries of the consequence sort. For instance, including two giant optimistic 64-bit integer values can produce a worth that can not be represented in 64 bits. The ensuing overflow shouldn’t be detected or reported by Java’s additive operators.

Instance software: Additive operators

Itemizing 1 presents a small software for enjoying with Java’s additive operators.

Itemizing 1. Additive operators in Java (AddOp.java)

class AddOp
{
   public static void primary(String[] args)
   {
      System.out.println(125 + 463);
      System.out.println(2.0 - 6.3);
      int age = 65;
      System.out.println(age);
      System.out.println(age--);
      System.out.println(age++);
      System.out.println(--age);
      System.out.println(++age);
      System.out.println("A" + "B");
   }
}

See Elementary Java language options for an introduction to utilizing the JDK’s javac instrument to compile Java supply code and the java instrument to run the ensuing software. Execute the next command to compile Itemizing 1:

javac AddOp.java

Assuming profitable compilation, you need to observe an AddOp.class file within the present listing. Execute the next command to run it:

java AddOp

AddOp responds by producing the next output:

Finding out this output provides perception into the postincrement, postdecrement, preincrement, and predecrement operators. For postincrement/postdecrement, age‘s present worth is output earlier than the increment/decrement operation. For preincrement/predecrement, the operation is carried out and its result’s saved in age, after which age‘s new worth is output.

Array index operator

The array index operator ([]) accesses an array factor by offering the factor’s index (place). This operator is positioned after the array variable’s title, as in grades[0] (entry the primary factor within the array assigned to grades; the primary factor is saved at index 0). This is a proper definition:

Given variable[index], the place index should be of integer (int) sort, learn a worth from or retailer a worth into variable‘s storage factor at location index. Instance: temperatures[1]

The worth handed to index is a 32-bit integer that’s both 0 or a optimistic worth ranging to 1 lower than the array’s size, which is indicated by appending .size to the title of the array. For instance, grades.size returns the variety of components within the array assigned to grades.

Instance software: Array index operator

Itemizing 2 presents the supply code to an instance software that permits you to play with the array index operator.

Itemizing 2. Array index operator in Java (ArrayIndexOp.java)

class ArrayIndexOp
{
   public static void primary(String[] args)
   {
      int[] grades = { 89, 90, 68, 73, 79 };
      System.out.println(grades[1]);
      grades[1] = 91;
      System.out.println(grades[1]);
      int index = 4;
      System.out.println(grades[index]);
      System.out.println(grades['C' - 'A']);
//      System.out.println(grades[1D]);
   }
}

Itemizing 2 is considerably extra attention-grabbing than Itemizing 1. After making a five-element, one-dimensional array of integers (through an array initializer) and assigning the array’s reference to grades, primary() proceeds to entry varied components. Two gadgets are of particular curiosity:

The array index operator’s index should finally be a 32-bit integer (0 or a optimistic worth). You may specify the title of an integer variable (e.g., index), which incorporates the index worth, because the index.
You may specify a calculation involving character literals. (Later on this tutorial I am going to introduce sort conversions, and you will uncover why 'C' - 'A' produces an integer (2), which serves as a legitimate index.)

The ultimate instance, which passes 1D as an index to the array index operator, is commented out as a result of it won’t compile. If you happen to uncomment the road and try to compile Itemizing 2, you’ll obtain an error message about incompatible varieties: “potential lossy conversion from double to int..”

Compile Itemizing 2 (javac ArrayIndexOp.java) and run the appliance (java ArrayIndexOp). You must observe the next output:

Project operators

The task operator (=) assigns an expression’s worth to a variable (e.g., i = 6;), together with an array factor (e.g., x[0] = 15;). The expression and variable should be task appropriate, that means their varieties should agree. For instance, you can not assign a string literal to an integer variable. I am going to clarify extra about this once we talk about sort conversions.

Supply hyperlink