Skip to content
Preview · sample content · Explore all pages
AITrove

Advanced Java

Continue with exceptions, generics and concurrent work.

Advanced Java work combines type contracts, resource ownership, and execution boundaries. The difficult failures often come from a mismatch between those boundaries rather than from syntax.

Types before casts

Start with generics and wildcard bounds, then make failure handling explicit. Use Optional for defined absence, not as a way to hide an I/O error.

Execution and ownership

A stream pipeline is not a collection copy, and a lambda is not automatically asynchronous. Keep file handles and worker lifetimes scoped to an owner that can close them.

Common Mistakes

Do not add concurrency before measuring the workload and choosing an admission policy. Do not describe an unbounded queue as safe because the worker count is fixed.

Curriculum

Keep type relationships checked and preserve useful failure context.

  1. 1Java generics: invariance, bounds, and type erasure
  2. 2Java exceptions: recovery boundaries and failure context
  3. 3Java Optional: absence without hidden failure

Express transformations without hiding shared side effects.

  1. 1Java lambdas: function contracts and captured state
  2. 2Java streams: lazy pipelines and bounded results

Read a bounded format and close resources on every exit path.

  1. 1Java file I/O: UTF-8, streaming reads, and path ownership
  2. 2Java try-with-resources: close order and suppressed failures

Define rounding, representation, local intent, and timeline identity.

  1. 1Java BigDecimal: decimal amounts and explicit rounding
  2. 2Java date and time: local schedules versus instants

Coordinate shared state, bound waiting work, and shut down owned workers.

  1. 1Java threads: visibility, atomicity, and shared counters
  2. 2Java ExecutorService: bounded admission and shutdown

State what reads metadata and respect member access.

  1. 1Java annotations: retention and explicit processing
  2. 2Java reflection: inspect types without breaking contracts

Inspect retaining owners before changing runtime budgets.

  1. 1Java JVM memory: stack frames, heap objects, and reachability
  2. 2Java garbage collection: diagnose retention before tuning

Own query resources, commit decisions, request deadlines, and response size.

  1. 1Java JDBC PreparedStatement: values stay outside SQL grammar
  2. 2Java JDBC transactions: atomic updates and rollback
  3. 3Java HttpClient: request policy, deadlines, and response size

Use version-labelled value types, closed variants, patterns, and virtual threads.

  1. 1Java records: value carriers and defensive copies
  2. 2Java sealed types: restrict a domain’s direct variants
  3. 3Java 21 pattern switch: exhaustive branches and null policy
  4. 4Java 21 virtual threads: blocking tasks still need limits

Declare compiler targets and run contract-focused assertions.

  1. 1Java Maven builds: compiler release and dependency scope
  2. 2Java JUnit tests: boundary cases and observable contracts
Storage details