Autoplay
Autocomplete
Previous Lesson
Complete and Continue
Java In-Depth: The Master Course
Course Introduction
Motivation behind Creating this Course (7:43)
Course Structure & Guidance on Doing the Course (19:08)
Java: A High-level Overview
Chapter Introduction (3:08)
What is Java & Who is Using It? (6:42)
Story behind Java's Creation ~ A Brief History (7:36)
Compilation (9:51)
Platform Dependency (8:38)
Interpreter (7:50)
Platform Independence in Java (8:57)
Java Virtual Machine (14:01)
An Overview of Java SE (21:28)
Java SE Release Cycles & Release History (6:49)
Installing JDK 17 on Windows (22:58)
Installing Java on Mac (4:46)
Installing Java on Linux (6:52)
Setting Classpath Environment Variable (9:20)
Writing First Java Program (16:15)
Conclusion (2:40)
Chapter Quiz
Important Q&A Discussions! (S)
Classes, Objects and their Members
Chapter Introduction (3:19)
Class & Objects (12:32)
Absolute Java Basics (17:13)
Variables: Introduction (10:20)
Declaring & Re-initializing Variables (15:00)
Assignment: Currency Converter - Creating a Class with Variables
Variables: Primitive Types (2:00)
Primitive Variables: Integers (19:47)
Question on Binary Representation of Negative Number
Other Integer Literal Formats (10:33)
Primitive Variables: Floating-point Numbers (11:09)
Floating-point Pitfalls* (10:55)
Primitive Variables: Character Data Type (17:01)
Alternate ways to initialize char variables (6:25)
Primitive Variables: Boolean Data Type (5:57)
Variable Kinds (26:38)
Multi-variable Declaration Statements (9:31)
Quiz: Variables
Variables: Type Casting (19:25)
Variables: Object References (6:19)
Statements (7:40)
Arrays (27:35)
Assignment: Currency Converter - Array Creation & Accessing it Elements
2D Arrays (7:22)
3D Arrays (5:20)
Use byte & short Variables Judiciously (S)
Methods: Introduction (20:51)
Method Types (21:27)
Summary on Accessibility of Members from Static & Instance Methods
Assignment: Currency Converter ~ Invoking Methods of an Object
How Data is Passed to Methods in Java? (18:18)
Method Overloading (10:21)
Methods: varargs (8:39)
Constructors (22:07)
Constructor Overloading (24:47)
Constructor Overloading ~ Alternate way of delegating (3:58)
Minor Note on Method Invocation & Implicit Narrowing Conversion (S)
this Reference (14:35)
Reinitializing Object References ~ More Brainstorming! (20:00)
Minor Note on Executing StudentTest
Coding Exercise 1: Arrays with Object References
Review of Exercise 1 Solution with Best Practices (21:43)
Conclusion (3:38)
Chapter Quiz
Important Q&A Discussions! (S)
Method Building Blocks: Operators & Control-flow Statements
Chapter Introduction (3:32)
Operators (4:09)
Arithmetic Operators (22:13)
Arithmetic Operation Rules (8:55)
Quiz: Arithmetic Operators
Note on Student Class
Comparison Operators (14:45)
Logical Operators (28:13)
Car Price Estimator ~ Coding Exercise for Comparison & Logical Operators (19:48)
Coding Exercise 2: Car Price Estimator ~ Putting Comparison & Logical Operators into Action
Car Price Estimator - Exercise Solution Review (6:06)
Bitwise Operators (9:24)
Quick Note on Bitwise Operators with Boolean Operands
Bit Shift Operators (5:37)
Quiz: Bitwise & Bit Shift Operators
Control-flow: if-statement (18:05)
Control-flow: switch (18:04)
When is switch Preferred? (3:36)
Quiz: switch Statement
Control-flow: Ternary (7:25)
Additional Notes on Ternary Operator
Control-flow: for Statement (11:56)
More for Statement ... (21:54)
for-each Statement* (18:42)
Variable Scope (5:16)
Exercise
Coding Exercise 3: Computing GPA ~ Putting Operators & Control-flow to Test
Computing GPA - Exercise Solution Review (21:28)
Control-flow: while Statement (3:26)
Control-flow: break Statement (9:16)
Control-flow: continue (5:08)
Recursion (27:01)
Minor Correction in Binary Search Code
Conclusion (5:54)
Packages & Access Levels
Chapter Introduction (2:26)
Java API* (9:21)
Accessing Packages (16:41)
Creating Packages & Classpath Management (29:39)
Naming Packages (4:18)
Access Levels (22:36)
More on private Modifier (10:27)
Quiz: Packages & Access Levels
Programming with Eclipse IDE
Introduction (2:56)
Installing Eclipse (6:05)
Writing a Java Program in Eclipse (14:40)
Eclipse Build Process (15:44)
Importing Demo Code (4:31)
Source Code Navigation (11:40)
Automatic Source Code Cleaning & Generation (14:22)
Shortcuts Cheat Sheet
java.lang: The Fundamental Classes
Chapter Introduction (2:43)
Strings: Introduction (5:44)
String Class (19:46)
Assignment: Calculating Term Frequency in a Document
String Pool & Interning (15:51)
String Immutability (3:29)
String Concatenation (10:32)
String Concatenation Performance* (3:14)
Escape Sequences (4:50)
Strings - Important Q&A Discussions! (S)
Coding Exercise 4: Sentiment Analysis: Mining Pros & Cons ~ Putting String Class to Test
Math Class (20:14)
Boxed Primitives & Static Factory Methods* (14:15)
Uses of Boxed Primitives (15:23)
Autoboxing (4:25)
Prefer Primitives over Boxed Primitives* (11:36)
Coding Exercise 5: Parsing API Response ~ Let's make use of Boxed Primitives & String class
Chapter Quiz
Initialization Blocks & final Variables
Chapter Introduction (0:55)
Initializers: Static & Instance (7:44)
Note on Instance Initialization Blocks
final Variable (S) (19:35)
Constant Variables (10:22)
Chapter Quiz
Information Hiding Design Principle & Professional Coding Conventions
Chapter Introduction (1:23)
Information Hiding - Use Accessor Methods* (10:58)
Enhancing Student Example with Information Hiding (12:26)
Minimize Accessibility of Classes & Members* (3:49)
Coding Conventions: Naming Classes, Methods and Variables* (10:04)
Coding Conventions: Structuring Programs* (7:31)
Coding Conventions: Stylistic (6:39)
Coding Conventions: Comments (13:12)
Case Study: A Social Bookmarking Application
thrill.io ~ A Social Polymarking App! (10:15)
Case Study (4:14)
Serious OOP: Inheritance & Polymorphism
Inheritance (8:27)
Access Modifiers & Inheritance + Demo (12:27)
Note on Recommended Order for Modifiers (S)
IS-A Test (4:07)
Coding Exercise 6: Hospital Management System (HMS) ~ Let's put Inheritance into practice!
Polymorphism + Demo (12:20)
Casting Objects & instanceof Operator + Demo (9:49)
Coding Exercise 7: Extending HMS with a Billing Component ~ Putting Polymorphism into Practice!
Type Safety (7:27)
Method Overriding + Demo (14:49)
Minor Correction in First Method Overriding Rule
Method Binding + Demo (17:03)
Question on Method Binding
What is Not Overridden? (final Method is one of them) + Demo (14:17)
Demo: Fields are Not Overridden (3:03)
Object Class + Demo* (7:52)
Constructor Chaining + Demo (8:33)
Preventing Inheritance (5:30)
Conclusion (7:02)
Chapter Quiz
More Serious OOP: Abstract Classes & Interfaces
New Requirement: thrill.io for Kids (6:14)
Note on Next Lecture on Abstract Classes
Abstract Classes & Methods + Demo (6:27)
Note on Abstract Classes & Constructors
Prefer Class Hierarchies over Tagged Classes* (5:58)
Coding Exercise 8: Computing Health Insurance Premium for Staff ~ Let's put Abstract Classes & Methods into practice!
New Requirement: Sharing Bookmarks (5:20)
Multiple Inheritance & Diamond Problem (4:08)
Interfaces (18:44)
Update to Interfaces due to Java 9
More on Interfaces (8:08)
Note on Next Lecture on Interfaces
Demo: Interfaces (11:23)
Interfaces: A Conceptual View (7:50)
Prefer Interfaces over Abstract Classes* (7:56)
Refer Objects through their Interfaces* (3:20)
Coding Exercise 9: Computing Health Insurance Premium for Staff (Part 2) ~ Let's put Interfaces into practice!
Marker Interfaces (6:44)
Cloneable Interface + Demo (6:03)
default Methods (Java 8) + Demo (18:51)
Recap of default Methods (4:17)
default Methods: Other Benefits + Demo (10:09)
Static Methods in Interfaces + Demo (11:48)
Private Methods in Interfaces
Conclusion (12:37)
Chapter Quiz
Important Q&A Discussions!
Debugging Java Programs & Unit Testing with JUnit
Using Eclipse Debugger (17:34)
JUnit & Debugging (18:03)
Shortcuts Cheat Sheet
Project: Implementing a Social Bookmarking App
Project Introduction (3:58)
MVC Architecture (6:55)
Implementing Entities (12:04)
Implementing Manager Classes - Demonstrates Singleton Pattern!! (12:33)
Implementing Constant Exporting Classes (4:50)
Implementing Data Store (18:40)
Implementing Dao Classes (5:40)
Launching the Application (9:14)
Implementing User Bookmarking Feature (15:54)
Implementing Kid-Friendly Eligibility Criteria Using TDD (19:41)
Marking Bookmarks as Kid-Friendly (19:01)
Minor Coding Correction in Previous Lecture
Implementing Sharing Feature: Part 1 (Implementing Shareable Interface) (13:31)
Troubleshooting StringUtils Compilation Issue
Implementing Sharing Feature: Part 2 (View, Controller and Manager) (19:08)
JVM Internals
Introduction (8:28)
Lifetime of a Type (8:32)
Lifetime of a Type: Class Loading (9:36)
Lifetime of a Type: Linking (10:07)
Demo: Lifetime of a Type (17:50)
Quiz: Lifetime of a Type
Reflection (7:55)
Accessing Class Object (6:20)
Demo: Reflection (12:44)
Coding Exercise 10: Simulate a Basic Unit Testing Framework ~ Putting reflection into action!
Runtime Data Areas (6:33)
Method Area & Heap (10:46)
Method Table (6:55)
Garbage Collection: Introduction (8:46)
Garbage Collection Algorithms (7:13)
GC: Generational Collections (10:08)
Important Questions on GC Algorithm (+)
Demo: Tuning Heap & Analyzing GC Cycles (7:43)
Eliminate Obsolete Object References (aka Memory Leaks)* (6:25)
Stack (5:48)
Stack Frame (6:03)
Instruction Set: invokespecial & invokevirtual + Demo (17:57)
Conclusion (8:04)
Chapter Quiz
Exceptions with Best Practices
Chapter Introduction (3:04)
Demo: Exceptions & Exception Handling (15:00)
Demo: Multiple Exceptions & Polymorphically Referencing Exceptions!! (9:40)
Checked & Unchecked Exceptions + Demo (10:08)
Exceptions & Method Overriding
finally Block + Demo (11:53)
try-with-resources Statement + Demo (15:09)
Demo: Suppressed Exceptions (7:23)
Demo - Best Practices: Creating New Exceptions* (12:49)
Demo - Best Practices for Capturing Failure Information* (9:20)
Demo - Best Practice: Exception Translation & Chaining* (7:13)
Coding Exercise 11: Extending Compute GPA Exercise with Exceptions
Bit of Brainstorming! (+)
Exceptions: More Advice ...* (6:22)
Assertions (10:07)
Demo: Assertions (9:19)
Conclusion (6:08)
Chapter Quiz
Exceptions ~ Important Q&A Discussions!
Input-Output
Chapter Introduction (6:32)
Character Encoding + Demo (Prerequisite) (19:40)
Stream IO (6:33)
Byte Streams (5:50)
Reading Byte-Oriented Files Efficiently + Decorator Pattern + Demo (19:56)
Character Streams (4:07)
Reading & Writing Text Efficiently (9:39)
Project Extension: Reading User & Bookmark Data from Text Files (Demo) (10:52)
Project Extension: Downloading WebLinks & Writing to Disk (Demo) (13:02)
Demo: Reading User Input from Console using BufferedReader & Scanner (9:38)
The File Class + Demo (14:39)
Serializing Java Objects + Demo (17:34)
Deserialization & Versioning + Demo (12:04)
Demo: Decoding with Compatible Encoding Scheme (3:35)
Conclusion (7:17)
Chapter Quiz
Input-Output ~ Important Q&A Discussions! (+)
Collections Framework (aka Data Structures)
Chapter Introduction (7:35)
Collection Interface (6:31)
List Interface (3:31)
ArrayList - Introduction (6:12)
Demo: ArrayList (16:16)
Iterator + Demo (19:18)
List Iterator + Demo (10:36)
LinkedList (10:38)
Queue & Deque Interfaces (9:36)
ArrayDeque + Demo (9:46)
Coding Exercise 12: Flight Reservation System ~ Putting Lists & Queues into Action!
Hash Table (9:36)
Set Interface & HashSet + Demo + (Overriding hashCode & Equals)* (14:51)
LinkedHashSet + Demo (5:21)
SortedSet & NavigableSet (9:04)
TreeSet (Comparable & Comparator) + Demo (18:03)
Demo: More TreeSet ~ Exploring NavigableSet Methods (9:46)
Coding Exercise 13: TreeSet & Comparator Exercise
Map Interface (8:32)
Demo: HashMap + Excercise (13:38)
Demo: Beware of Creating Mutable Keys (7:35)
LinkedHashMap + Demo (17:42)
SortedMap, NavigableMap and TreeMap + Demo (10:17)
Demo: Arrays Class (19:54)
Further Clarification on Arrays.asList() Explanation
Demo: Arrays Class (Part 2) ~ Parallelized Operations from Java 8 (8:22)
Demo: Collections Class (16:34)
Best Practice: Return Empty Arrays or Collections* (5:18)
Conclusion - A Quick Summary (8:34)
Chapter Quiz
Collections ~ Important Q&A Discussions! (+)
Generics
Chapter Introduction ~ Motivation & Agenda (12:24)
Generic & Parameterized Types (8:33)
Demo: Creating Generic Types + Type Erasure Discussion (15:55)
Project Extension: Replacing Arrays with ArrayLists (Part 1) (13:13)
Project Extension: Replacing Arrays with ArrayLists (Part 2) (9:49)
End of Part 1 (Core Java) of the Course
Bounded Type Parameter + Demo (11:15)
Avoid Raw Types in New Code* (12:14)
Unbounded Wildcard + Demo (10:10)
Invariance + Demo + Prefer Lists to Arrays* (7:15)
Generic Methods* (15:04)
Demo: Generic Methods & Generic Constructors (20:46)
Important Question on Type Inference & Invariance (+)
Bounded Wildcards: Motivation + Demo (11:23)
Bounded Wildcards & More Expressive APIs* (12:43)
Demo: Bounded Wildcards (15:26)
Generics Restrictions (4:45)
Conclusion - A Quick Summary (11:58)
Chapter Quiz
Important Q&A Discussions!
Nested Classes with Best Practices
Chapter Introduction (9:18)
Nonstatic Member Classes & Adapters + Demo (17:08)
Note on Nonstatic Member Classes - From Java 16 Onwards (+)
Anonymous Classes + Demo & Function Objects* (21:56)
Local Classes + Demo (7:42)
Fix in Previous Demo on Local Classes for Java 9 and above
Static Member Classes (Favor them!) + Demo* (15:13)
Variable Scope with Nested Classes (4:36)
Conclusion - A Quick Summary (6:24)
Coding Exercise 14: Anonymous Class & Static Member Class Exercise
enums
enums: Motivation & Introduction (Avoid int Constants)* (10:25)
Enum Class + Demo (12:33)
enums with State & Behavior + Demo (6:08)
Nested enums + Demo (4:16)
Project Extension: Converting Constant Exporting Classes to Enums (12:17)
enums with Constant-specific Behavior + Demo (11:10)
Bit of Brainstorming! (+)
Chapter Quiz
Concurrency (aka Multi-threading)
Chapter Introduction ~ Motivation & Agenda (8:12)
Threads: Introduction (7:52)
Minor Correction on Thread States
Demo: Launching Threads and Making them to Sleep! (14:40)
Demo: Thread Naming, Prioritization and Joining (Avoid Thread Groups)* (12:55)
Race Condition + Demo (13:28)
Synchronization + Demo* (10:49)
Java Memory Model (JMM) (10:44)
Volatile Variables + Demo (9:29)
Atomic Variables + Demo (17:54)
Important Question on Atomic Variable (+)
Synchronization Best Practices* (8:40)
Thread Cooperation & Management + Demo (14:44)
Demo: wait & notify (21:54)
Thread Interruption + Demo (23:51)
Explicit Locks (Reentrant Lock) + Demo (25:59)
Hijacked Signal: Single Condition Queue with signal notification (+)
Quiz: Concurrency Part 1
Prefer Concurrency Utilities over wait & notify* (5:47)
Executor Framework + Demo* (16:21)
Executor Service & Future (13:39)
Demo: ExecutorService & Future (10:18)
Tasks with Time Limits + Demo (11:41)
Project Extension: Downloading Web Links Concurrently (19:20)
Project Extension: Implementing Background Job to Download Web Links (21:03)
Quiz: Concurreny Part 2
Date & Time API - Covers Java 8 & Legacy API
Agenda (1:55)
Background - epoch, UTC, Timezone ... (12:50)
Legacy API - Date & Calendar Classes + Demo (24:29)
New Date & Time API - Introduction (9:52)
Demo: New Date & Time API (22:43)
Coding Exercise 15: Implementing Flight Booking Feature ~ Putting new Date & Time API into practice!
Database Implementation & JDBC API
Database Introduction & Chapter Agenda (15:12)
Installing MySQL Database & MySQL Workbench (10:30)
Database Design & Normalization (24:31)
Database Design using MySQL Workbench (17:37)
Project Ext.: Creating Database via CREATE & INSERT Queries + Storage Engines (25:29)
Installing JDBC Driver (9:10)
Writing SELECT Queries with Multiple Tables, GROUP BY, ORDER BY, etc. (19:27)
Project Extension: Loading Data from Database via JDBC API (20:50)
Project Extension: Saving Bookmarking Data via INSERT Queries (14:04)
Project Extension: ALTER Query & Saving Kid-Friendly Details via UPDATE Queries (19:14)
Useful Links to Some Tutorials
Functional-style Programming - Lambdas & Streams
Functional-style Programming: Motivation & Chapter Agenda (8:44)
Lambdas - Introduction (13:40)
Demo: Lambdas (10:23)
Demo: Capturing Variables from Lambdas ~ Closures! (13:29)
Quiz: Lambdas
Lambdas: Important Q&A Discussions!
Predicate, (Bi) Function, and Unary Operator Interfaces + Demo (25:09)
Demo: Consumer, Supplier, and Primitive Functional Interfaces (14:33)
Quiz: Functional Interfaces
Demo: Method References (12:59)
Demo: Constructor References (8:52)
Streams + Demo (23:41)
Stream Operations: An Overview (7:03)
Demo: Slicing a Stream (18:49)
flatMap Operation (7:50)
Demo: flatMap Operation (5:17)
Demo: Stream Matching Operations (10:33)
Demo: Stream Finding Operations & Optional Class (18:27)
Stream Reduction Operations + Demo (23:10)
Assignment: Let's test our skills on reduce() operation
Assignment Solution
Coding Exercise 16: Covid Tracking with reduce()
Solution: Covid Tracking with reduce() (9:59)
Special Cases of Reduction Operation (7:05)
Mutable Reduction with Collection Operations + Demo (23:34)
collect() with Collector (10:52)
Demo: Collecting Stream into List & Set (12:01)
Coding Exercise 17: Covid Tracking with collect()
Solution: Covid Tracking with collect()
Demo: Grouping Stream Elements (18:32)
Demo: Summarizing Groups & Generating Multi-level Groups (25:16)
Side-effect Free Functions (4:50)
Demo: Streams & Side-effect Free Functions (21:37)
Conclusion (8:58)
Important Q&A Discussions!
Introduction to Java EE & Web-enabling Project
Motivation & Agenda (7:42)
Web Basics (23:31)
Java EE & Servlet Containers (12:07)
Installing Tomcat (7:21)
BooksAloha! ~ Creating & Deploying a Web Application using Servlets (23:31)
Servlet Life Cycle (13:35)
Implementing BooksAloha! as MVC using JSP (22:35)
Using JSTL to Improve Presentation Layer (13:44)
Project Extension: Web-enabling thrill.io Project (6:03)
Project Extension: Implementing Browse Functionality (28:55)
Project Extension: Implementing Bookmarking & MyBooks Functionality (29:19)
Project Extension: Implementing Login Functionality with Session (35:06)
JAR Files - Introduction (8:52)
Demo: Creating & Manipulating JAR Files (21:20)
The Java Platform Module System (JPMS)
Chapter Introduction & Agenda (6:16)
Motivation: Stronger Encapsulation (10:04)
Motivation: Ease of Understanding (5:39)
Motivation: Smaller Distributables (9:29)
Motivation: Reliable Configuration (11:19)
Anatomy of a Module (21:00)
Demo: Creating Downloader & Indexer Modules (22:53)
Interoperability: Pre-Java 9 Code on Java 9 & Later
Module Path & Module Resolution (12:30)
Demo: Creating Modular JARs (6:19)
Demo: Achieving Reliable Configuration with Modules (14:31)
Demo: Creating Modules from within Eclipse (8:31)
Demo: Creating Modular JAR from within Eclipse (4:55)
Unnamed Modules: Using Modular Code (17:22)
Unnamed Modules: Using Modular Code from Command Line (7:40)
Minor Correction in Previous Lecture
Automatic Modules: Using Non-Modular Code (9:15)
Demo: Automatic Modules (12:24)
Note on Auto-Suggest Option in Previous Lecture
Chapter Summary
Custom Runtime Images
Custom Runtime Images: Introduction (12:17)
Demo: Custom Runtime Image with Platform Modules (14:01)
Minor Note on Previous Lecture
Custom Runtime Image with few Application Modules: A First Look (3:00)
jdeps: Java Dependency Analysis Tool (6:18)
Converting Automatic Module into Explicit Module (7:44)
Custom Runtime Image with Application Modules (9:58)
Conclusion
Record Class
Record: Introduction (18:37)
Records with Explicit Constructors (13:19)
Restrictions on Records (9:54)
Quiz: Records
Conclusion - Java in around 18 Minutes!
Closing Comments (2:01)
Java in around 18 Minutes! (25:26)
Certification Project: Crafting a Simple Compiler (Accessible on Request)
Problem Description
Using Git & GitHub from Eclipse - A Practical Introduction
Module Introduction & Agenda (2:25)
Introduction to Version Control System (VCS) (8:57)
Introduction to Git (10:02)
Setting-up Project Code - Simulating a Professional Set-up! (5:32)
Creating Git Repository & Committing Code from Eclipse (12:55)
Hosting Repository on GitHub (10:41)
Team Collaboration Set-up (2:23)
Cloning Repository & Committing Code from Eclipse (10:54)
Pull & Update from Remote Repository from Eclipse (3:04)
Bonus Lessons
Big O Notation
Java on Web: Websites & Social Media Groups to Follow
Follow-up Steps Towards Becoming a Full-Stack Java Developer!
Demo: Consumer, Supplier, and Primitive Functional Interfaces
Lesson content locked
If you're already enrolled,
you'll need to login
.
Enroll in Course to Unlock