Objects and references, the String and generics model, the collections framework, exceptions, the Stream API and the concurrency essentials.
Java's reputation as verbose is a side effect of a design that puts everything in a class and states types twice. Underneath that, four ideas do most of the work, and this course is built around them. First, **Java has no value types**. Every variable holds a reference, so passing an argument copies the reference and not the object. That single fact explains why `==` on strings is a bug, why arrays are not compared by their contents, and why a method that "modifies its argument" may or may not be visible to the caller. Second, **`String` is immutable**, and immutability is not a limitation but the reason it is safe to share, to use as a map key, and to hand to code that runs on another thread. Third, **generics are erased**. `List<String>` and `List<Integer>` are the same type at run time, which is why you cannot write `new ArrayList<String>()` polymorphically, and why a raw `List` accepts anything without complaint. Fourth, **checked exceptions** put failure in the method signature. It is controversial and it is also the only mainstream language that makes "this can fail" part of a type. The course ends with concurrency, where the memory model decides what another thread is allowed to see.