Advanced Java 8 Material

    It’s no secret that many Java programmers, starting their way in the industry, pay great attention to “heavy” technologies - OpenJPA, Spring, JAX-RS, EJB, WS - *, ... This makes it possible to integrate into modern corporate projects as soon as possible and maximize salary growth rate.

    Many of them eventually “descend” to the technologies underlying these frameworks - JDBC, Servlet API, NIO / NIO.2. However, it is regrettable that often there is no time left for a detailed study of the language itself and the platform's capabilities.

    This is not about subtleties or exoticism, but about what makes up a significant part of the framework’s work: the Servlet container uses multiple ClassLoaders, the JPA2 provider uses bytecode manipulation, the vast majority of libraries use the Reflection API, the general use of Generics has only "worsened" with the advent of functional interfaces (java.lang.function. *) and lambd.

    The “innovations” of Java 5 (Generics), and now also Java 8 (methods in interfaces, methods links, lambdas, Stream API, JSR 308: Pluggable Type Systems) are superimposed on the misunderstanding of the original platform (ClassLoader, Reflection API). It is necessary to pay attention to the fact that Generics + Java 8 is not just language features, it is partly a transition to a functional programming style.

    I also teach"Scala for Java Developers" on the platform for online education (analogous to Coursera / EdX).

    I have collected a certain number of useful (in my opinion) links on the following topics
    1. Methods in interfaces, method references, multiple inheritance
    2. Lambda (Project Lambda)
    3. Stream API
    4. Functional Algorithms
    5. Annotations
    6. Generics
    7. Reflection API
    8. Class loading

    I hope someone finds them useful.

    Detailed information

    1. Methods in interfaces, method references, multiple inheritance
      • Static methods in interfaces
      • Default methods in interfaces
      • How to live with multiple inheritance: opportunities, conflict resolution
      • Method Links

    2. Lambda (Project Lambda)
      • Background, lambda syntax
      • Details: lexical scope, effectivelly final, closures, type inference, target typing, lambda serialization

    3. Stream API
      • External and internal iteration: map, filter, forEach
      • More complex operations: flatMap, reduce, collect
      • Stream properties and operation properties: immediate / terminal, lazy / eager, stateless / stateful, short-circuiting, serial / parallel, ordered / unordered, associative
      • Parallel Streams and Implicit Fork / Join Integration

    4. Functional Algorithms
      • Parallel reduction works on monoids (associativity, neutral element). What does it mean?
      • Optional, CompletableFuture, ... and other monads. What does it mean?
      • Currying, higher order functions. What does it mean?
      • Combinatorial algorithms in Java 8

    5. Annotations
      • Define your annotations
      • Meta annotations: @ Target, @ Retention, @ Inherited, @ Repeatable, ...
      • Compiler annotations: @ Override, @ SafeVarargs, @ SuppressWarnings, @ FunctionalInterface, ...
      • Subtract annotations using the Reflection API
      • JSR 308: Type Annotations and Pluggable Type Systems
      • Extending type checking with the Checker Framework: @ NotNull, @ GuardedBy, ...

    6. Generics
      • Bounded type parameters
      • Self-bounding generics
      • Wildcards
      • As implemented in Java, restrictions (type erasure, bridge methods, non-reifiable types)

    7. Reflection API
      • java.lang.reflect
      • How frameworks use the Reflection API (JUnit, Mockito, Servlet API 3)

    8. Class loading
      • Class file format and class loading procedure (load, link (verify, prepare, resolve), init)
      • ClassLoader: define your loader, build a hierarchy of loaders
      • Dynamic code generation, compiling on the fly: Compiler API, javaassist
      • Dynamic code generation, we collect from bytecode: BCEL, cglib
      • Dynamic code generation, transformation of an existing bytecode during class loading


    On August 5, a series of 8 webinars will start on the topics mentioned above. Webinars last 2.5-3 hours, during which they manage to delve deeply into the issues and details. Classes are held 2 times a week for 4 weeks on Tuesday and Friday at 18.00-21.00 Moscow time.
    If paid before July 12: $ 225.
    If paid before July 19: $ 250.
    If paid before July 26: $ 275.
    When paying after July 26: $ 300.


    email: GolovachCourses
    skype: GolovachCourses

    Also popular now: