Expressions, Statements, and Blocks

Home /

Table of Contents

Statements, blocks, and expressions are the three main building elements of the Java language. An expression is a combination of operands and operators that evaluates to a value. Expressions can be used to assign values to variables, perform arithmetic operations, and compare values. A statement is a complete unit of code that performs a specific action, such as declaring a variable or executing a loop. Statements can be grouped together into blocks, which are enclosed in curly braces and treated as a single unit of code. Blocks are commonly used in control structures like if-else statements and loops to group multiple statements together and define their scope. Understanding the concepts of expressions, statements, and blocks is essential for writing effective Java code.

In our previous discussions, we mentioned expressions and statements. But we did not have an elaborate discussion on them. You were not ready as you had to understand variables and operators before learning about expressions, statements, and blocks.

Expressions : Expressions may be built using operators, which compute values.
Statements  : The core components of statements are the expressions.
Block       :  We may group statements into groups - these groups are called blocks.


In simple words, the combination of operators, constants, variables, and method invocation may be regarded as an expression. An expression computes a single value. To produce a value, an expression may be constructed using one or more operands and zero or more operators.

ukl28TDt6Zni6 m177dTdDWLv38DFJVKunQexxQryibX kpHDrH4 gyNfoVwCmdPgA2 OUQGgC et5o0wNuflTfelsCaCv1ekWBqa4 - Expressions, Statements, and Blocks

You have already seen expressions. In the following snippets, expressions are illustrated in bold:

int value = 20;
System.out.println("Value is:  " + value);
int result = 11 + 21; // result is now 32
if (value1 == value2)
System.out.println("value1 == value2");

An expression gives a value, we refer to this as a returned value. The data type of the return value of the expression depends on the elements used in the expression. The expression value = 20 returns an int because the assignment operator returns a value of the same data type as its left-hand operand; in this case, the value is an int. As you can see from the other expressions, an expression can return other types of values as well, such as a boolean or String.

Expressions can be categorized into the following categories:

Constant Expression

An expression containing only constant values. A constant value doesn’t change.


12 + 7 / 6.0

Integral Expression

An integer expression produces an integer result after implementing all the automatic and explicit type conversions.


u * v
u + int(5.0)

where u and v are integer variables

Relational Expression

A relational expression relates two operands and produces a boolean-type result.


u <= v
u + v > 2

Logical/Conditional Expression

A logical/conditional expression combines two or more relational expressions and produces a boolean-type result.


u > v && u == 10
u == 10 || v == 9

Compound Expression

We may also use combinations of the above expressions. Such expressions are known as compound expressions. Java language allows you to construct compound expressions. But there is a catch. The data of the various smaller expressions must match.


1 * 2 *4

This is a multiplication expression. The order in which this expression is evaluated is not important. The result of the multiplication is independent of order: the result is always the same. It does not matter in which order you apply the multiplications. However, this is not true of all expressions.

x + y / 100  // ambiguous
If we do the addition operation first and the division operation second then we get a different result from if we do the division operation first and the addition operation second.

Exactly how an expression will be evaluated can be specified using balanced parenthesis: ( and ).

(x + y) / 100  // unambiguous, recommended
Here we only have one result as always the addition operation is done first and the division operation second.

What happens if we do not explicitly indicate the operations to be performed? Then the order is determined by the precedence assigned to the operators in use within the expression. First, the operators with higher precedence get evaluated.


x + y / 100
x + (y/100) unambiguous, recommended

These two expressions are equivalent as the division operator has higher precedence than the addition operator.

The practice of writing compound expressions explicitly and indicating with parentheses which operators should be evaluated first makes code easier to read and maintain.


We can compare statements with sentences in natural languages. They are roughly equivalent. A complete unit of execution is formed by a statement. The following types of expressions can be made into a statement by terminating the expression with a semicolon (;).

  • Assignment expressions
  • Any use of ++ or —
  • Method invocations
  • Object creation expressions

Such statements are called expression statements. Here are some examples of expression statements.

// assignment statement
valueOne = 23;
// increment statement
// method invocation statement
System.out.println("Hello World!");
// object creation statement
Object object = new Object();

There are two other kinds of statements: declaration statements and control flow statements. We declare a variable using a declaration statement. We have already seen many examples of declaration examples.

// declaration statement
double valueOne = 23;

The order in which statements get executed is regulated by control flow statements. We will not discuss them here. You’ll learn about control flow statements in a later tutorial.


In Java, it is possible to link two or more statements together. This is called a block of code or code block. By surroundings the statements in the block with opening and closing curly braces we can create a block of code. Once we create a block of code or code block, the statements essentially form one logical unit, which we may use anywhere that a single statement may. A block is essentially a group of zero or more statements between curly braces and can be used anywhere a single statement is allowed. For example, the general form of the if using the blocks of code is:

SR10QU dkti2adz323Q5x rFwuCoOOMryWZPjmoKoXwqca959m9DIx4PAQJPutYIxncIvgrl771BCggVQcsZZABxkBxpR2wZXt5ltaMSi mXe5i5JmNWrp9Oq05SOqY9oRykAkW5QVl EtvROA4 - Expressions, Statements, and Blocks

All the statements in the block of codes associated with the if will be executed if the expression evaluates to true. If the expression evaluates to false then the blocks of code associated with else will be executed. Keep in mind that the else is optional and need not be present. Moreover, it is not necessary for both the if and else statements to be blocks of code. 

The following BlockDemo program demonstrates the use of blocks:

public class BlockDemo {
     public static void main(String[] args) {
          boolean someCondition = true;
          if (someCondition) { // begin block 1
               System.out.println("someCondition is true.");
               System.out.println("So the block associated with if will be executed!");
          } // end block one
          else { // begin block 2
               System.out.println("someCondition is false.");
               System.out.println("So the block associated with else will be executed!");
          } // end block 2


someCondition is true.
So the block associated with if will be executed

Remember that a code block represents one individual logical unit. What this means is that under no circumstances could one of the System.out.println() statements in this code fragments execute without the other also executing, may that be associated with the if block or the else block.

One last thing to note - Notice that the statements that appear within the block of codes are intended. Although Java does not care about the indention, it is common practice to indent one level at the start of a block. Indenting makes the code more readable. Also, the placement of the curly braces are arbitrary. 

In Java, as you will see, you can use a block of code anywhere you can use a single statement.

Share The Tutorial With Your Friends

Check Our Ebook for This Online Course

Advanced topics are covered in this ebook with many practical examples.

Other Recommended Article