Expressions in Java are the primary construct for doing calculations. Here are some examples:

1                 // A simple literal is an expression
1 + 2             // A simple expression that adds two numbers
(i + j) / k       // An expression with multiple operations
(flag) ? c : d    // An expression using the "conditional" operator
(String) s        // A type-cast is an expression
obj.test()        // A method call is an expression
new Object()      // Creation of an object is an expression
new int[]         // Creation of an object is an expression

In general, an expression consists of the following forms:

• Expression names which consist of:

- Simple identifiers; e.g. `someIdentifier`
- Qualified identifiers; e.g. `MyClass.someField`

• Primaries which consist of:

- Literals; e.g. `1`, `1.0`, `'X'`, `"hello"`, `false` and `null`
- Class literal expressions; e.g. `MyClass.class`
- `this` and `<TypeName> . this`
- Parenthesized expressions; e.g. `( a + b )`
- Class instance creation expressions; e.g. `new MyClass(1, 2, 3)`
- Array instance creation expressions; e.g. `new int[3]`
- Field access expressions; e.g. `obj.someField` or `this.someField`
- Array access expressions; e.g. `vector[21]`
- Method invocations; e.g. `obj.doIt(1, 2, 3)`
- Method references (Java 8 and later); e.g. `MyClass::doIt`

• Unary operator expressions; e.g. !a or i++
• Binary operator expressions; e.g. a + b or obj == null
• Ternary operator expressions; e.g. (obj == null) ? 1 : obj.getCount()
• Lambda expressions (Java 8 and later); e.g. obj -> obj.getCount()

The details of the different forms of expressions may be found in other Topics.

• The Operators topic covers unary, binary and ternary operator expressions.
• The Lambda expressions topic covers lambda expressions and method reference expressions.
• The Classes and Objects topic covers class instance creation expressions.
• The Arrays topic covers array access expressions and array instance creation expressions.
• The Literals topic covers the different kinds of literals expressions.

The Type of an Expression

In most cases, an expression has a static type that can be determined at compile time by examining and its subexpressions. These are referred to as stand-alone expressions.

However, (in Java 8 and later) the following kinds of expressions may be poly expressions: