Java Advanced
The traps a confident Java reader still walks into: erasure, wildcard variance, dispatch decided before the program runs, and a constructor that sees a field before it is assigned. Ten spines of code that compiles cleanly and behaves otherwise.
Who it is for
Confident; wants the traps.
For someone confident in the language who wants the traps, the edge cases and the interview questions.
You will get the most out of it if you have written Java recently enough to read it without effort, and have been surprised by it at least once. If you are picking the language up for the first time, start with Java Essentials and come back to this one.
It is also built for interview preparation: the questions are the ones that get asked because they separate people who have read the documentation from people who have hit the behaviour in production.
How long it takes
90 graded questions at roughly 45 seconds each is about 68 minutes of answering in total.
At the default five questions a day, and because the session mixes in your other courses, expect around 18 days — call it 3 weeks — to see everything once, plus a few weeks of thinning reviews after that before it is all mastered.
A question is mastered on the third correct answer, once the gap between reviews has grown past a week — so a course cannot be finished in a weekend however long you sit with it.
Question mix
- 60 multiple choice
- 10 concept cards
- 10 predict the output
- 10 put it in order
- 10 matching questions
Syllabus
What you will be asked about
-
01
Erasure and What Survives It
Predict which generic information is gone at run time and which the class file still carries.
-
02
Bounded Wildcards and PECS
Choose between extends and super on a parameter, and predict which operations the choice forbids.
-
03
Why List<String> Is Not a List<Object>
Explain why generic types are invariant and reach for a wildcard where a subtype assignment is refused.
-
04
Covariant Arrays and ArrayStoreException
Predict when an array store is refused at run time rather than at compile time, and say why generics differ.
-
05
Overload Resolution and Dynamic Dispatch
Separate the choice the compiler makes from the choice the JVM makes, and predict which method actually runs.
-
06
Initialisation Order
Trace static blocks, instance blocks and constructors in the order they actually run, including across a superclass.
-
07
Inner Classes and the Captured Outer Reference
Decide when a nested class needs an enclosing instance, and name what it holds on to when it has one.
-
08
Lambdas, Anonymous Classes and Capture
Explain what a lambda captures and how it differs from the anonymous class it replaced.
-
09
Records and Sealed Types
State what a record generates for you, what it refuses to let you write, and what sealing buys.
-
10
The equals and hashCode Contract
Diagnose why an object that looks equal is not found in a hash-based collection.
8 more topics, and all 90 questions
Java Advanced is a Pro course. One subscription opens it and every other course in the catalogue, including the ones still being written.
A question from this course
Erasure and What Survives It
What does this print?
import java.util.*;
public class Main {
public static void main(String[] args) {
List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
System.out.println(a.getClass() == b.getClass());
}
}Show the answer
A true
You may have expected false, reading List<String> and List<Integer> as two different types with two different classes. Erasure means there is exactly one ArrayList class loaded, and both objects are instances of it. The parameter lives in the compiler's head and in the declaration's signature, never in the object.
The rest of the track
Java at every depth
Java Essentials
The behaviour underneath the ceremony: what a variable really holds, why 1/2 is 0, and why two Strings that look identical are not always the same object. Ten spines on the code that compiles cleanly and still does something else.
Java Core
Where Java trips developers who use it every day: autoboxing that hides a NullPointerException, a ternary that quietly unboxes, and dispatch rules that pick a method before the program runs. Ten spines on the gap between what the code says and what the JVM does.
Java Data & Collections
The collections framework taken seriously: which container promises what, why remove(1) deletes a position, and how a mutated key disappears from its own HashMap. Ten spines on the containers you use every day and the contracts underneath them.
Java Errors & Edge Cases
Exceptions at the points where they stop behaving the way you assumed: a finally block that discards the exception unwinding through it, a map lookup that throws on the way into an int, a class that fails once and reports a missing definition forever after. Ten spines on the paths your happy-path code never takes.
Java Standard Library
The library people reimplement by hand: what split really returns, StringBuilder, Optional, streams and collectors, comparators, java.time, the Objects helpers and text blocks. Ten built-ins that already do the job, and one behaviour in each that is not the one you assumed.
Java Idioms & Pitfalls
The Java people write out of habit that is wrong or dated: raw types, boxed equality, catching Exception, building strings in a loop, arrays where a List belongs and getters that hand out the field. Ten habits, each one run to see what it actually does.
Java Performance
What actually costs on the JVM, read off code rather than a stopwatch: the allocation that never happens, the concat loop that copies everything twice, the map that rehashes sixteen times on its way to a million entries. Ten spines on the difference between the operation you wrote and the work the VM does.
Java Testing
What a Java test actually asserts, and where that claim is weaker than it looks. Argument order and failure messages, the three kinds of equality, deltas, throwing, fixtures and static state, test doubles, and the difference between a failure and an error.
Java Interview Questions
The Java an interviewer actually probes, answered from the rules rather than from memory. The equals and hashCode contract, the string pool, references and boxing, collections, erasure, checked exceptions, dispatch, immutability, and the what-does-this-print questions behind them.
Start Java Advanced
in tomorrow’s session.
Enrol and this course joins your daily five, mixed in with everything else you are studying — 90 questions spread over about 18 days rather than dropped on you at once.
Browse the catalogue