Gain insights into Java 17, cloud and microservices, reactive programming, and top JVM languages. Explore hands-on projects using Scala, Groovy, and Gradle to boost your software development career.

Modern Java Second Edition by Adam L. Davis.png

file.tar.gz

modern_java

Groovy

Scala

Java 12

Java 14

Java 16

Java 17

Java 16-copy

Play

jshell

SPA-play

Gradle-uppercase

Gradle-copyimages

Gradle-properties

Java 14-copy

Java 16-fruits

Java 16-strings

Gradle-java

This course is meant for Java programmers or aspiring programmers who want to know about the latest Java and JVM technology. Throughout this course, you will get several opportunities to get hands-on experience with various Java concepts. 

This course will help you understand the latest in Java up to version 17; cloud and microservices; build, testing, and web frameworks; reactive programming in Java; and the best JVM languages so you can advance your career in software development. 

Moreover, you will also get to work with Scala, Groovy, and Gradle. The course explains Java concepts in detail and also draws comparisons with its older versions, as well as JVM languages.

The All-in-One Guide to Java Programming

Java 5 added several new features to the language. If you’re not familiar with Java 5 or would like a refresher, keep reading.

The following new features have been added to Java 5:


* Generics
* Annotations
* More concise for loops
* Static imports
* Autoboxing/unboxing
* Enumerations
* Varargs
* Concurrency utilities in package `java.util.concurrent`

## Generics
**Generics** were a huge addition to the language. Although it improved the type-safety of Java, it also increased the complexity of the language.

Generics are most commonly used to specify what type a Collection holds. This reduces the need for casting and improves type safety. For example, we can declare a list of strings in the following manner:

```Java
List<String> strings = new ArrayList<String>();
```
Declaring a map of `long` to `String` would appear like the following:

``` Java
Map<Long,String> map = newHashMap<Long,String>();
```

The generic type needs to be repeated twice in the declaration, which receives a lot of criticism.
However, various libraries such as Google's guava make this less painful by using static methods. For example, declaring the above map would be as simple as the following:
``` Java
Map<Long,String> map = Maps.newHashMap();
```

## Annotations
Java **annotations** allow us to add meta-information to Java code that can be used by the compiler, various APIs, or even by our own code at runtime.

The most common annotation we will see is the `@Override` annotation, which declares that we are overriding a method to the compiler. For example, this is useful because it will cause a compile-time error if we mistype the method name.

Other useful annotations are those in `javax.annotation` such as `@Nonnull` and `@Nonnegative`, which declare our intentions.

To reduce "wiring" code, annotations such as `@Autowired` and `@Inject` are used by direct-injection frameworks like Spring and Google [Guice](http://code.google.com/p/google-guice/), respectively.

## More concise `for` loops
we can write `for` loops concisely for an array or any class that implements `Iterable`. For example:

# Generics
**Generics** were a huge addition to the language. Although it improved the type-safety of Java, it also increased the complexity of the language.

Generics are most commonly used to specify what type a Collection holds. This reduces the need for casting and improves type safety. For example, we can declare a list of strings in the following manner:

```Java
List<String> strings = new ArrayList<String>();
```
Declaring a map of `long` to `String` would appear like the following:

``` Java
Map<Long,String> map = newHashMap<Long,String>();
```

The generic type needs to be repeated twice in the declaration, which receives a lot of criticism.
However, various libraries such as Google's guava make this less painful by using static methods. For example, declaring the above map would be as simple as the following:
``` Java
Map<Long,String> map = Maps.newHashMap();
```

# Annotations
Java **annotations** allow us to add meta-information to Java code that can be used by the compiler, various APIs, or even by our own code at runtime.

The most common annotation we will see is the `@Override` annotation, which declares that we are overriding a method to the compiler. For example, this is useful because it will cause a compile-time error if we mistype the method name.

Other useful annotations are those in `javax.annotation` such as `@Nonnull` and `@Nonnegative`, which declare our intentions.

To reduce "wiring" code, annotations such as `@Autowired` and `@Inject` are used by direct-injection frameworks like Spring and Google [Guice](http://code.google.com/p/google-guice/), respectively.

# More concise `for` loops
we can write `for` loops concisely for an array or any class that implements `Iterable`. For example:

Learn about Java 5 and a few of the new features added to it.

Introduction

Java Syntax and Conventions

Java 7

Idiomatic Java 8: Lambdas, Streams, and Dates

New Date and Time API

Java 8 Miscellaneous

Advantages of Java 9

Java 10 - 17

Java Ecosystem

Maven and JUnit

Utilizing Essential Libraries

Modern Java Concurrency

RxJava

Other JVM Languages

Groovy

Gradle

Spock

Scala

RESTful

Microservices and Clouds

Grails

Spark

Spring Boot

Play Framework

Ratpack

Final Thoughts

Appendix

Java 5

Generics