Java 21, Java 17, Java 11, Java 8 (advanced) and Spring Boot

Java 21, Java 17, Java 11, Java 8 (advanced) and Spring Boot, available at $69.99, has an average rating of 4.57, with 167 lectures, based on 1609 reviews, and has 14761 subscribers.

You will learn about Apply functional programming techniques in Java i.e. lambda expressions (including method references) and Streams. Obtain the knowledge of many advanced Java concepts such as Concurrency, Generics/Collections, Localization, JDBC and IO/NIO.2. Master the important topics introduced Java since Java 8 e.g. modules, sealed classes, records, switch expressions, unnamed classes and instance main methods. Acquire the skills to pass the Java OCP exams. This course is ideal for individuals who are Students/software professionals who want to take their Java beyond the fundamentals and understand advanced Java topics. or Students/software professionals wanting to master the new features introduced since Java 8 or Anyone preparing for Java OCP Certification. It is particularly useful for Students/software professionals who want to take their Java beyond the fundamentals and understand advanced Java topics. or Students/software professionals wanting to master the new features introduced since Java 8 or Anyone preparing for Java OCP Certification.

Enroll now: Java 21, Java 17, Java 11, Java 8 (advanced) and Spring Boot

Summary

Title: Java 21, Java 17, Java 11, Java 8 (advanced) and Spring Boot

Price: $69.99

Average Rating: 4.57

Number of Lectures: 167

Number of Published Lectures: 167

Number of Curriculum Items: 174

Number of Published Curriculum Objects: 174

Original Price: €54.99

Quality Status: approved

Status: Live

What You Will Learn

Apply functional programming techniques in Java i.e. lambda expressions (including method references) and Streams.
Obtain the knowledge of many advanced Java concepts such as Concurrency, Generics/Collections, Localization, JDBC and IO/NIO.2.
Master the important topics introduced Java since Java 8 e.g. modules, sealed classes, records, switch expressions, unnamed classes and instance main methods.
Acquire the skills to pass the Java OCP exams.

Who Should Attend

Students/software professionals who want to take their Java beyond the fundamentals and understand advanced Java topics.
Students/software professionals wanting to master the new features introduced since Java 8
Anyone preparing for Java OCP Certification.

Target Audiences

Students/software professionals who want to take their Java beyond the fundamentals and understand advanced Java topics.
Students/software professionals wanting to master the new features introduced since Java 8
Anyone preparing for Java OCP Certification.

[UPDATE June 2024] – Spring Boot 3 added! I have added a Spring Boot v3 application. Topics include: configuring the application (including its dependencies); how RESTful applications work and how dependency injection and inversion of control operate. I walk through the code in detail and demonstrate it in action with Postman.

[UPDATE September 2023] – Java 21 added! Java 21 has now been officially released. Among its topics include the eagerly anticipated “Unnamed classes and instance main methods”. In addition, other topics include sequenced collections; record patterns and pattern matching for switch.

[UPDATE April 2023] – MAJOR NEWS – this course has been selected by Udemy for inclusion in their Udemy Business program.

“Udemy Business is a curated(carefully chosen) selection of high-quality Udemy courses — like yours” [Udemy email].
“Only 3% of all courses are chosen for Udemy Business.” [Udemy email].

Java has now 4 LTS (Long Term Support) releases: 8, 11, 17 and 21. This course covers them all: it addresses advanced Java 8 programming in addition to Java 11, 17 and 21.

This course is a successor to my “Java 8 OCA (1Z0-808) Certification – Master the Fundamentals”, which covers Java fundamentals in great detail. As a result, this course starts with lambdas i.e. fundamentals such as classes, interfaces, operators and methods are not in this course. It is important to realise that while familiarity with Java is helpful, certification is certainly nota pre-requisite.

This course starts with the advanced topics of Java 8 – lambdas, streams, collections, generics, concurrency etc.. There are assignments for lambdas, streams and collections.

Java 11 is then covered – LVTI, private interface methods, annotations, security and modules. Modules are examined in detail (with examples).

Java 17 is covered next – sealed classes, records, switch expressions, pattern matching and text blocks. A significant assignment covering all topics is included.

Lastly, Java 21 is covered – unnamed classes and instance main methods, record patterns, pattern matching for switch and sequenced collections. An assignment covering all topics that builds on the Java 17 assignment, is included.

All the code used throughout the course is available.

Topics are presented with both general understanding and certification in mind i.e. the course caters for both. Regarding certification, Java 8 OCP (1Z0-809), Java 11 OCP (1Z0-819) and Java 17 OCP (1Z0-829) are targeted. This course would be a great training support in conjunction with the excellent MCQ Certification tool from Enthuware (as there are no MCQ’s on this course).

The theory of the topic is explained with lots of code examples used to reinforce the topic. The videos are annotated in detail to help the learner follow my explanations. Having access to the code is a great learning aid as you can get the code running and see what happens when you change it. In addition, the assignments/exercises are a great aid for learning.

Topics include:

Spring Boot Application:

configuring a Spring Boot application, including its dependencies
understanding how RESTful applications work
architecture overview
code explained in detail
testing the application with Postman

Java 21:

Unnamed classes and instance main methods
Record patterns
Pattern matching for switch
Sequenced collections

Java 17:

Sealed classes
Records
switchexpressions and pattern matching
Text blocks

Java 11:

Modules
privateinterface methods
LVTI (local variable type inference)
Annotations
Security

Java 8 Advanced:

Lambda Expressions
Streams
Generics
Collections
Concurrency
JDBC
File IO
NIO.2
Serialisation
Localisation

By way of background, I am a PhD-qualified University lecturer since 2002. For over a decade, I have taught Java on a bespoke Masters on behalf of a highly regarded software company.

I have recently co-authored two books on Java: “Learn Java with Projects” and “Java Memory Management: a comprehensive guide to garbage collection and JVM tuning”. Both were co-authored with Maaike van Putten.

I love teaching and this course has all my experience in explaining advanced concepts of Java. In addition, I have a strong attention to detail which lends itself perfectly to the Oracle Java Certification exams.

Course Curriculum

Chapter 1: Lambda Expressions

Lecture 1: Lambdas – Introduction

Lecture 2: Lambdas – using a custom Functional Interface (in code)

Lecture 3: Lambdas – using Predicate (in code)

Lecture 4: API Functional Interfaces – Predicate and BiPredicate

Lecture 5: API Functional Interfaces – Supplier

Lecture 6: API Functional Interfaces – Consumer and BiConsumer

Lecture 7: API Functional Interfaces – Function and BiFunction

Lecture 8: API Functional Interfaces – UnaryOperator and BinaryOperator

Lecture 9: Lambdas – final and 'effectively final'

Lecture 10: Method References

Lecture 11: Bound Method References

Lecture 12: Unbound Method References

Lecture 13: Static Method References

Lecture 14: Constructor Method References

Lecture 15: The Importance of Context for Method References

Chapter 2: Cloning the Repositories

Lecture 1: Cloning Advanced Java repo

Lecture 2: Cloning Spring Boot repos

Chapter 3: Streams

Lecture 1: Introduction and Stream Pipelines

Lecture 2: Stream Laziness

Lecture 3: Creating Streams

Lecture 4: Terminal Operations

Lecture 5: Terminal Operations – reduce()

Lecture 6: Terminal Operations – collect()

Lecture 7: Terminal Operations – collect() – Collectors.toMap()

Lecture 8: Terminal Operations – collect() – Collectors.groupingBy()

Lecture 9: Terminal Operations – collect() – Collectors.partitioningBy()

Lecture 10: Intermediate Operations – filter(), distinct(), limit()

Lecture 11: Intermediate Operations – map(), flatMap(), sorted()

Lecture 12: Primitive Streams – Creating

Lecture 13: Primitive Streams – API

Lecture 14: Primitive Streams – Functional Interfaces

Lecture 15: Primitive Streams – Mapping Streams

Lecture 16: Code – mappingObjectStreams()

Lecture 17: Code – mappingPrimitiveStreams()

Lecture 18: Optionals

Lecture 19: Parallel Streams

Chapter 4: Collections and Generics

Lecture 1: Collections – Introduction

Lecture 2: Common Collection Methods in Code

Lecture 3: List

Lecture 4: Lists in Code

Lecture 5: Set

Lecture 6: Sets in Code

Lecture 7: Maps

Lecture 8: Maps in Code

Lecture 9: Queue and Deque

Lecture 10: Queue and Deque in Code

Lecture 11: PriorityQueue

Lecture 12: Sorting – Comparable and Comparator

Lecture 13: Code: Comparable – Product

Lecture 14: Code: Comparable and Comparator – Sorting Arrays and Lists – Dog

Lecture 15: Code: Sorting by Multiple Fields

Lecture 16: Code: TreeSet Comparable issue – how to resolve with Comparator

Lecture 17: Code: Binary Search

Lecture 18: Generics – Introduction

Lecture 19: Generics – polymorphism, extends, super

Lecture 20: Generics – super and extends (in detail)

Lecture 21: Generic Classes and Interfaces

Lecture 22: Generic Methods

Lecture 23: equals()

Lecture 24: hashCode()

Lecture 25: Hashing in code

Lecture 26: Watch out for mutable fields in hashing

Chapter 5: Concurrency

Lecture 1: Introduction

Lecture 2: Creating Threads

Lecture 3: sleep() and join()

Lecture 4: ExecutorService (Introduction)

Lecture 5: ExecutorService (code)

Lecture 6: Submitting Task Collections (code)

Lecture 7: Scheduling Tasks

Lecture 8: Thread Safety – Introduction

Lecture 9: Data Race Demo

Lecture 10: Atomic Classes

Lecture 11: AtomicInteger example (code)

Lecture 12: synchronized keyword

Lecture 13: synchronized example (code)

Lecture 14: Lock interface

Lecture 15: Lock example (code)

Lecture 16: Concurrent Collections – Introduction

Lecture 17: Concurrent Collections – API

Lecture 18: Concurrent Collections – SkipList Collections

Lecture 19: Concurrent Collections – CopyOnWriteCollections

Lecture 20: Concurrent Collections – BlockingQueue

Lecture 21: Concurrent Collections – synchronized collections

Lecture 22: Concurrency – Threading problems – Race Condition

Lecture 23: Concurrency – Threading problems – Deadlock

Lecture 24: Concurrency – Threading problems – Livelock and Starvation

Chapter 6: Localisation

Lecture 1: Introduction and Creating locales

Lecture 2: Localising Numbers and Currencies (Introduction)

Lecture 3: Localising Numbers and Currencies

Lecture 4: Localising numbers using custom formats

Instructors

Dr. Seán Kennedy OCA, OCP
OCA, OCP

Rating Distribution

1 stars: 14 votes
2 stars: 22 votes
3 stars: 139 votes
4 stars: 559 votes
5 stars: 881 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu