docs(Switch): add explanation of yield in Java 12+ switch expressions

What
- Documented the role and usage of the yield keyword introduced with switch expressions in Java 12+.
- Covered:
  1. Definition: yield returns a value from a case block in switch expressions.
  2. When to use: required for multi-line case blocks where arrow syntax (->) isn’t sufficient.
  3. Examples:
     - Arrow-style cases without yield.
     - Block-style cases with yield returning values.
  4. Why not return: return exits the whole method; yield only exits the case block.
  5. Comparison table of break, return, and yield with scope and behavior.
  6. Summary: yield is the modern replacement for break when using switch expressions that return values.

Why
- Clarifies difference between traditional switch statements and new switch expressions.
- Explains why yield was introduced and how it fits into Java’s expression-oriented switch.
- Provides examples for practical usage and avoids confusion with return or break.

How
- Illustrated simple switch expressions using arrow syntax (no yield needed).
- Provided block-style examples where yield is necessary to return values.
- Added table comparing break, return, and yield in terms of purpose, value return, and scope.

Logic
- Inputs: integer values tested in switch expression.
- Outputs: returned string values based on case.
- Flow:
  1. If single expression, arrow syntax works without yield.
  2. If multiple statements, case must use yield to return a value.
  3. Default branch also uses yield to return fallback value.
- Edge cases:
  - Using return in case block exits method prematurely, not just switch.
- Complexity / performance: identical to traditional switch; yield only changes syntax and semantics.
- Concurrency / thread-safety: not relevant; purely syntactic feature.
- Error handling: ensures compile-time safety by requiring yield in multi-statement blocks.

Real-life applications
- Replacing verbose if-else chains with concise switch expressions.
- Cleaner code for mapping values or computing results based on enums, constants, or input values.
- Safer than traditional switch with fall-through, reducing bugs.

Notes
- yield is mandatory for block-style cases in switch expressions.
- Arrow-style cases remain concise and preferred when logic fits in one expression.
- Break is still used in old-style switch statements, but not needed in modern switch expressions.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Java-Versions/Java 14/src/Java 14.txt

@@ -0,0 +1,58 @@
+Understanding `yield` in Java 12+ Switch Expressions:
+
+1. What is `yield`?
+- In traditional `switch` statements:
+  - You used `break` to exit a case.
+  - No value was returned directly.
+
+- In Java 12+, switch expressions allow cases to **return values**.
+- `yield` is the keyword that returns a value from a `case` block (especially multi-line blocks with `{}`).
+
+
+2. When to Use `yield`
+- When you have multi-line logic in a case.
+- When you need to return a computed value back to the switch expression.
+- When arrow syntax (`->`) is not enough.
+
+3. Examples
+
+Arrow style (no `yield` needed):
+String result = switch (value) {
+    case 1 -> "One";
+    case 2 -> "Two";
+    default -> "Other";
+};
+
+Block style (must use `yield`):
+String result = switch (value) {
+    case 1 -> {
+        System.out.println("Matched one");
+        yield "One";  // returns "One" from this case block
+    }
+    case 2 -> {
+        System.out.println("Matched two");
+        yield "Two";  // returns "Two"
+    }
+    default -> {
+        yield "Other";
+    }
+};
+
+
+4. Why Not `return`?
+- `return` exits the whole method.
+- `yield` only exits the current `case` block and provides a value back to the `switch`.
+
+
+5. Quick Comparison
+| Keyword  | Use Case                  | Returns Value? | Scope                      |
+|----------|---------------------------|----------------|----------------------------|
+| break    | Old-style `switch` exit   | No             | Exits switch, not method   |
+| return   | Exit method completely    | Yes            | Whole method               |
+| yield    | Switch expression (Java 12+)| Yes           | Current case → switch expr |
+
+
+6. Summary
+- Use `yield` in **multi-line switch expression cases** to provide a value.
+- Arrow (`->`) cases don’t need `yield` because they are single-expression.
+- `yield` is a safer, modern replacement for `break` in the context of expressions.