# Unit 3: Modern Java Features (BCS403) ## 1. Java New Features Overview * **Goal:** Enhance developer productivity, code readability, and performance. * **Key Themes:** Functional programming constructs, improved syntax, modularity, better resource management. --- ## 2. Functional Interfaces * **Definition:** An interface with exactly **one abstract method**. * **Purpose:** To support lambda expressions and method references. * **Annotation:** `@FunctionalInterface` (optional, but recommended for clarity and compile-time checking). * **Example:** ```java @FunctionalInterface interface MyFunctionalInterface { void doSomething(); } ``` * **Exam Point:** Understand the single abstract method requirement. --- ## 3. Lambda Expressions * **Definition:** A concise way to represent an anonymous function (a function without a name). * **Syntax:** `(parameters) -> expression` or `(parameters) -> { statements; }` * **Purpose:** To provide implementations for functional interfaces. * **Key Components:** * **Parameters:** Input variables (type inference often applies). * **Arrow Token:** `->` separates parameters from the body. * **Body:** Single expression or a block of statements. * **Types of Lambdas:** * **Expression Lambda:** Single expression return value. * **Block Lambda:** Multiple statements, explicit `return` needed if applicable. * **Examples:** * `() -> System.out.println("Hello");` * `(x, y) -> x + y` * `(a, b) -> { int sum = a + b; return sum; }` * **Exam Point:** Understand syntax variations and how they map to functional interfaces. --- ## 4. Method References * **Definition:** A shorthand for a lambda expression that calls an existing method. * **Purpose:** To refer to methods directly without executing them. * **Syntax:** `ClassName::staticMethodName`, `instanceRef::instanceMethodName`, `ClassName::instanceMethodName`, `ClassName::new` (constructor reference). * **Types:** * **Static Method Reference:** `Math::sqrt` * **Instance Method Reference:** `string::length` (on an instance) * **Class Method Reference:** `String::toUpperCase` (on a class) * **Constructor Reference:** `ArrayList::new` * **Example:** ```java // Lambda: (x) -> System.out.println(x) // Method Reference: System.out::println // Lambda: (x) -> String.valueOf(x) // Method Reference: String::valueOf ``` * **Exam Point:** Recognize the different reference types and their equivalent lambda expressions. --- ## 5. Stream API * **Definition:** A sequence of elements that supports aggregate operations. * **Purpose:** To perform **declarative operations** on collections of data (filter, map, reduce, etc.). * **Key Concepts:** * **Source:** The collection or data to process (e.g., List, Set). * **Intermediate Operations:** Transform the stream (e.g., `filter()`, `map()`, `sorted()`). They are **lazy**. * **Terminal Operations:** Produce a result or side-effect (e.g., `forEach()`, `collect()`, `reduce()`, `findFirst()`). They **trigger execution**. * **Stream Pipeline:** Source -> Intermediate Operations -> Terminal Operation. * **Example:** ```java List names = Arrays.asList("Alice", "Bob", "Charlie"); names.stream() .filter(name -> name.startsWith("A")) .map(String::toUpperCase) .forEach(System.out::println); ``` * **Key Operations:** * `filter(Predicate)` * `map(Function)` * `flatMap(Function>)` * `sorted()` * `distinct()` * `collect(Collector)` * `reduce(BinaryOperator)` * `forEach(Consumer)` * **Exam Point:** Differentiate intermediate vs. terminal operations. Understand common stream operations and their effects. --- ## 6. Default and Static Methods in Interfaces * **Default Methods:** * Allow adding new methods to interfaces without breaking existing implementations. * Provide a default implementation that implementing classes can override. * **Syntax:** `default void methodName() { ... }` * **Exam Point:** Enables evolution of interfaces. * **Static Methods:** * Belong to the interface itself, not to any specific instance. * Cannot be overridden. * Often used for utility methods related to the interface. * **Syntax:** `static String utilityMethod() { ... }` * **Exam Point:** Provide helper functions directly within the interface. --- ## 7. Base64 Encoding and Decoding * **Definition:** A binary-to-text encoding scheme that represents binary data in an ASCII string format. * **Purpose:** Safe transmission of binary data over media designed for text. * **Java Classes:** `java.util.Base64`. * **Encoders:** `Base64.getEncoder()`, `Base64.getUrlEncoder()`, `Base64.getMimeEncoder()`. * **Decoders:** `Base64.getDecoder()`, `Base64.getUrlDecoder()`, `Base64.getMimeDecoder()`. * **Methods:** `encodeToString(byte[])`, `decode(String)`. * **Exam Point:** Understand the purpose and basic usage of `java.util.Base64`. --- ## 8. `forEach` Method * **In Collections:** An **instance method** on `Iterable` (and thus `Collection`) interfaces. * Executes an action for each element. * Can be implemented using a lambda expression or method reference. * **Example:** `myList.forEach(System.out::println);` * **In Streams:** A **terminal operation**. * Executes an action for each element of the stream. * **Example:** `myStream.forEach(System.out::println);` * **Exam Point:** Differentiate `forEach` on collections vs. streams; understand its role in iteration. --- ## 9. `try-with-resources` * **Definition:** A `try` statement that declares one or more resources, which are then automatically closed when the statement is executed. * **Purpose:** Ensures that resources (like streams, file handles, network connections) are closed properly, preventing leaks. * **Requirement:** Resources must implement the `AutoCloseable` or `Closeable` interface. * **Syntax:** ```java try (ResourceType resource1 = getResource1(); ResourceType resource2 = getResource2()) { // Use resources } catch (Exception e) { // Handle exceptions } ``` * **Exam Point:** Crucial for robust resource management; understand automatic closing. --- ## 10. Type Annotations * **Definition:** Annotations that can be applied to any Java type use (not just declarations). * **Purpose:** To provide more flexible and detailed type checking, often used by static analysis tools. * **Requirement:** Requires `-Aprint=typeUse` compiler argument and a custom processor. * **Placement:** Before the type, e.g., `@MyAnnotation MyType`. * **Exam Point:** Advanced concept; focus on **where** they can be applied (type uses). --- ## 11. Repeating Annotations * **Definition:** Allows the same annotation to be applied multiple times to a single location. * **Purpose:** Simplifies the declaration of annotations that logically represent a collection of values. * **Requirement:** 1. The base annotation must be annotated with `@Repeatable(ContainerAnnotation.class)`. 2. A container annotation is defined to hold multiple instances of the repeatable annotation. * **Example:** ```java @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface Schedules { Schedule[] value(); } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @Repeatable(Schedules.class) public @interface Schedule { String dayOfMonth(); String month(); } // Usage: @Schedule(dayOfMonth="1", month="JAN") @Schedule(dayOfMonth="15", month="JUN") public void doPensions(){} ``` * **Exam Point:** Understand the `@Repeatable` annotation and how it enables multiple annotations. --- ## 12. Java Module System (JPMS) * **Definition:** Introduced in Java 9, organizes code into **modules**. * **Purpose:** To improve the structure, security, and maintainability of large Java applications. * **Key Concepts:** * **Module:** A self-contained unit of code and resources. * **`module-info.java`:** Declares module dependencies and what is exported/opened. * **`requires`:** Declares dependency on another module. * **`exports`:** Makes packages visible to other modules. * **`opens`:** Allows reflection access to packages. * **Benefits:** Encapsulation, reliability, scalability. * **Exam Point:** Understand the concept of modules, `module-info.java`, and the keywords `requires`, `exports`. --- ## 13. Diamond Syntax with Inner Anonymous Classes * **Diamond Syntax (`<>`):** Introduced in Java 7 for type inference in generic instantiations. * **Limitation:** Cannot be used directly for **inner anonymous classes**. * **Problem:** `new HashMap<>() { ... }` is invalid. * **Solution:** Explicitly state the type: `new HashMap() { ... }` * **Exam Point:** Understand that diamond syntax is not applicable to inner anonymous classes, requiring explicit type parameters. --- ## 14. Local Variable Type Inference (`var`) * **Definition:** Allows the compiler to infer the type of local variables. * **Syntax:** `var variableName = initialValue;` * **Purpose:** Reduces verbosity, improves readability, especially with complex types. * **Restrictions:** * Only for **local variables**, method parameters, and catch-block parameters. * Cannot be used for fields or method return types. * Must be initialized at the time of declaration. * **Example:** ```java var message = "Hello"; // String var numbers = new ArrayList(); // ArrayList ``` * **Exam Point:** Understand its scope (local variables only) and benefits. --- ## 15. Switch Expressions * **Definition:** An evolution of the `switch` statement, allowing `switch` to be used as an expression (returning a value). * **Purpose:** More concise and expressive way to handle multiple conditions. * **Syntax:** ```java // Traditional switch statement int day = 3; String dayName; switch (day) { case 1: dayName = "Monday"; break; case 2: dayName = "Tuesday"; break; // ... default: dayName = "Unknown"; break; } // Switch expression int day = 3; String dayName = switch (day) { case 1 -> "Monday"; case 2 -> "Tuesday"; // ... default -> "Unknown"; }; ``` * **Key Features:** * **Arrow Labels (`->`):** Used instead of colon, automatically breaks. * **Yield Keyword:** Used within block `switch` expressions to return a value. * **Exhaustive:** Compiler checks if all cases are covered (or a `default` is present). * **Exam Point:** Understand `->` syntax, automatic break, and the concept of exhaustiveness. --- ## 16. `yield` Keyword * **Purpose:** Used within a **block `switch` expression** to return a value from that specific case. * **Context:** Only applicable within a `switch` expression that uses curly braces `{}` for its body. * **Example:** ```java int code = 200; String message = switch (code) { case 200: yield "OK"; case 404: yield "Not Found"; case 500: yield "Internal Server Error"; default: yield "Unknown Status"; }; ``` * **Exam Point:** Understand its role in returning values from `switch` expression cases. --- ## 17. Text Blocks * **Definition:** A literal for representing multi-line strings in Java, simplifying string formatting. * **Syntax:** Starts with three double-quote characters (`"""`). * **Purpose:** Avoids the need for escape sequences for quotes and line breaks in strings like SQL queries, HTML, or JSON. * **Formatting:** * Trailing whitespace is automatically trimmed. * Newlines are preserved. * Allows embedding double quotes without escaping. * **Example:** ```java String html = """

