Geekly Articles each Day
📜 ⬆️ ⬇️

Java 8 Advanced Content

It's not a secret that many Java programmers, starting their way in the industry, pay great attention to "heavy" technologies - OpenJPA, Spring, JAX-RS, EJB, WS - *, ... This allows you to quickly integrate into modern corporate projects, and maximize the rate of wage growth.

Many of them eventually “go down” to the technologies underlying the specified 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 capabilities of the platform.

This is not about subtleties or exotic, but about what constitutes a significant part of the framework: Servlet-container uses multiple ClassLoaders, JPA2-provider uses bytecode manipulation, the vast majority of libraries use Reflection API, universal use of Generics is only “aggravated” with the emergence of functional interfaces (java.lang.function. *) and lambda.
')
The new principles of Java 5 (Generics) and now Java 8 (methods in interfaces, links to methods, 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 udemy.com online education platform (equivalent to Coursera / EdX).

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

I hope someone finds them useful.

Detailed information


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


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


  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 Stream 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?
    • Java 8 combinatorial algorithms


  5. Annotations
    • We define our annotations
    • Meta annotations: @ Target, @ Retention, @ Inherited, @ Repeatable, ...
    • Annotations to the compiler: @ 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. Generic
    • 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 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, compile on the fly: Compiler API, javaassist
    • Dynamic code generation, collected from bytecode: BCEL, cglib
    • Dynamic code generation, transformation of existing bytecode during class loading




Webinars


On August 5, a series of 8 webinars will start on the topics indicated above. Webinars last 2.5-3 hours, during which they manage to be deeply immersed in problems and details. Classes are held 2 times a week for 4 weeks on Tuesday and Friday from 6 to 8 p.m. Moscow time.
Cost of
If paid before July 12: $ 225.
If paid before July 19: $ 250.
If paid before July 26: $ 275.
If paid after July 26: $ 300.

Contacts


email: GolovachCourses
skype: GolovachCourses

Source: https://habr.com/ru/post/228603/

More articles:


All Articles