What's new in Java Switch | Switch Statement and Expression

Telusko

4 chapters7 takeaways9 key terms5 questions

Overview

This video explains the enhancements made to Java's switch statement, focusing on updates introduced in recent Java versions. It contrasts the traditional switch statement, highlighting the need for `break` statements and the verbosity, with the newer switch expression syntax. The tutorial demonstrates how the arrow (`->`) syntax eliminates the need for `break` and how the `yield` keyword can be used with the traditional colon (`:`) syntax to return values, making switch statements more concise and readable. The video also touches upon the evolution of switch statement support, from integers only to including strings.

How was this?

Save this permanently with flashcards, quizzes, and AI chat

Chapters

The old switch statement requires a `break` after each case to prevent fall-through.
Without `break`, execution continues to the next case, potentially executing unintended code blocks.
Switch statements before Java 5 only supported integers; string support was added later.
The syntax involves `switch`, `case` labels followed by colons, and code blocks.

Understanding the limitations of the traditional switch statement, such as the mandatory `break` and potential for fall-through errors, provides context for appreciating the newer, more streamlined syntax.

A switch statement on a `String` variable 'day' with cases for 'Saturday', 'Sunday', 'Monday', and a 'default', demonstrating the need for `break` to avoid printing multiple alarm times.

Java 12 introduced a preview feature allowing the use of an arrow (`->`) instead of a colon (`:`) after case labels.
The arrow syntax automatically handles the `break` functionality, preventing fall-through.
This new syntax leads to more concise code, often allowing case logic to be written on a single line.
When using arrows, all cases within a switch block must use arrows; mixing with colons is not allowed.

The arrow syntax significantly improves code readability and reduces the likelihood of common errors associated with forgetting `break` statements, making switch statements more robust and easier to maintain.

Replacing colons with arrows in the 'day' example, allowing 'Saturday' and 'Sunday' to directly execute `System.out.println("6am")` without needing a `break` statement.

Modern Java allows switch statements to be used as expressions, meaning they can return a value.
This is achieved by assigning the result of the switch to a variable.
The `yield` keyword is used with the traditional colon syntax to return a value from a case block.
Alternatively, the arrow syntax can directly return a value without needing an explicit `return` or `yield` keyword, similar to lambda expressions.

Using switch as an expression simplifies code by allowing direct assignment of results, eliminating the need for temporary variables and multiple assignment statements within the switch body.

Declaring a `String result` and assigning the output of the switch statement (e.g., '6am', '8am', '7am') directly to it, then printing `result`.

When using switch as an expression with the traditional colon (`:`) syntax, the `yield` keyword is required to return a value from each case.
The arrow (`->`) syntax for switch expressions implicitly returns the value of the expression on the right side of the arrow, making it more concise.
The choice between `yield` and arrow syntax depends on whether you prefer the traditional colon structure or the newer, more compact arrow structure.
Both approaches ensure that all possible paths (including default) yield a value, making the switch expression complete.

Understanding the difference between `yield` and the implicit return of arrow syntax allows developers to choose the most appropriate and readable approach for their switch expressions.

Demonstrating the same alarm-setting logic using `yield` with colons and then refactoring it to use the arrow syntax for implicit value return.

Key takeaways

1Java's switch statement has evolved significantly, offering more concise and less error-prone syntax.
2The arrow (`->`) syntax in modern Java switch statements eliminates the need for explicit `break` statements.
3Switch statements can now function as expressions, directly returning values, which simplifies variable assignment.
4The `yield` keyword is used with colon-based switch cases to return values when using switch as an expression.
5Arrow-based switch expressions implicitly return values, making them more compact than `yield`-based ones.
6Developers can choose between the traditional colon syntax (with `yield`) and the arrow syntax for switch expressions based on preference and readability.
7String support in switch statements, introduced after Java 5, further increased its utility.

Key terms

Switch StatementSwitch ExpressionFall-throughBreak StatementArrow Syntax (`->`)Yield KeywordCase LabelDefault CaseString Support in Switch

Test your understanding

1What is the primary issue with the traditional Java switch statement that the newer syntax addresses?
2How does the arrow (`->`) syntax in Java's enhanced switch statement differ from the traditional colon (`:`) syntax in terms of execution flow?
3Explain the concept of using a switch statement as an expression in Java and what benefit it provides.
4What is the purpose of the `yield` keyword when using switch expressions with the colon syntax?
5Under what circumstances would you choose the arrow syntax over the `yield` keyword for a Java switch expression?