Hello, world!

"""; ``` * **Exam Point:** Understand the triple-quote syntax and how it simplifies multi-line strings. --- ## 18. Records * **Definition:** A special class declaration that makes it easy to declare immutable data carriers. * **Purpose:** To concisely declare classes that primarily hold data. * **Syntax:** ```java record Point(int x, int y) { } ``` * **Automatic Features:** * **Immutable Fields:** All fields are `private final`. * **Constructor:** Generates a canonical constructor. * **Accessors:** Generates public getter methods (e.g., `x()`, `y()`). * **`equals()` and `hashCode()`:** Implemented based on all fields. * **`toString()`:** Implemented to show all fields. * **Exam Point:** Understand the conciseness and automatically generated methods for data-holding classes. --- ## 19. Sealed Classes * **Definition:** Allows developers to restrict which other classes or interfaces may extend or implement them. * **Purpose:** To provide more control over class hierarchies, enabling exhaustive pattern matching and better design. * **Syntax:** ```java public sealed class Shape permits Circle, Rectangle, Square { ... } ``` * **`permits` Clause:** Explicitly lists the permitted subclasses. * **Subclasses:** Must be either `final`, `sealed`, or `non-sealed`. * **Exam Point:** Understand the concept of restricting inheritance and the role of the `permits` clause.