Master Java 9.0 To 17.0

Learn everything that you should know to master Java 17.0

What you'll learn

Learn all the features from Java 9.0 to 17.0

Understand how to use Java module system effectively

Learn the modified Stream and Collection API in different versions in Java

Learn how to use functional interfaces and lambdas

Requirements

Knowledge of earlier versions (Java 5.0) is recommended but optional.

Some coding exposure is required. Even if you do not have any prior experience of Java you will still understand everything from the course.

Description

Learning Java was always a FUN. Understanding and implementing OOPs to design and develop Java application was enjoyable for sure. That was true, until few years back. To be specific until Java 10 version was launched with the new approach of "Time based version release".  Under this approach, for every 6 months new Java version will be released. For instance, Java 10 was launched on March 20, 2018, and Java 11 was launched on Sept 15, 2018, exactly after 6 months. Though this was good approach for API developers (as they can release smaller chunks), it had become a nightmare for developers. Getting to know the API changes in each and every version is not a simple job for sure. Though every version might not have drastic changes, there has to be enough support and evidence from the community for which developers would always struggle. This course is savior for all such developers, who are keen to know the API changes from Java 9 to Java 17. During this entire course you will learn almost all the features those were introduced as a part of corresponding version release. The course "Master Java 9.0 to 17.0" does not only explain you the concepts, but also covers the proof of the concept by using different programs. Though the course title is, "Master Java 9.0 to 17.0" is covers everything that you need to know to become successful Java developers. For instance, the course covers functional interfaces, lambdas, and stream programing from Java 8 as well. Along with this it covers features like JPMS(Java Platform Module System) from Java 9, and other concepts like modified switch case, var keyword, updates in Stream and Collection API etc.  Even if you are new to Java, this course is right choice for you because it covers the traditional concepts like concurrency, collection, generics, exception handling, String api etc. This course will be certainly one of the best choices for you, if you are aiming to make a exciting career in Java. So, if you are really keen to learn all the features from Java 9.0 to 17.0, REGISTER FOR THIS COURSE.

Overview

Section 1: The Fundamentals

Lecture 1 Setting up Eclipse

Lecture 2 Creating HelloWorld

Lecture 3 Undestanding public static void main

Lecture 4 Working with Arguments

Lecture 5 Working with multiple classes

Lecture 6 Source code

Section 2: Introduction to OOPs

Lecture 7 How to create a class

Lecture 8 Creating object from class

Lecture 9 Invoking methods from object reference

Lecture 10 Working with constructor

Lecture 11 Working with Copy Constructor

Lecture 12 "this" keyword

Lecture 13 Types of variables- Part1

Lecture 14 Types of variables- Part2

Lecture 15 Working with Access Specifiers

Lecture 16 Source Code

Section 3: Exploring OOPs

Lecture 17 Pillars of OOPs

Lecture 18 What is abstraction?

Lecture 19 What is encapsulation?

Lecture 20 Implementing encapsulation

Lecture 21 What is inheritance?

Lecture 22 Achieving inheritance using extends keyword

Lecture 23 Using super keyword

Lecture 24 What is polymorphism?

Lecture 25 Implementing method overloading

Lecture 26 Rules for method over-riding

Lecture 27 Achieving Method Over-riding

Lecture 28 Working with polymorphic reference OR dynamic method dispatch

Lecture 29 Instanceof Operator

Lecture 30 final keyword

Lecture 31 Understanding containment

Lecture 32 "Object" the cosmic super class

Lecture 33 Methods in Object class

Lecture 34 Comparing objects with equals() method

Lecture 35 equals() vs == operator

Lecture 36 Using toString() method

Lecture 37 Using clone() method

Lecture 38 Implementing hashCode() method

Lecture 39 Using finalize() method

Lecture 40 Working with abstract class - Part 1

Lecture 41 Working with abstract class - Part 2

Lecture 42 Working with interfaces

Lecture 43 Understanding marker interface

Lecture 44 Default methods in Interfaces

Lecture 45 Static methods in Interfaces

Lecture 46 Java 9 Update: private method interface

Lecture 47 Source code

Section 4: Variable Declaration and Control statements

Lecture 48 Data Types

Lecture 49 Java10 Update: Type Inference using "var" keyword

Lecture 50 Working with Simple If statement

Lecture 51 Working with Nested if statement

Lecture 52 Working with Ladder if statement

Lecture 53 Java 16 update: Pattern Matching statement

Lecture 54 Using for and nested for

Lecture 55 Working with enhanced for loop

Lecture 56 Using While an DoWhile

Lecture 57 Working with Simple switch case

Lecture 58 Java 14 updates: Switch with expression

Lecture 59 Using Labels (break and continue)

Section 5: Working with Enum

Lecture 60 Creating Enum and accessing elements of Enum

Lecture 61 Using enum objects in application

Lecture 62 Implementing Business Logic in Enum

Lecture 63 Adding constructors and data members in Enum

Lecture 64 Predefined methods in Enum

Lecture 65 Source code

Section 6: Working with Array

Lecture 66 Creating and using Single Dimensional Array

Lecture 67 Creating and using MultiDimensional Array

Lecture 68 Working with Arrays: The utility class

Lecture 69 Java 9 Updates : equals(), compare() and mismatch() methods

Lecture 70 Source code

Section 7: Date and Time API

Lecture 71 Working with LocalDate

Lecture 72 Extracting information from LocalDate

Lecture 73 Working with LocalTime

Lecture 74 Working with LocalDateTime

Lecture 75 Dealing with ZonedDateTime

Lecture 76 Understanding Duration, Period and ChronoUnit

Lecture 77 Handling with UnsupportedTemporalTypeException

Lecture 78 Working with Instant object

Lecture 79 Java 16 Updates

Lecture 80 Source code

Section 8: Working with Strings

Lecture 81 Creating String object

Lecture 82 Exploring String API - Part 1

Lecture 83 Exploring String API - Part 2

Lecture 84 Understanding String immutability

Lecture 85 Understanding String Pool

Lecture 86 Working with StringBuffer and StringBuilder

Lecture 87 Java 11 Updates - Part 1: trim() and strip()

Lecture 88 Java 11 Updates - Part 2: isBlank(), lines() and repeat()

Lecture 89 Java 12 Updates : indent(), and transform()

Lecture 90 Java 15 Updates - Part 1: text blocks

Lecture 91 Java 15 Updates - Part 2: formatted() and translateEscape()

Lecture 92 Source code

Section 9: Exception Handling

Lecture 93 Understanding the need for exception handling and hierarchy of exception

Lecture 94 Types of Exceptions

Lecture 95 How to handle the exception

Lecture 96 Implementing exception handling using try-catch

Lecture 97 Catch block chaining

Lecture 98 Working with multi-catch block

Lecture 99 Using finally in try-catch hierarchy

Lecture 100 Using throws keyword

Lecture 101 Using throw keyword and User Defined Exception

Lecture 102 Working with Automatic Resource Management

Lecture 103 Java 14 Updates: Improved NullPointerException

Lecture 104 Source code

Section 10: Java Database Connectivity

Lecture 105 Introduction to JDBC. Why to use JDBC?

Lecture 106 Introduction to MySQL

Lecture 107 Overview of Java-Database communication

Lecture 108 Understanding JDBC API

Lecture 109 Setting up the project for JDBC Connectivity

Lecture 110 Connecting to Database - Part 1

Lecture 111 Connecting to Database - Part 2

Lecture 112 Dealing with SSLException

Lecture 113 Working with executeQuery() method

Lecture 114 Working with executeUpdate() method

Lecture 115 Working with execute() method

Lecture 116 Working with PreparedStatement

Lecture 117 Creating simple stored procedure in mysql

Lecture 118 Creating stored procedure with IN parameter

Lecture 119 Creating stored procedure with OUT parameter

Lecture 120 Creating stored procedure with INOUT parameter

Lecture 121 Working with CallableStatement

Lecture 122 Managing Transactions - Part 1 : commit() and rollback

