Oracle Java SE 17 Developer Course Notes

Java performs compile-time type checking and conversions. Primitive and reference types have distinct conversion rules. Java: Classes, Interfaces, Inheritance, Polymorphism Records: Transparent data carriers with implicit finality and generated methods. Method overloading uses the same name for methods with different parameter lists. Override requires identical method signatures. Access modifiers control visibility. Nested types and sealed classes are core Java features impacting type checking and inheritance.

• Confusing implicit and explicit conversions.

• Review the specific conversion rules for primitive and reference types.

Collection selection: Order, Uniqueness, Lookup, Mutability, Concurrency. Generic bounds and wildcards provide type safety and flexibility in Java generics. Sorting collections using `Comparable` or `Comparator`. Generics and type bounds for safe sorting. Lambdas capture variables from their scope. Capture is formal (parameters) or variable (local). Immutability and collection factories are key to building robust and concurrent Java applications.

• Assuming all collections are interchangeable. The choice depends on the specific requirements.

• Consider the primary operation: Add, Remove, Lookup.

Stream pipelines are single-use data flows. Parallel pipelines must be independent. Collection choice drives pipeline behavior. Streams are consumed once; parallel pipelines need statelessness. Collection choice impacts ordering, uniqueness, and performance. Stream pipelines are single-use. Grouping uses List, Set, Queue, Map. Parallel pipelines need stateless operations. Optional results in streams mean consumption is final. Parallel pipelines need independent parameters. Collection choice drives performance and constraints. Parallel streams require careful design to avoid ordering and concurrency issues.

• Trying to reuse a stream after consumption.

• Focus on the pipeline's flow and the purpose of each stage.

Control flow: if, switch, for, while. Handles multiple exceptions with a single block. `try-with-resources` automatically closes resources, simplifying code and preventing leaks. Assertions and defensive validation are key to robust Java code.

• Confusing switch expressions with if statements.

• Focus on expression evaluation order.

Focus on `java.time` immutable types and chronology selection for accurate date/time calculations. Focus on `java.time` immutable types for date/time operations. Understand `java.time`'s immutable types and their specific semantics. Focus on selecting the correct `java.time` type based on precision needs. Immutable wrappers are preferred for data integrity. Focus on `java.time` immutable types and their semantic requirements.

• Converting dates/times via strings introduces potential errors and bypasses the API's type safety.

• Verify the resulting type's precision, calendar, and time zone after arithmetic operations.

Thread safety requires controlling shared mutable state – visibility, atomicity, ordering, and resource management. Concurrency: Executors and Tasks Concurrent collections and atomic variables are key to managing shared mutable state safely in Java. Concurrency: Locks, Synchronization, Deadlock Parallel task coordination requires careful design to manage shared resources and prevent concurrency issues.

• Assuming timing will solve concurrency issues – incorrect.

• Focus on the core principles of thread safety.

File I/O using Streams and Files. Focus on `Path` and `Files` classes for file manipulation. Traverse file trees using `Files.newDirectoryStream()`. Filter files with stream operations (e.g., `filter()`). Serialization constraints in I/O/NIO.2 relate to collection types and file operations. Safe and portable file handling with NIO.2 requires careful resource management and consideration of platform differences.

• Forgetting to close streams, leading to resource leaks.

• Focus on the core concepts of file I/O and collection selection.

Declare modules and their dependencies – a foundational step. Exports control public access; opens enable reflection. Focus on module descriptor configuration, package exports/opens, and service loading. Collection type selection is key – align with ordering, uniqueness, and performance. Module descriptors manage service dependencies. Exports for compile-time access, opens for runtime reflection. Collection choice based on ordering, uniqueness, lookup, etc. Modular application development involves defining module requirements and managing dependencies.

• Confusing exports and opens – remember their distinct purposes.

• Focus on the purpose of each module descriptor element.

Connect to the database using JDBC. Execute SQL statements to retrieve or modify data. Prepared statements separate SQL from data, improving security and performance. JDBC: Navigate and update database results. Manage JDBC transactions and resources effectively for data integrity and performance.

• Incorrectly establishing the JDBC connection.

• Focus on the connection and statement execution process.

Apply `instanceof` with pattern matching for type checking. Records: Immutable data classes. Sealed Types: Restrict inheritance. Collections: List, Set, Queue, Map – choose wisely. Sealed classes restrict inheritance to improve API stability. Java 17: Permanent features vs. Preview features.

• Confusing `instanceof` with `==` (value comparison).

• Focus on the inheritance hierarchy when using `instanceof`.