Elementary Overview

Expressions produce results, statements perform complete units of execution, and blocks group statements together. These three ideas are the basic structural pieces of Java programs. Once variables and primitive types are understood, the next step is learning how values are combined into expressions and how those expressions become executable statements inside braces.

This lesson follows OSJava.002: Primitive Types and Variables. That lesson introduced the values Java stores. OSJava.003 shows how Java uses those values to build executable program structure.

Learning Objectives

• Define an expression in Java.
• Explain how an expression can produce a value.
• Distinguish an expression from a statement.
• Recognize declaration statements, expression statements, and control-flow statements.
• Explain why semicolons terminate many Java statements.
• Use braces to create a block.
• Explain how a block creates a local scope.
• Use parentheses to make compound expressions clearer.
• Understand Java’s left-to-right operand evaluation and operator precedence at a beginner level.

What Is an Expression?

An expression is a piece of Java source code that is evaluated and produces a result, denotes a variable, or performs a computation with a result. Expressions can contain literals, variables, operators, method calls, object creation, or smaller expressions.

Examples:
42
temperature + 5
price * quantity
online && authorized
name.length()
new Object()

The current Dev.java expressions, statements, and blocks guide describes expressions as combinations of variables, operators, and method invocations that evaluate to a value. The Java Language Specification gives the formal rules for how expressions are evaluated.

Expressions Can Be Combined

Small expressions can become part of larger expressions. Java uses operator precedence, parentheses, and explicit evaluation rules to determine how a compound expression is interpreted.

Example:
int total = 10 + 5 * 2;

Multiplication has higher precedence than addition, so the multiplication is grouped first and the result is 20. Writing parentheses makes the programmer’s intent easier to read:

Clearer version:
int total = 10 + (5 * 2);

Precedence Is Not the Same as Operand Evaluation Order

Operator precedence determines how an expression is grouped. Java separately specifies that operands are evaluated from left to right. These concepts matter when expressions contain method calls, increments, assignments, or other side effects.

Example:
boolean result = a == 10 || b == 20 && c == 30;

The logical AND portion groups more tightly than the logical OR portion, but Java still begins by evaluating the left side of the OR expression. If that left side is already true, short-circuit evaluation can prevent the right side from running at all.

Evaluation order of Java operators && vs ||
byu/HaNguyenHuy inlearnjava

What Is a Statement?

A statement is a complete unit of execution. Statements tell the program to declare something, perform an action, change control flow, return from a method, throw an exception, or carry out another defined step.

Declaration statement:
int count = 10;

Assignment expression used as a statement:
count = 20;

Method invocation used as a statement:
System.out.println(count);

Many Java statements end with a semicolon. The semicolon marks the end of that statement. Braces, control-flow structures, method declarations, class declarations, and other language constructs have different grammatical rules and should not be reduced to the simple rule “every line ends with a semicolon.”

Only Certain Expressions Can Stand Alone as Statements

Java does not permit every possible value-producing expression to appear by itself as a statement. The language specifically permits useful expression-statement forms such as assignments, increments and decrements, method invocations, and object creation expressions.

Valid expression statements:
count = 5;
count++;
System.out.println(count);
new Object();

A bare arithmetic expression such as 10 + 20; is not a useful Java statement form and is rejected by the compiler. The language expects executable statement expressions rather than arbitrary discarded calculations.

What Is a Block?

A block is a group of zero or more statements enclosed in balanced braces. A block can appear anywhere the language allows a block and is commonly used for method bodies, loops, conditionals, synchronized regions, classes, and nested scopes.

Example:
{
    int voltage = 208;
    int current = 30;
    int power = voltage * current;
    System.out.println(power);
}

The braces group the statements into one block. A block also creates a local scope for variables declared inside it.

Blocks Create Scope

A local variable declared inside a block is normally accessible only from its declaration to the end of the scope that contains it. Once execution and source structure leave that scope, code outside the block cannot refer to the variable by name.

Example:
public class ScopeDemo {
    public static void main(String[] args) {
        int outside = 10;

        {
            int inside = 20;
            System.out.println(outside + inside);
        }

        System.out.println(outside);
    }
}

The variable outside remains available after the nested block. The variable inside does not. This local-scope rule becomes essential when methods, loops, conditionals, and object-oriented structures get larger.

A Full Example

Example program:
public class StructureDemo {
    public static void main(String[] args) {
        int miners = 100;
        int wattsPerMiner = 3500;
        int totalWatts = miners * wattsPerMiner;

        System.out.println(totalWatts);
    }
}

Inside this short program, 100 and 3500 are literals, miners * wattsPerMiner is an expression, int totalWatts = miners * wattsPerMiner; is a declaration statement containing an expression, System.out.println(totalWatts); is a method-invocation statement, and the braces surrounding main form a block.

Common Beginner Mistakes

• Confusing a value with a statement: 42 is an expression, not a complete executable statement.
• Adding semicolons after everything: some constructs use braces or other grammar instead.
• Forgetting a semicolon where one is required: declaration and many expression statements need one.
• Assuming line breaks define statements: Java grammar does not use ordinary line breaks as statement terminators.
• Ignoring scope: a variable declared inside a nested block may not exist by name outside that block.
• Writing dense compound expressions: parentheses often make intent clearer even when precedence already defines the result.

Mini Lab

1. Create a file named StructureLab.java.
2. Declare two integer variables and create a third variable from an arithmetic expression using them.
3. Print the result with System.out.println.
4. Add a nested block and declare one new variable inside it.
5. Use both an outer variable and the nested variable inside the block.
6. Try to use the nested variable after the block and observe the compiler error.
7. Create one compound arithmetic expression and then rewrite it with parentheses for readability.
8. Compile with javac StructureLab.java and run with java StructureLab.

Knowledge Check

1. What does an expression do?
2. What is a statement?
3. What commonly terminates declaration and expression statements?
4. What is a block?
5. What symbols delimit a Java block?
6. Can every possible expression be used by itself as a statement?
7. What happens to a local variable declared inside a nested block after that scope ends?
8. What is the difference between precedence and evaluation order?

Answers

1. It is evaluated and produces or denotes a result, variable, value, or defined effect depending on the expression form.
2. A complete unit of execution in the Java language.
3. A semicolon.
4. A group of zero or more statements treated together in braces.
5. { and }.
6. No. Java permits specific expression forms as expression statements.
7. It is no longer accessible by that local name outside its scope.
8. Precedence determines grouping; evaluation order determines when operand expressions are evaluated.

Previous Related Lessons

• OSJava.002: Primitive Types and Variables
• OSJava.001: What Is Java?
• OSC#.003: C# Operators and Expressions

Primary References

• Dev.java — Expressions, Statements and Blocks
• Java Language Specification — Chapter 15: Expressions
• Java Language Specification — Chapter 14: Blocks and Statements

Elementary Conclusion

Java programs are built by combining expressions, statements, and blocks. Expressions compute or produce results. Statements form executable units. Blocks group statements and establish structure and scope. These ideas are simple individually, but together they form the grammar that later lessons will use for conditionals, loops, methods, classes, exceptions, and larger applications.

BitcoinVersus.Tech Editor’s Note:
We volunteer daily to ensure the credibility of the information on this platform is Verifiably True. If you would like to support to help further secure the integrity of our research initiatives, please donate using the QR code provided

For best QR-code scanning results, please scan this donation code from a desktop or larger screen. Mobile screens may prevent camera recognition.