Lecture 123 Managing Transactions - Part 2: working with SavePoints

Lecture 124 Source code

Section 11: Functional Interfaces and Lambda

Lecture 125 Understanding Functional Interface

Lecture 126 Creating and using functional interfaces

Lecture 127 Traditional Functional interfaces (Pre Java 8)

Lecture 128 Understanding Lambdas

Lecture 129 Implementing Lambda expression

Lecture 130 Avoiding type declaration in lambda expression argument

Lecture 131 Built-in functional interfaces in Java 8

Lecture 132 Implementing Consumer interface

Lecture 133 Implementing Predicate interface

Lecture 134 Implementing Function interface

Lecture 135 Implementing BiFunction interface

Lecture 136 Implementing Supplier interface

Lecture 137 What is method reference?

Lecture 138 Using static method reference

Lecture 139 Using instant method reference

Lecture 140 Using Firstclass object's method referecne

Lecture 141 Using constructor reference

Lecture 142 Source code

Section 12: Java Stream

Lecture 143 What is Java Stream?

Lecture 144 Ways of creating Streams

Lecture 145 Using Streams with Wrappers

Lecture 146 Using Streams with user-defined objects - Part 1

Lecture 147 Using Streams with user-defined objects - Part 2

Lecture 148 Intermediate Operations in Streams

Lecture 149 Terminal Operations in Streams

Lecture 150 Source code

Section 13: Java 9 : Working with Java module aka JPMS(Java Platform Module System)

Lecture 151 Introduction to Java Modules

Lecture 152 What is Java module

Lecture 153 Built-in modules

Lecture 154 All about module descriptor file (module-info.java)

Lecture 155 Creating single module

Lecture 156 Compiling and executing single module

Lecture 157 Working with JAR file with single module

Lecture 158 Implementing Services through module

Lecture 159 Source code

Section 14: Multithreading

Lecture 160 What is multithreading

Lecture 161 The main thread

Lecture 162 Creating Threads

Lecture 163 Using Threads

Lecture 164 Thread life-cycle

Lecture 165 Setting up Thread Priorities

Lecture 166 Thread Synchronization

Lecture 167 Inter-thread Communication

Lecture 168 Understanding Executor Framework

Lecture 169 Working with SingleThreadExecutor and Future

Lecture 170 Working with SingleThreadScheduledExecutor

Lecture 171 Using Callable interface

Lecture 172 Source code

Section 15: Collection API

Lecture 173 Collection API overview

Lecture 174 Working with List

Lecture 175 Conversion of array to ArrayList and ArrayList to array

Lecture 176 Working with ListIterator

Lecture 177 Implementing Set

Lecture 178 Implemeting TreeSet

Lecture 179 Using Comparator interface

Lecture 180 Working with HashMap

Lecture 181 Working with TreeMap

Lecture 182 Working with PriorityQueue

Lecture 183 Working with ArrayDeque

Lecture 184 Source code

Section 16: Generics

Lecture 185 Creating Generic class

Lecture 186 Understanding Type Erasures

Lecture 187 Creating Generic Interfaces

Lecture 188 Creating Generic Methods

Lecture 189 Creating Upper bounded generics type

Lecture 190 Working with wild card

Lecture 191 Creating upper bounded wild card

Lecture 192 Creating lower bounded wild card

Lecture 193 Source code

Section 17: Record class : Java 16 feature

Lecture 194 What is record class

Lecture 195 Instantiating record class

Lecture 196 Canonical constructor in record class

Lecture 197 Compact constructor

Lecture 198 Overriding constructor

Lecture 199 Adding members to record class

Lecture 200 Source code

Section 18: Sealed class : Java 17 feature

Lecture 201 What is sealed class

Lecture 202 Creating sealed class

Lecture 203 keywords in sealed class

Lecture 204 Sealed classes with the subclass

Lecture 205 Creating sealed interface

Lecture 206 Source code

Anyone who wish to learn Java.,Any developer who is keen to upgrade his knowledge from earlier versions of Java till Java 17,Anyone who want to understand how to use functional interfaces and lambdas.