Java Masterclass 2025: 130+ Hours of Expert Lessons

Course Introduction

Getting Started with Java Programming 04:04

• Lecture
  Course Introduction: Your Journey to Becoming a Java Developer 01:17
• Lecture
  Course Remastered: All Lessons Updated to Java 17 with New Slides 00:58
• Lecture
  Maximizing Video Quality for Optimal Course Viewing Experience 00:50
• Lecture
  Enabling and Using Subtitles for Improved Course Comprehension 00:59

Software Tools Setup 04:36

• Lecture
  Source Code Access and the Importance of Hands-On Coding Practice 01:10
• Lecture
  The Key to Success: Persistence and a Growth Mindset in Programming 00:51
• Lecture
  Choosing the Right Java Version: Understanding Long-Term Support (LTS) 02:35

Java Development Environment Setup 21:16

• Lecture
  Essential Software Tools for Java Development: JDK 17 and IntelliJ IDEA 01:18
• Lecture
  IntelliJ IDEA Ultimate Edition: Six-Month Free Trial for Course Students 01:29
• Lecture
  Step-by-Step Guide to Installing JDK 17 on Windows 10 and Windows 11 03:01
• Lecture
  Installing JDK 17 on macOS: A Comprehensive Guide for Intel and M1/M2 Macs 02:38
• Lecture
  Installing OpenJDK 17 on Ubuntu Linux: A Step-by-Step Terminal Guide 02:06
• Lecture
  Verify Java Installation and Explore Java Interactively with JShell 10:44

First Steps in Java Programming 02:35:54

• Lecture
  Your First Java Program: Displaying "Hello World" and Basic Error Handling 09:35
• Lecture
  Introduction to Variables, Keywords, and the Integer (int) Data Type 16:05
• Lecture
  Using Variables in Java Expressions: A Comprehensive Introduction 09:26
• Lecture
  Exploring Java Primitive Types: Integer Ranges and Wrapper Classes 16:45
• Lecture
  Understanding Byte, Short, and Long Data Types and Their Width in Java 12:38
• Lecture
  Understanding and Using Casting with Numeric Primitive Types in Java 09:07
• Lecture
  Primitive Types Challenge: Applying Your Knowledge of Integer Variables 06:11
• Lecture
  Working with Float and Double: Precision in Floating Point Numbers 10:39
• Lecture
  Understanding Floating-Point Precision: A Practical Challenge in Java 11:39
• Lecture
  Exploring Character (char) and Boolean Primitive Data Types in Java 12:16
• Lecture
  Recap of Primitive Types and Introduction to the String Class in Java 17:02
• Lecture
  Mastering Operators, Operands, and Expressions in Java Programming 11:32
• Lecture
  Simplifying Java Code: Using Abbreviated Operators for Concise Operations 12:59

First Steps

Transitioning from JShell to IntelliJ IDEA: A Comprehensive IDE Guide 01:20:05

• Lecture
  Embracing the Power of an Integrated Development Environment 02:27
• Lecture
  Step-by-Step IntelliJ IDEA Community Edition Installation Guide for Windows 02:37
• Lecture
  Comprehensive IntelliJ IDEA Community Edition Setup Instructions for macOS 02:45
• Lecture
  Installing IntelliJ IDEA Community Edition on Linux: A Step-by-Step Tutorial 02:24
• Lecture
  Configuring IntelliJ IDEA for Optimal Java Development (Windows, Mac, Linux) 06:29
• Lecture
  Creating Your First IntelliJ Project: "Hello World" Java Code Implementation 07:53
• Lecture
  Understanding IntelliJ Code Structure: Classes, Methods, and Basic Java Syntax 11:10
• Lecture
  Mastering Java's if-then Statement: Conditional Logic for Program Flow Control 08:13
• Lecture
  Advanced Conditional Logic: Implementing the Logical AND Operator in Java Code 06:48
• Lecture
  Java's Logical OR Operator: Enhancing Conditional Statements for Flexible Code 04:31
• Lecture
  Assignment vs. Equality: Avoiding Common Java Operator Errors in IntelliJ 07:48
• Lecture
  Streamlining Code: Implementing Java's Ternary Operator for Concise Conditionals 06:38
• Lecture
  Java Operator Precedence: Mastering Expression Evaluation and Challenge 10:22

Mastering Java Expressions, Statements, Code Blocks, And Method Overloading 02:23:08

• Lecture
  Introduction To The Fundamentals Of Java Workflow 00:31
• Lecture
  Exploring Java Keywords And Understanding Expressions 09:15
• Lecture
  Mastering Java Statements, Whitespace, And Code Organization 09:19
• Lecture
  Harnessing Code Blocks And The If-Then-Else Statement In Java 09:00
• Lecture
  Practical If-Then-Else Challenge For Java Flow Control 10:09
• Lecture
  Deep Overview Of Methods In Java For Reusable Code 13:53
• Lecture
  Enhancing Skills With Additional Java Method Techniques 09:32
• Lecture
  Comprehensive Recap Of Java Methods 07:40
• Lecture
  Hands-On Java Method Challenge For Deeper Practice 11:50
• Lecture
  Comparing And Reviewing Code In IntelliJ For Better Development 06:40
• Lecture
  Introduction To Java Coding Exercises For Skill Development 13:16
• Quiz
  Comprehensive 'Positive, Negative, Or Zero' Assessment In Java 1 question
• Quiz
  Implementing A Speed Converter To Practice Basic Java Arithmetic And Output 1 question
• Quiz
  Accurate MegaBytes Converter For Mastering Integer Math In Java 1 question
• Quiz
  Developing A 'Barking Dog' Program For Boolean Logic Familiarity 1 question
• Quiz
  Implementing A Precise Leap Year Calculator To Enhance Conditional Reasoning 1 question
• Quiz
  Building A Decimal Comparator To Practice Floating-Point Comparisons In Java 1 question
• Quiz
  Creating An Equal Sum Checker For Strengthening Arithmetic And Comparison Operations 1 question
• Quiz
  Devising A Teen Number Checker For Mastery Of Conditional Range Checking 1 question
• Lecture
  Delving Into Method Overloading In Java 13:17
• Lecture
  Practical Method Overloading Challenge To Strengthen Java Expertise 08:32
• Lecture
  Comprehensive Seconds-And-Minutes Challenge For Time-Based Calculations 11:05
• Lecture
  Detailed Bonus Challenge Solution And Key Insights 09:09
• Quiz
  Constructing A Comprehensive Area Calculator For Circles And Rectangles In Java 1 question
• Quiz
  Implementing A Minutes-To-Years-And-Days Calculator For Advanced Time Conversions 1 question

Java Tutorial: Expressions, Statements, Code blocks, Methods and more

• Quiz
  Designing A 'Playing Cat' Logic Program To Refine Conditional Implementation 1 question

Mastering Conditional Logic, Loops, And Interactive Java Applications 03:12:48

• Lecture
  Introduction To The Foundations Of Program Flow In Java 00:53
• Lecture
  Exploring The Traditional And Enhanced Switch Statements 10:33
• Lecture
  Delving Deeper Into Advanced Switch Statement Features 12:42
• Lecture
  Traditional Switch Statement Challenge And Practical Exercises 05:46
• Lecture
  Embracing Switch Expressions With A Hands-On Coding Challenge 08:49
• Quiz
  Determining Word Representation Of Numbers Accurately 1 question
• Quiz
  Computing Month Length With Leap Year Consideration 1 question
• Lecture
  Mastering The for Statement For Repetitive Task Automation 11:57
• Lecture
  Comprehensive for Loop Challenge To Strengthen Iteration Skills 14:26
• Lecture
  Sum 3 And 5 Challenge With IntelliJ Debugger Insights 15:44
• Lecture
  for Loop Recap And Key Takeaways For Iteration In Java 08:29
• Quiz
  Summing Odd Numbers In A Specified Range 1 question
• Lecture
  The while And do-while Statements For Conditional Looping 10:46
• Lecture
  Practical while Loop Exercises And Challenges 09:48
• Lecture
  Digit Sum Challenge And Further Looping Techniques 08:59
• Lecture
  Revisiting The while And do-while Loops: A Complete Recap 08:24
• Lecture
  Exploring Local Variables And Scope In Java Blocks 05:42
• Lecture
  Introduction To The Course 02:48
• Lecture
  Understanding Classes, Objects, And Static Versus Instance Members 07:19
• Quiz
  Identifying Palindromic Numbers For Enhanced Numeric Validation 1 question
• Quiz
  Summing The First And Last Digits Of An Integer 1 question
• Quiz
  Calculating The Sum Of All Even Digits In An Integer 1 question
• Quiz
  Checking For A Shared Digit Between Two Numbers 1 question
• Quiz
  Evaluating The Last Digit For Multiple Integer Comparisons 1 question
• Quiz
  Listing All Factors Of A Given Number 1 question
• Quiz
  Deriving The Greatest Common Divisor (GCD) Efficiently 1 question
• Quiz
  Confirming Perfect Numbers Through Sum Of Proper Divisors 1 question
• Quiz
  Converting Digits Into Words And Handling Edge Cases 1 question
• Quiz
  Managing Flour Pack Requirements With Limited Bucket Sizes 1 question
• Quiz
  Identifying The Largest Prime Factor Of A Number 1 question
• Quiz
  Constructing A Diagonal Star Pattern With Loops 1 question
• Lecture
  Parsing Values And Reading Console Input – system.console() Overview 12:02
• Lecture
  Handling Exceptions And Introducing The Scanner Class 10:52
• Lecture
  Reading Input With The Scanner For Seamless User Interaction 08:43
• Lecture
  Hands-On Reading User Input Challenge For Practical Mastery 10:21
• Lecture
  Identifying Min And Max Values – A Final Control Flow Challenge 07:45
• Quiz
  Interactive Summation And Average Calculator From User Input 1 question
• Quiz
  Efficient Paint Job Planning With Bucket Calculations 1 question

Mastering Java OOP: Classes & Inheritance 03:54:56

• Lecture
  Welcome to Java OOP Inheritance 00:47
• Lecture
  Deep Dive into Classes and Objects 12:32
• Lecture
  Getters, Encapsulation, and Object Access 08:54
• Lecture
  Setters, Object Creation, and OOP Practice 11:37
• Lecture
  Classes Challenge: Building a Bank Account 08:58
• Quiz
  Sum Calculator Implementation 1 question
• Quiz
  Person Class and Age Validation 1 question
• Lecture
  Constructors Part 1: Object Initialization 07:54
• Lecture
  Constructors Part 2: Overloading and Chaining 09:39
• Lecture
  Constructor Challenge: Building Customer Data 08:15
• Lecture
  Understanding References, Objects, and Instances 08:28
• Lecture
  Static vs. Instance Variables in Java 04:12
• Lecture
  Static vs. Instance Methods Explained 04:35
• Lecture
  POJOs: Plain Old Java Objects 09:12
• Lecture
  Java Records: The Modern POJO Approach 10:28
• Quiz
  Wall Area Computation 1 question
• Quiz
  Point Class and Distance Calculation 1 question
• Quiz
  Carpet Cost Calculator Class 1 question
• Quiz
  Complex Number Operations 1 question
• Lecture
  Working With Subtitles 01:52
• Lecture
  Inheritance - Part 1: The Basics 12:01
• Lecture
  Inheritance - Part 2: Extending Animal Class 11:16
• Lecture
  Inheritance - Part 3: Unique Dog & Fish Classes 10:34
• Lecture
  Unveiling java.lang.Object in Java 12:28
• Lecture
  Inheritance Challenge - Designing a Worker Hierarchy 10:44
• Lecture
  Inheritance Challenge Part 2: Specialized Employees 09:31
• Lecture
  Using this and super for Constructors 05:44
• Lecture
  Method Overloading vs. Overriding Explained 08:47
• Lecture
  Text Blocks & Advanced Output Formatting 12:00
• Lecture
  Revisiting the String: Methods and Best Practices 11:34
• Lecture
  Mastering String Manipulation Methods 11:06
• Lecture
  The StringBuilder: Efficient Mutable Strings 11:48
• Quiz
  Cylinder Class with Circle Inheritance 1 question

Concurrency in Java

Advanced OOP Techniques: Composition, Encapsulation, and Polymorphism in Action 02:56:19

• Lecture
  Embarking on OOP Part 2: Composition, Encapsulation, and Polymorphism Essentials 00:38
• Lecture
  Building a Computer with Composition: Understanding Has-A vs. Is-A in Java 09:34
• Lecture
  Assembling a Personal Computer: Real-World Composition and Object Management 11:00
• Lecture
  Hands-On Smart Kitchen Challenge: Modeling IoT Appliances with Composition 09:45
• Quiz
  Bedroom Composition Exercise: Creating Classes for Lamp, Bed, and Wall 1 question
• Lecture
  Encapsulation Essentials, Part 1: Data Hiding and Simplifying Interfaces 10:27
• Lecture
  Encapsulation Deep Dive, Part 2: Enhancing Classes and Securing Data 08:44
• Lecture
  Encapsulation Challenge: Building a Printer with Toner and Duplex Functionality 09:16
• Lecture
  Concurrency and Threads Introduction 06:59
• Quiz
  Toner and Duplex Printing Exercise: Enforcing Encapsulation in a Printer Class 1 question
• Lecture
  Polymorphism Foundations, Part 1: Introducing Movie Subclasses for Runtime Varia 09:54
• Lecture
  Polymorphism in Practice, Part 2: Factory Methods, Runtime Types, and Movie Scen 12:50
• Lecture
  Advanced Casting and var Usage: Navigating Compile-Time vs. Runtime Types in Jav 10:32
• Lecture
  Runtime Type Inspection: Mastering instanceof and Pattern Matching in Java 05:27
• Lecture
  Polymorphism Challenge: Building Gas, Electric, and Hybrid Car Classes in Java 08:46
• Quiz
  Polymorphism 1 question
• Lecture
  Polymorphism Challenge, Part 2: Finalizing Car Inheritance and Overridden Method 06:24
• Lecture
  OOP Master Challenge, Part 1: Crafting a Burger Restaurant App with OOP Concepts 11:09
• Lecture
  OOP Master Challenge, Part 2: Implementing Meal Orders and Pricing Strategies 12:56
• Lecture
  Threads 13:32
• Lecture
  OOP Master Challenge: Deluxe Burger Bonus Adding Specialized Topping and Pricing 08:13
• Lecture
  Project Structure and Modular Design: Harnessing Packages and Import Statements 10:13

Advanced Arrays in Java: Single & Multi-Dimensional Techniques 01:55:55

• Lecture
  Arrays Introduction: Handling Multiple Values Efficiently in Java 01:07
• Lecture
  Declaring, Initializing, and Accessing Arrays: Foundational Principles 11:09
• Lecture
  Populating, Looping, and Searching: Deeper into Java Arrays 10:37
• Lecture
  Sorting, Filling, and Copying: Mastering the java.util.Arrays Helper Class 08:36
• Lecture
  Binary Search & Equality Checks: Speedy Lookups and Comparisons in Arrays 06:17
• Lecture
  Descending Sort Challenge: Building Your Array Skills with Real Data 08:59
• Quiz
  Sort Integers Descending: Strengthening Array Processing Logic 1 question
• Lecture
  Runnable and Thread 13:19
• Lecture
  Common Pitfalls & Best Practices: A Comprehensive Arrays Recap 07:18
• Lecture
  Reference vs. Value Types: Understanding Array Memory and Method Calls 07:31
• Lecture
  Embracing varargs: Flexible Method Parameters and Array Conversions 06:39
• Lecture
  Finding the Smallest Value: A Hands-On Minimum Element Challenge 07:24
• Quiz
  Implement Min Finder: Reading and Storing Data for Minimum Value Discovery 1 question
• Lecture
  Reversing Arrays In-Place: Hands-On Practice with Swapping Elements 09:13
• Quiz
  Reverse an Array: Mastering In-Place Swaps for Efficient Reordering 1 question
• Lecture
  Navigating 2D Arrays: Matrix Representation and Nested Loop Traversals 10:27
• Lecture
  Expanding to Multi-dimensional Arrays: Jagged Structures and Complex Data 07:19

Mastering Lists, Iterators, and Autoboxing: ArrayList, LinkedList & Enums 03:49

• Lecture
  Interrupt and Join 09:44
• Lecture
  Introduction to Java Collections: Beyond Basic Arrays 01:16
• Lecture
  Meet the List Interface & ArrayList (Part 1) 10:08
• Lecture
  ArrayList Methods (Part 2): Add, Remove, and More 09:38
• Lecture
  ArrayList Methods (Part 3): Sorting, Copying & Searching 08:23
• Lecture
  Arrays vs. ArrayLists: A Practical Comparison 10:37
• Lecture
  ArrayList Challenge Part 1: Building an Interactive Grocery List 10:25
• Lecture
  LinkedList Overview: Memory, Big O, and Why LinkedList Exists 11:55
• Quiz
  Mobile Phone Contacts: Managing a List of Names & Calls 1 question
• Lecture
  LinkedList Essentials (Part 1): Adding & Removing Elements 09:50
• Lecture
  LinkedList Essentials (Part 2): Retrieving & Itinerary Example 08:23
• Lecture
  Getting Support 02:30
• Lecture
  Iterators Explained: Navigating Lists with Forward & Reverse 09:44
• Lecture
  LinkedList Challenge: Ordered Travel Itinerary (Part 1) 09:52
• Lecture
  LinkedList Challenge Continued: Interactive Navigation 10:35
• Quiz
  Playlist Creator: Storing Songs & Custom Track Numbers 1 question
• Lecture
  Introduction to Autoboxing & Unboxing: Moving Between Primitives & Wrappers 09:41
• Lecture
  Autoboxing & Unboxing for Arrays & Lists: Working with Wrapper Classes 06:33
• Lecture
  Autoboxing & Unboxing Challenge: Simple Banking App (Part 1) 06:58
• Lecture
  Autoboxing & Unboxing Challenge: Bank & Customer Implementation (Part 2) 06:04
• Quiz
  Banking System: Branches, Customers & Transactions 1 question
• Lecture
  Multiple Threads 11:52
• Lecture
  Enums Demystified: Declaring & Using Predefined Constants 08:33
• Lecture
  Enums (Part 2): Switch Expressions & Custom Methods in Enums 08:08

Mastering Abstraction & Interfaces: Expand Polymorphism & Java Hierarchies 02:11:21

• Lecture
  Abstraction & Generalization: Less Code, More Extensibility 00:35
• Lecture
  Exploring Abstract & Interface Modifiers: Real-World Modeling in Java 04:18
• Lecture
  Diving into Abstract Classes (Part 1): Creating Flexible Hierarchies 08:53
• Lecture
  Diving into Abstract Classes (Part 2): Polymorphic Behavior & Implementation 06:43
• Lecture
  Diving into Abstract Classes (Part 3): Advanced Hierarchies & Use Cases 09:15
• Lecture
  Abstract Class Challenge (Part 1): Building a Storefront & Product Hierarchy 07:52
• Lecture
  Abstract Class Challenge (Part 2): Finalizing the Store & Order System 07:04
• Lecture
  Thread Variables 09:53
• Lecture
  Interfaces (Part 1): Harnessing Contracts & Polymorphic Behavior in Java 09:50
• Lecture
  Interfaces (Part 2): Multiple Implementations & Real-World Examples 09:40
• Lecture
  Interfaces (Part 3): Constants, Conversion & Flexible Abstractions 10:23
• Lecture
  Interfaces & JDK 8 Enhancements: Default/Static Methods for Compatibility 10:24
• Lecture
  Interfaces & JDK 9 Enhancements: Private & Static Methods in Action 09:18
• Lecture
  Interface vs. Abstract Class: Key Differences & Best Use Cases 07:06
• Quiz
  Data Structures with Abstract Classes: Linked Lists & Binary Search Trees 1 question
• Lecture
  Interface Challenge (Part 1): Creating Mappable Classes & GeoJSON-Like Output 11:04
• Lecture
  Interface Challenge (Part 2): Finalizing Mapping Logic & Extended Features 09:03
• Quiz
  Implementing the ISaveable Interface: Storing & Retrieving Player & Monster Data 1 question

Deep Dive into Java Generics: Bounds, Comparators & Advanced Techniques 02:07:39

• Lecture
  Generics Overview: Why Type Parameters & Where They Excel 00:53
• Lecture
  Creating Your First Generic Class: From Basics to Implementation 08:48
• Lecture
  Refining Generic Classes: Polymorphism & Type Safety 11:33
• Lecture
  Advanced Generics: Multiple Type Parameters & Bounded Types 11:01
• Lecture
  Generic Class Challenge (Part 1): Building Reusable Structures 10:21
• Lecture
  Generic Class Challenge (Part 2): Finalizing Maps & Overviews 07:04
• Lecture
  Comparable Revisited: Sorting Objects by Natural Order 09:40
• Lecture
  Comparable vs. Comparator: Distinctions & Sorting Strategies 11:29
• Lecture
  Generic Classes as Reference Types: Wildcards & Method Parameters 10:36
• Lecture
  Producer and Consumer 10:54
• Lecture
  Generic Methods, Wildcards & Type Erasure: Handling Advanced Cases 12:39
• Lecture
  Static Methods in Generics & Multiple Upper Bounds Explained 11:27
• Lecture
  Final Generics Challenge: Integrating Bounded Types & Comparators 11:14

Exploring Nested Classes, Local Types & Anonymous Classes 01:20:53

• Lecture
  Understanding Nested Classes: Overview & Types 01:46
• Lecture
  Static Nested Classes: Encapsulation & Access Rules 07:45
• Lecture
  Inner Classes: Non-Static Nesting & Syntax 07:48
• Lecture
  Applying Inner Classes: Bill’s Burger Revisited 08:27
• Lecture
  Inner Classes Challenge: Practical Enhancements 11:55
• Quiz
  Building a Playlist with Inner Classes 1 question
• Lecture
  Deadlocks, wait, notify and notifyAll methods 14:05
• Lecture
  Local Classes: Scoping & Effective-Final Variables 11:39
• Lecture
  Anonymous Classes: Inline Instantiation & Use Cases 10:30
• Lecture
  Local & Anonymous Classes Challenge 06:58

Mastering Java Lambdas: Expressions, Interfaces, and Method References 02:28:17

• Lecture
  Introduction to Lambda Expressions: Revolutionizing Java Code with Conciseness 01:42
• Lecture
  Deep Dive into Lambda Expressions and Functional Interfaces: Practical Examples 12:07
• Lecture
  Exploring Lambda Expression Syntax: Variations, Rules, and Advanced Examples 10:53
• Lecture
  Custom Functional Interfaces: Building Reusable Lambda Expressions in Java 11:42
• Lecture
  Exploring Java's Built-In Functional Interfaces: Consumer and Predicate 12:17
• Lecture
  Exploring Java's Built-In Functional Interfaces: Function and Supplier 11:52
• Lecture
  The Java Util Concurrent package 12:09
• Lecture
  Hands-On Practice: Lambda Mini-Challenges for Skill Reinforcement and Mastery 13:46
• Lecture
  Lambda Expression Challenge: Applying Skills with Arrays, Lists, and Operations 12:08
• Lecture
  Demystifying Method References: Simplifying Lambda Expressions in Java Code 09:28
• Lecture
  Understanding the Most Complex Method References: Unbounded Receiver Explained 12:57
• Lecture
  Hands-On Practice: Method Reference Challenge for Practical Skill Development 10:54
• Lecture
  Chaining Lambdas: Leveraging Convenience Methods on Functional Interfaces 11:23
• Lecture
  Advanced Comparator Usage: Leveraging Convenience Methods for Enhanced Sorting 04:59

Mastering Java Collections: Framework, Lists, Sets, and Maps 06:06:51

• Lecture
  Java Collections Framework: An In-Depth Introduction for Beginners 00:50
• Lecture
  Deep Dive into Java Collections: Core Interfaces and Big Picture 11:02
• Lecture
  Thread Interference 11:15
• Lecture
  Creating a Versatile Deck of Cards in Java: Code Setup & Best Practices 11:53
• Lecture
  Exploring java.util.Collections: Essential Methods and List Operations 11:35
• Lecture
  Advanced java.util.Collections: Shuffle, Reverse, Sort, indexOfSubList 08:40
• Lecture
  Mastering java.util.Collections: binarySearch, frequency, min, max, rotate 12:17
• Lecture
  Challenge: Building a Custom Card Game with java.util.Collections 11:45
• Lecture
  Completing the Collections Challenge: Five Card Draw (Poker) 11:18
• Lecture
  Java Hash Codes Explained: Mastering the Basics for Effective Collections 16:16
• Lecture
  Preparing for Sets and Maps: Setting Up Phone and Email Contacts in Java 11:46
• Lecture
  Introduction to Java Sets and HashSet: Mastering Unordered Collections 14:18
• Lecture
  Java Set Operations Explained: Mastering Union, Intersection, & Difference 11:34
• Lecture
  Reentrant Lock and Unlock 10:28
• Lecture
  Java Set Operations Challenge: Setting Up Task and TaskData Classes 14:23
• Lecture
  Java Set Operations Challenge: Real-World Application with Task Management 13:47
• Lecture
  Exploring LinkedHashSet and TreeSet: Ordered Sets in Java 10:59
• Lecture
  Java TreeSet Mastery: Navigating with Closest Match and Subset Methods 10:15
• Lecture
  Challenge: Building a Robust Theatre Seat Booking System with TreeSet 13:52
• Lecture
  Completing the Theatre Seat Booking System Challenge 12:09
• Lecture
  Comprehensive Guide to the Java Map Interface and Its Functionality 13:59
• Lecture
  Advanced Map Operations: compute, replace, and remove Methods Explained 09:27
• Lecture
  Mastering Map View Collections: keySet, values, and entrySet in Java 15:06
• Lecture
  Challenge: Build a Text-Based Adventure Game with Java HashMap 10:34
• Lecture
  Using Try Finally With Threads 10:36
• Lecture
  Completing the Text Adventure Game Challenge 09:08
• Lecture
  Exploring LinkedHashMap and TreeMap: Ordered Maps in Java 12:11
• Lecture
  Mastering TreeMap: NavigableMap Methods for Efficient Data Handling 13:15
• Lecture
  EnumSet and EnumMap: Optimizing Collections for Enum Types in Java 08:30
• Lecture
  Collection Framework Final Challenge Part 1 12:47
• Lecture
  Building a Complete Store Inventory Management System (Part 1) 10:57
• Lecture
  Building a Complete Store Inventory Management System (Part 2) 09:59

Mastering Mutability, Immutability and Final Keyword in Java OOP 04:24:01

• Lecture
  Mutable vs Immutable Objects in Java: Advantages, Disadvantages, and Design 02:30
• Lecture
  Deep Dive into the Final Modifier: Methods, Fields, Classes, Variables 11:19
• Lecture
  Thread Pools 12:03
• Lecture
  Final Modifier: Static Methods, Hiding vs. Overriding, Final Variables 12:13
• Lecture
  Understanding Side Effects of Mutability: Defensive Coding Techniques 13:19
• Lecture
  Designing Immutable Classes: Private Final Fields, Defensive Copies - Part 1 12:31
• Lecture
  Creating Truly Immutable Java Classes: Preventing Subclass Modification 12:48
• Lecture
  Implement Immutable BankAccount and BankCustomer Classes in Java 08:09
• Lecture
  Shallow vs. Deep Copies: Protecting Data Integrity in Java Applications 10:58
• Lecture
  Immutable Collections, Unmodifiable Views: Limitations and Best Practices 09:46
• Lecture
  Implementing Unmodifiable Collections in a Banking Application 09:20
• Lecture
  Building a Secure Banking Application: Implementing Transaction Handling 10:51
• Lecture
  Java Constructors: No-args, Initializers, Final Fields, and Inheritance 13:55
• Lecture
  ArrayBlockingQueue Class 12:29
• Lecture
  Demystifying Record Constructors: Canonical, Custom, and Compact Forms 11:02
• Lecture
  Mastering Enum Constructors and Static Initializers in Java 09:11
• Lecture
  Building a Game Console Framework with Player Input 09:48
• Lecture
  Building a Generic Game Console: Implementing Game and Player Interactions 07:22
• Lecture
  Java Coding Challenge: Design a Pirate Adventure with Constructors & Initializer 11:32
• Lecture
  Pirate Game Development in Java: Implementing Game Logic and Data Loading 11:46
• Lecture
  Enhancing Code Security: Final Classes & Constructor Access Modifiers 08:53
• Lecture
  Restricting Class Extension in Java with the Sealed Classes and Interfaces 13:00
• Lecture
  Building a Complete Pirate Game: Loot, Combat, and Town Features in Java 13:41
• Lecture
  Final Java Game Enhancements: Implementing Town Features and Combat Interactions 15:35

Comprehensive Java Streams: Operations, Pipelines, and Sources 03:52:45

• Lecture
  Understanding Java Streams: Core Concepts and Key Differences from Collections 04:40
• Lecture
  Overview of Software 02:39
• Lecture
  Practical Java Stream Example: Manipulating and Transforming Bingo Ball Data 08:09
• Lecture
  Deep Dive into Java Stream Pipelines: Sources, Intermediate, and Terminal Ops 08:15
• Lecture
  Exploring Java Stream Sources: Collections, Arrays, and Infinite Data Streams 15:24
• Lecture
  Challenge: Mastering Stream Sources and Data Concatenation in Java 11:52
• Lecture
  Filtering and Transforming Data: distinct, filter, limit, skip, takeWhile, dropW 09:22
• Lecture
  Map, Peek and Sorted Operations, using Comparator interface 11:31
• Lecture
  Mastering Terminal Ops: Find Statistics, Match Elements 10:41
• Lecture
  Deadlocks 10:34
• Lecture
  Building a Student Engagement System: Code Setup - Part 1 09:02
• Lecture
  Student Class Construction: Code Setup - Part 2 for Stream Processing 11:05
• Lecture
  Terminal Operations Challenge Part 1 - Student Data Analysis 09:43
• Lecture
  Enhancing Data Analysis: Advanced Terminal Operation Challenge Solution 06:05
• Lecture
  Collecting Data in Java Streams, the Collect and Reduce operations 10:00
• Lecture
  Advanced Stream Processing: Practical Applications of Collect and Reduce 09:36
• Lecture
  Terminal Operations Part 2 - Advanced Data Aggregation Challenge 14:03
• Lecture
  Java Optionals: Preventing NullPointerExceptions and Handling Missing Values 14:51
• Lecture
  Mastering Stream Terminal Operations Find, Min, Max, Average, and Reduce in Java 09:06
• Lecture
  Challenge: Advanced Stream Operations and Data Analysis on Student Engagement 10:36
• Lecture
  More on Deadlocks 14:06
• Lecture
  Transforming Data Structures: Using flatMap to Stream Map Elements in Java 09:39
• Lecture
  Comprehensive Streams Challenge: Applying Advanced Techniques in Java 11:46

Java Core Fundamentals: Math, Randomization, BigDecimal, and Date/Time 03:40:12

• Lecture
  Revisiting Essential Java Core API Functionalities: Math and java.time 00:58
• Lecture
  Mastering the Java Math Class: Preventing Overflow and Underflow Errors 08:19
• Lecture
  Comprehensive Guide to Random Number Generation: Math.random and Random 13:24
• Lecture
  Java Dice Rolling Game: Implementing Randomization and User Input Challenge 09:05
• Lecture
  Advanced Dice Game: Implementing Scoring and Game Logic with Java Enums 14:29
• Lecture
  Mastering BigDecimal for Financial Applications: Precision and Scale in Java 10:39
• Lecture
  Advanced BigDecimal Operations: Controlling Rounding and Precision in Java 13:47
• Lecture
  Thread Starvation 16:47
• Lecture
  Comprehensive Introduction to Java Date and Time API (java.time package) 07:10
• Lecture
  Working with LocalDate in Java: Creation, Manipulation, and Comparison 12:06
• Lecture
  Mastering LocalTime and LocalDateTime in Java: A Comprehensive Guide 13:16
• Lecture
  Understanding Instance, Period, Duration, and Time Zones in Java's Time API 09:26
• Lecture
  Exploring Java Time Zones: ZoneId, Zone Offset, and Daylight Savings Time 10:55
• Lecture
  Mastering Java Time: Instant, ZonedDateTime, Duration, Period, ChronoUnit 13:09
• Lecture
  Introduction to Java Localization and the Locale Class: Concepts and Usage 08:33
• Lecture
  Applying Localization in Java: Formatting Dates, Numbers, and Currencies 10:38
• Lecture
  DateTime & Localization: Cross-Timezone Meeting Scheduler Challenge (10 Days) 14:29
• Lecture
  Java Internationalization: Using ResourceBundle for Multi-Language Support 10:00
• Lecture
  Fair Locks and Live Locks 12:54
• Lecture
  ResourceBundle in Java: Creating Multi-Language Applications (Part 2) 10:08

Regular Expressions in Java: Mastering Pattern Matching and Text Manipulation 01:38:21

• Lecture
  Introduction to Regular Expressions: Practical Uses and Applications in Java 01:30
• Lecture
  Demystifying Regular Expressions: Understanding Syntax, Usage, and Benefits 08:35
• Lecture
  Decoding Regular Expressions: Literals, Character Classes, Quantifiers, Anchors 12:10
• Lecture
  Using Regular Expressions with String and Scanner: split(), replaceAll(), etc. 07:40
• Lecture
  Regular Expression Challenges: Applying Concepts through Practical Exercises 08:56
• Lecture
  Advanced Regular Expressions with Pattern and Matcher: Compilation and Matching 10:08
• Lecture
  Extracting Data with Matcher: find(), group(), Grouping, and Capturing in Java 08:58
• Lecture
  Replacing Text Efficiently: Exploring Matcher's Replacement Methods in Java 12:38
• Lecture
  Live Lock Example and Slipped Conditions 05:04
• Lecture
  In-Depth Review: Dissecting Complex Regular Expressions for Phone/HTML Tags 14:36
• Lecture
  Crafting a Robust Email Validator: A Comprehensive Regular Expression Challenge 08:06

Comprehensive Java Input/Output (I/O) and File Operations 05:21:42

• Lecture
  Java I/O Fundamentals: Resources, Operations, and Exception Handling Intro 04:19
• Lecture
  Mastering Java Exceptions: Checked vs. Unchecked, Finally, and Best Practices 12:09
• Lecture
  Efficient Resource Management: Mastering Try-with-Resources in Java I/O 11:00
• Lecture
  Java I/O Essentials: File, Path, Files, and Paths - A Practical Guide 12:58
• Lecture
  Practical File Operations in Java: Create, Delete, Write with File/Path 11:48
• Lecture
  Exploring Path Methods and File System Interactions in Java NIO.2 10:20
• Lecture
  Directory Listing Mastery: Exploring Files with list, walk, and find 16:09
• Lecture
  Other Thread Issues 14:04
• Lecture
  Advanced File Tree Traversal: Implementing walkFileTree in Java 15:41
• Lecture
  File Tree Navigation Challenge: Mastering Practical File System Tasks 14:12
• Lecture
  Classic Java I/O: Reading Text Files Using FileReader and BufferedReader 10:52
• Lecture
  Mastering the Scanner Class for Flexible Text Input Processing in Java 12:37
• Lecture
  Character Sets, Encodings (UTF-8, ASCII), and NIO.2 Text File Reading 10:47
• Lecture
  Challenge: Text Processing and Word Frequency Analysis in Java 11:52
• Lecture
  Java Output: Writing Text Data to Files (Files.write, BufferedWriter) 12:15
• Lecture
  Java Writers: BufferedWriter, FileWriter, PrintWriter - Features and Usage 13:53
• Lecture
  Comprehensive File Writing in Java: Creating a JSON Data File Challenge 14:57
• Lecture
  Mastering Java File Operations: Rename, Copy, Delete, and Move Files 09:19
• Lecture
  JavaFX Background Tasks 15:25
• Lecture
  Advanced File Copy and Delete: Recursive Directory Handling in Java 13:56
• Lecture
  Practical Directory Navigation: Building and Indexing a File System 09:29
• Lecture
  Deep Dive into Java's RandomAccessFile for Efficient Binary Data Handling 12:27
• Lecture
  Implementing Advanced Data Retrieval: RandomAccessFile Indexing in Java 08:47
• Lecture
  Random File Operations: Design a Program for Employee Data Management 08:42
• Lecture
  Mastering Binary Data I/O: Utilizing DataOutputStream and DataInputStream 11:26
• Lecture
  Introduction to Java Object Serialization: Persisting Objects to Files 11:19
• Lecture
  Advanced Serialization: Version Control, Transient Fields and Customisation 10:59

Mastering Java Concurrency and Multithreading 06:04:35

• Lecture
  Understanding Processes and Threads in Java: An Introductory Overview 05:24
• Lecture
  Data Binding 10:16
• Lecture
  Deep Dive into Java Thread States and Concurrent Thread Execution 10:08
• Lecture
  Implementing Multithreading: Concurrent Thread Creation Best Practices 10:25
• Lecture
  Managing and Manipulating Running Threads in Java: Sleep and Interrupt 14:34
• Lecture
  Applying Thread Concepts: Build a Multi-Threaded Application in Java 05:20
• Lecture
  Exploring Java's Memory Model: Heap vs. Thread Stack in Multithreading 12:39
• Lecture
  Advanced Concurrency: Interleaving, Atomicity, Memory Consistency Explained 10:49
• Lecture
  Implementing Synchronization: Mastering Synchronized Methods in Java 12:03
• Lecture
  Advanced Synchronization: Deep Dive into Synchronized Blocks in Java 10:47
• Lecture
  Building a Producer-Consumer Application in Java, Deadlock Exploration 09:42
• Lecture
  Preventing Deadlocks in Java: Practical Techniques Using Wait and Notify 07:36
• Lecture
  Service 14:34
• Lecture
  Producer Consumer Challenge: Build a Java Shoe Warehouse Fulfillment Center 08:36
• Lecture
  Explicit Locking in Java Concurrency: Exploring java.util.concurrent.locks 08:46
• Lecture
  Advanced Locking: Exploring the Benefits and Uses of ReentrantLock in Java 09:08
• Lecture
  Thread Management with ExecutorService: SingleThreadExecutorService in Java 13:55
• Lecture
  Efficient Thread Management: Exploring FixedThreadPool ExecutorService in Java 08:50
• Lecture
  Advanced Thread Pools: Exploring Callable, Submit, and Future in Java 15:04
• Lecture
  Practical Concurrency: ExecutorService Challenge in Java Development 11:01
• Lecture
  Java Concurrency: Mastering ScheduledExecutorService for Task Scheduling 13:13
• Lecture
  Java Concurrency: Exploring WorkStealingPool and ForkJoinPool Explained 14:32
• Lecture
  Parallel Streams in Java: Enhancing Performance with Concurrent Data Processing 09:29
• Lecture
  Challenge 1 and 2 09:09
• Lecture
  Deep Dive into Parallel Streams: Ordering, Reducing, and Collecting in Java 13:54
• Lecture
  Mastering Thread Safety: Synchronized and Concurrent Collections in Java 14:02
• Lecture
  Building Robust Applications: Thread-Safe Lists, Queues, and ArrayBlockingQueue 12:36
• Lecture
  Implementing Consumer Tasks: Mastering ArrayBlockingQueue in Java Concurrency 12:03
• Lecture
  Thread Contention: Understanding and Avoiding Deadlock, Livelock, Starvation 09:54
• Lecture
  Concurrency Challenges: Understanding and Avoiding Livelock in Java 16:08
• Lecture
  Preventing Thread Starvation: Implementing Fair Locks in Java Concurrency 08:03
• Lecture
  Exploring Advanced Java Concurrency: Atomic Variables and WatchService 12:03
• Lecture
  Implementing a File Watcher with Java's WatchService for Real-Time Monitoring 09:52

Mastering Java Database Connectivity: Interactions, Queries, and Frameworks 07:06:43

• Lecture
  Introduction to Java Database Connectivity (JDBC) and Relational Databases 04:32
• Lecture
  Step-by-Step MySQL Server and Workbench Installation Guide for Windows OS 21:47
• Lecture
  Installing MySQL Server & Workbench: A Comprehensive Guide for Mac Users 13:30
• Lecture
  Installing MySQL Server and Workbench on Linux: A Step-by-Step Guide 12:10
• Lecture
  Which JDK? 01:11
• Lecture
  Understanding Databases: RDBMS, Schema, Tables, SQL, DDL, and DML Explained 09:35
• Lecture
  Hands-On with MySQL Workbench: Creating, Importing, and Querying Databases 13:09
• Lecture
  JDBC Fundamentals: Connecting Java Applications to Databases with Drivers 06:59
• Lecture
  Establishing Database Connections in Java: DriverManager vs DataSource 12:02
• Lecture
  Retrieving Data with JDBC: Crafting and Executing SQL SELECT Queries 14:13
• Lecture
  Challenge 3,4 and 5 11:15
• Lecture
  Secure Coding with JDBC: Preventing SQL Injection and Using ANSI SQL Standards 12:54
• Lecture
  Mastering Statement.execute vs. Statement.executeQuery for Database Operations 13:06
• Lecture
  Comprehensive SQL Operations in Java: Updating, Deleting, & Inserting Data 13:08
• Lecture
  Efficient Database Updates: executeUpdate, Transactions, Commits, Rollback, and 15:12
• Lecture
  Creating the 'Store Front' Database: DDL Operations and SQL Exception Handling i 15:52
• Lecture
  Hands-On JDBC: Building a Database Application with Transactions & Data Operatio 16:23
• Lecture
  Preventing SQL Injection with Parameterized JDBC PreparedStatement Objects 12:51
• Lecture
  Enhancing Database Efficiency: Batch Processing with PreparedStatements 14:00
• Lecture
  Comprehensive JDBC Challenge: Transactions, Alter, Batch Processing Operations 15:04
• Lecture
  Leveraging Stored Procedures in Databases Through JDBC CallableStatement 15:08
• Lecture
  Challenge 6 and 7 11:00
• Lecture
  Mastering OUT and INOUT Parameters in JDBC with CallableStatement Objects 11:24
• Lecture
  Executing Database Functions Using CallableStatement and JDBC Escape Sequences 14:38
• Lecture
  Advanced JDBC Challenge: Calling Stored Procedures with IN and OUT Parameters 15:57
• Lecture
  An Overview of Object-Relational Mapping, JPA Providers, and Jakarta Persistence 15:35
• Lecture
  Implementing CRUD Database Operations in Java: Entity Lifecycle Management 16:33
• Lecture
  Establishing Table Relationships and Managing Related Data with JPA Entities 12:23
• Lecture
  Mastering Dynamic Data Retrieval with JPQL: Select, From, Where, and Joins 14:19
• Lecture
  Mastering Advanced JPQL Queries: Joins, Named Parameters, and Tuple Results 10:17
• Lecture
  Building Dynamic and Type-Safe JPA Queries: A Comprehensive CriteriaBuilder Guid 14:19
• Lecture
  Comprehensive JPA Challenge: Build Entities, Relationships, JPQL Queries 14:59
• Lecture
  Challenge 8 05:30
• Lecture
  Mastering JPA: Advanced CriteriaBuilder Queries with Dynamic Joins (Bonus) 05:48

Mastering Java Network Programming: Sockets, NIO, and Modern Frameworks 04:41:45

• Lecture
  Java Networking Fundamentals: Internet, Networks, and Core Java API Overview 02:13
• Lecture
  Essential Network Terminology: Hosts, Client-Server, Protocols, Ports & IP 12:39
• Lecture
  Building a Basic Java Client-Server Application with ServerSocket (TCP/IP) 13:17
• Lecture
  Enhancing Server Scalability: Implementing a Multi-Threaded Java Server 08:29
• Lecture
  Comparing ServerSocket and ServerSocketChannel: Blocking vs. Non-Blocking IO 09:42
• Lecture
  Deep Dive into Java NIO: Understanding Channels and Buffers for Networking 04:59
• Lecture
  Practical Java NIO: ByteBuffer Operations, Capacity, Limit, and Position 14:52
• Lecture
  Implementing Efficient Network Polling with Custom Java Channel Management 08:16
• Lecture
  Challenge 9 04:53
• Lecture
  Java Networking: Building Scalable Servers using Event-Driven Selectors 11:48
• Lecture
  Creating UDP Client and Server in Java using Datagram Sockets 09:33
• Lecture
  Streaming Audio over UDP: Building a Datagram Client-Server Application in Java 09:35
• Lecture
  Building an Asynchronous UDP Server in Java using DatagramChannel 09:16
• Lecture
  Navigating Java's High-Level APIs: Understanding URIs, URLs and Connections 10:54
• Lecture
  Decoding Relative vs. Absolute URIs and Converting to URLs in Java 11:40
• Lecture
  Getting Started with HttpURLConnection for Making HTTP Requests in Java 11:17
• Lecture
  Rapid Web Server Development: Setting Up a Simple Java HTTP Server 10:24
• Lecture
  Sending Data with HTTP POST Requests Using Java's HttpURLConnection 08:46
• Lecture
  Modern Java Networking: Transitioning to HttpClient for HTTP/2 and Beyond 12:49
• Lecture
  Streamlining HTTP POST Requests and Responses with Java's HttpClient 10:25
• Lecture
  Java Asynchronous HTTP Requests: Leveraging CompletableFuture with HttpClient 14:25
• Lecture
  Exploring CompletableFuture: thenAccept, thenApply and thenRun methods 12:30
• Lecture
  Executing Multiple Concurrent HTTP Requests Using Java's HttpClient 12:37
• Lecture
  Challenge: Submitting multiple concurrent POST HTTP requests using HttpClient 09:30
• Lecture
  Creating a Custom Thread Safe Body Handler for Java HttpClient Responses 13:24
• Lecture
  Understanding WebSockets: Real-Time, Bidirectional Communication in Java 11:18
• Lecture
  Build a Java WebSocket Chat Application: Client and Server Implementation 12:14

Debugging and Testing in Java: A Comprehensive Guide 02:51:13

• Lecture
  Mastering the IntelliJ Debugger: A Practical Introduction 17:57
• Lecture
  Advanced Debugging Techniques: Stepping, Watches & Control 11:24
• Lecture
  Field Watchpoints, Debugging: Track Variable Changes 16:14
• Lecture
  Mastering Smart Step Into, Set Value & Third-Party Source 10:14
• Lecture
  Mastering Unit Testing Essentials & JUnit Framework in Java 16:20
• Lecture
  Installing JDK 11 on Windows 05:41
• Lecture
  Mastering Assertions: Essential Techniques for JUnit Testing 18:19
• Lecture
  JUnit Assertions: Beyond the Basics & Exception Handling 16:34
• Lecture
  Parameterized Tests: Efficient Data-Driven Testing in JUnit 12:21
• Lecture
  Hands-On JUnit: Challenges to Hone Your Testing Skills - 1&2 21:41
• Lecture
  Completing JUnit Challenges 3 to 7: Advanced Techniques 12:22
• Lecture
  JUnit Final Challenges : Mastering Scenarios 8,9 and 10 12:06

Comprehensive JavaFX UI Design 10:19:07

• Lecture
  Configuring JavaFX with JDK 11+: Setting Up Global Libraries 05:05
• Lecture
  Step-by-Step Guide to Creating Your First JavaFX Application 06:00
• Lecture
  JavaFX Fundamentals: MVC, Application Lifecycle, and Stages 09:48
• Lecture
  Building a JavaFX "Hello World" Program: FXML vs. Code 10:55
• Lecture
  Mastering JavaFX GridPane Layout: Positioning and Sizing Controls 15:34
• Lecture
  Maximising space with the JavaFX Hbox layout 13:11
• Lecture
  Mastering the JavaFX BorderPane Layout for Application Design 13:16
• Lecture
  Exploring JavaFX Layouts: FlowPane, TilePane, and StackPane 17:09
• Lecture
  Exploring JavaFX Controls: Buttons, Labels, and User Interaction 15:17
• Lecture
  Implementing Radio Buttons & Checkboxes in JavaFX Applications 17:02
• Lecture
  JavaFX User Input: Combo Box and Choice Box Controls Deep Dive 17:13
• Lecture
  JavaFX Interactive Controls: Slider, Spinner, ColorPicker, DatePicker 14:30
• Lecture
  Installing and Configuring IntelliJ IDEA on Windows 10:30
• Lecture
  JavaFX TitledPane and Accordion: Organizing UI Elements 06:42
• Lecture
  Mastering JavaFX Event Handling: Responding to User Actions 14:29
• Lecture
  Advanced JavaFX Event Handling: Parameters and Best Practices 14:38
• Lecture
  Optimizing JavaFX Applications: Mastering the UI Thread and Event Handling 14:40
• Lecture
  Concurrency in JavaFX: Implementing Background Tasks with Threads & Runnable 16:17
• Lecture
  JavaFX Project: Creating a To-Do List Application & Data Model Setup 12:59
• Lecture
  JavaFX ListView: Populating, Single Selection Mode & Event Handling Basics 13:28
• Lecture
  JavaFX Event Handling: Adding a Change Listener for Dynamic UI Updates 14:17
• Lecture
  JavaFX Date Formatting: Enhancing the User Interface with Date Formatting 07:03
• Lecture
  Implementing Singletons: Best Practices for Java Application Development 15:04
• Lecture
  JavaFX Disk Operations: Loading and Saving Data using the File System 16:25
• Lecture
  JavaFX Dialogs: Building User Input Forms with DialogPane and GridPane 16:31
• Lecture
  JavaFX Dialogs, Handling User Input and Displaying Program Output 14:33
• Lecture
  Bug Fixing, Data Binding, and UI Updates in JavaFX ToDo List App 10:27
• Lecture
  Data Binding Mastery: Implementing Observable Lists for Dynamic UI in JavaFX 11:20
• Lecture
  JavaFX Cell Factories: Customizing ListView Display and Highlighting Items 14:44
• Lecture
  JavaFX Context Menus: Implementing Right-Click Functionality for ListViews 15:37
• Lecture
  Installing JDK 11 on a Mac 02:46
• Lecture
  Implementing Key Events and Toolbars for Enhanced Functionality 15:41
• Lecture
  Enhancing JavaFX Applications Implementing Sorted Lists for Dynamic Data Display 12:44
• Lecture
  Filtering Data in JavaFX: Utilizing FilteredList for Dynamic Content Management 16:18
• Lecture
  Elevating Visuals: Enhancing Appearance with CSS Styling 17:39
• Lecture
  JavaFX Transformations: Mastering Node Rotation, Scaling, and Visual Effects 16:37
• Lecture
  Implementing File and Directory Choosers in JavaFX for Enhanced File Access 22:11
• Lecture
  Leveraging SceneBuilder: A Visual Approach to JavaFX UI Design within IntelliJ 03:23
• Lecture
  Installing and Setting up Scenebuilder on Windows 05:00
• Lecture
  Installing SceneBuilder for macOS: Step-by-Step Setup and IntelliJ Integration 03:39
• Lecture
  SceneBuilder Deep Dive: Exploring the Interface, Layouts, and Control Properties 07:15
• Lecture
  Constructing a Basic UI Layout, using SceneBuilder for JavaFX Development 15:49
• Lecture
  Deep Dive Into SceneBuilder's Code Section and CSS 17:27
• Lecture
  Contacts Manager Project, Part One, Setting up Project 15:14
• Lecture
  Contacts Manager Project, Part Two, Design and Layout 13:16
• Lecture
  Contacts Manager Project, Part Three, Show Dialog, Button Press and Contact 16:07
• Lecture
  Contacts Application: Enhancing Functionality with Edit and Delete Features 14:02
• Lecture
  JavaFX Contact Deletion, Confirmation, and Table Resizing Implementation 09:15

Deep Dive into the Java 9 Module System: JPMS Fundamentals 25:21

• Lecture
  Comprehensive Introduction to Java Modules: Concepts, Goals, and Structure 06:21
• Lecture
  Mastering Java Module Declarations and Statements: Requires, Exports, and Opens 02:08
• Lecture
  Installing and Configuring IntelliJ IDEA on a Mac 11:13
• Lecture
  Exploring Java Module Types: Named, Unnamed, Automatic, Open, and Aggregator 05:39

Migrating Existing Java Projects to Java 9 and the Module System 01:04:58

• Lecture
  Project Setup and Initial JDK 8 & 9 Compatibility Testing for Migration 07:23
• Lecture
  Strategically Structuring a Java Project for Modularization in JDK 9 04:01
• Lecture
  Creating the First Module (Common): Package Migration and Dependency Resolution 12:04
• Lecture
  Module Descriptor File Creation and Resolution of JavaFX Runtime Errors 13:25
• Lecture
  Creating the Second Module (Database): Dependency Management and Code Migration 10:44
• Lecture
  Challenge: Create and Configure the UI Module, Resolving Dependencies 09:52
• Lecture
  Understanding and Implementing Transitive Dependencies for Simplified Module 07:29

Course Introduction - Old content for Java 11 16:39

• Lecture
  Introduction To The Course 02:27
• Lecture
  Remaster in Progress 03:09
• Lecture
  Video Quality 01:16
• Lecture
  Subtitles 02:46
• Lecture
  How to Get Help 04:54
• Lecture
  Important Tip - Source Code 02:07

Software Tools Setup - Old content for Java 11 43:57

• Lecture
  Biggest Tip to Succeed as a Java Programmer 01:15
• Lecture
  The Four Stages of Becoming a Programmer 00:42
• Lecture
  Installing JDK 11 on a Linux Machine 07:20
• Lecture
  Software Tools Introduction 01:12
• Lecture
  Java Development Kit Installation Overview 01:42
• Lecture
  Install JDK 11 for Windows 02:47
• Lecture
  Installing Intellij IDEA for Windows 06:35
• Lecture
  ** IMPORTANT ** - Configuring IntelliJ IDEA 00:16
• Lecture
  Install JDK 11 for Mac 02:11
• Lecture
  Installing Intellij IDEA for Mac 04:57
• Lecture
  Install JDK 11 for Linux 04:33
• Lecture
  Installing Intellij IDEA for Linux 05:22
• Lecture
  Configuring IntelliJ IDEA - WINDOWS, MAC and LINUX 05:05

First Steps - Old content for Java 11 03:17:48

• Lecture
  Introduction 01:18
• Lecture
  Hello World Project 06:36
• Lecture
  Defining the Main Method 07:20
• Lecture
  Hello World Challenge and Common Errors 03:18
• Lecture
  Variables 09:03
• Lecture
  Installing and Configuring IntelliJ IDEA on a Linux Machine 11:37
• Lecture
  Starting out with Expressions 07:05
• Lecture
  Primitive Types 11:35
• Lecture
  byte, short, long and width 10:18
• Lecture
  Casting in Java 04:06
• Lecture
  Primitive Types Challenge 04:23
• Lecture
  float and double Primitive Types 07:00
• Lecture
  Floating Point Precision and a Challenge 10:22
• Lecture
  The char and boolean Primitive Data Types 10:20
• Lecture
  Primitive Types Recap and the String Data Type 12:56
• Lecture
  Operators, Operands and Expressions 08:50
• Lecture
  Abbreviating Operators 04:12
• Lecture
  if-then Statement 09:16
• Lecture
  Logical and Operator 06:24
• Lecture
  Logical OR Operator 06:11
• Lecture
  Assignment Operator VS Equals to Operator 07:31
• Lecture
  Ternary Operator 04:10
• Lecture
  Operator Precedence and Operator Challenge 11:44
• Lecture
  First Steps - Creating your first Java Program 18:43
• Lecture
  First Steps Summary 01:29
• Lecture
  End of Remaster 02:01

Java Tutorial: Expressions, Statements, and More - Old content for Java 11 03:33:39

• Lecture
  Introduction 00:31
• Lecture
  Keywords And Expressions 07:18
• Lecture
  Statements, Whitespace and Indentation (Code Organization) 09:24
• Lecture
  Code Blocks And The If Then Else Control Statements 17:08
• Lecture
  if then else Recap 04:19
• Lecture
  Methods In Java 18:03
• Lecture
  More On Methods And A Challenge 15:34
• Lecture
  Method Challenge - Final Code Changes 07:27
• Lecture
  DiffMerge Tool Introduction 01:54
• Lecture
  Install DiffMerge 02:01
• Lecture
  Using DiffMerge 17:29
• Lecture
  Coding Exercises 13:24
• Lecture
  Coding Exercises Example Part 1 11:08
• Lecture
  Coding Exercises Example Part 2 11:53
• Lecture
  Coding Exercises Example Part 3 09:50
• Lecture
  Method Overloading 27:01
• Lecture
  Exploring IntelliJ IDEA 10:36
• Lecture
  Method Overloading Recap 03:38
• Lecture
  Seconds and Minutes Challenge 13:49
• Lecture
  Bonus Challenge Solution 11:12

Control Flow Statements - Old content for Java 11 02:56:54

• Lecture
  Introduction 00:38
• Lecture
  The switch statement (+Challenge Exercise) 18:39
• Lecture
  Day of the Week Challenge 10:47
• Lecture
  The for Statement (+Challenge Exercise) 25:02
• Lecture
  For Loop Recap 07:59
• Lecture
  Sum 3 and 5 Challenge 06:13
• Lecture
  The while and do while statements (+Challenge Exercise) 24:21
• Lecture
  While and Do While Recap 07:58
• Lecture
  Digit Sum Challenge 10:29
• Lecture
  Parsing Values from a String 11:24
• Lecture
  Reading User Input 12:26
• Lecture
  Problems and Solutions 10:20
• Lecture
  Reading User Input Challenge 15:06
• Lecture
  Min and Max Challenge 15:32

Arrays, Java inbuilt Lists, Autoboxing and Unboxing - Old content for Java 11 01:23:41

• Lecture
  Arrays 21:27
• Lecture
  Arrays (Challenge Exercise) 16:20
• Lecture
  Arrays Recap 07:19
• Lecture
  References Types vs Value Types 16:13
• Lecture
  Minimum Element Challenge 11:51
• Lecture
  Reverse Array Challenge 10:31

Variables, Datatypes and Operators 02:58:38

• Lecture
  ArrayList Part 2 20:11
• Lecture
  ArrayList Part 3 16:48
• Lecture
  ArrayList Challenge Part 1 14:00
• Lecture
  ArrayList Challenge Part 2 18:12
• Lecture
  ArrayList Challenge Part 3 10:49
• Lecture
  Bug Fix for ArrayList Challenge 06:40
• Lecture
  Autoboxing and Unboxing 16:16
• Lecture
  Autoboxing & Unboxing (Challenge Exercise) - Part 1 16:49
• Quiz
  Sorted Array 1 question
• Lecture
  Autoboxing & Unboxing (Challenge Exercise) - Part 2 17:08
• Lecture
  Autoboxing & Unboxing (Challenge Exercise) - Part 3 09:32
• Lecture
  LinkedList Part 1 16:43
• Lecture
  LinkedList Part 2 15:30

OOP Part 1 - Classes, Constructors and Inheritance - Old content for Java 11 01:39:57

• Lecture
  LinkedList Challenge Part 1 15:05
• Lecture
  Introduction 00:36
• Lecture
  Bug Fix for "Track 1" Error 01:03
• Lecture
  Classes Part 1 16:31
• Lecture
  LinkedList Challenge Part 2 17:20
• Lecture
  Classes Part 2 13:27
• Lecture
  LinkedList Challenge Part 3 (Final video) 15:45
• Lecture
  Constructors - Part 1 (+Challenge Exercise) 20:10

Inner and Abstract Classes & Interfaces - Old content for Java 11 03:35:11

• Lecture
  Interfaces 12:34
• Lecture
  Inheritance - Part 1 19:39
• Lecture
  Interfaces Part 2 14:30
• Lecture
  Inheritance - Part 2 13:24
• Lecture
  Interfaces Challenge Part 1 18:11
• Lecture
  Reference vs Object vs Instance vs Class 06:52
• Lecture
  Interfaces Challenge Part 2 09:00
• Lecture
  this vs super 06:52
• Quiz
  Positive, Negative or Zero 1 question
• Lecture
  Inner classes Part 1 17:10
• Lecture
  Method Overloading vs Overriding Recap 07:32
• Lecture
  Inner Classes Part 2 14:44
• Lecture
  Static vs Instance Methods 04:10
• Lecture
  Inner Classes Challenge 11:57
• Lecture
  Static vs Instance Variables 04:17
• Lecture
  Abstract Classes Part 1 16:42
• Lecture
  Inheritance Challenge Part 1 (+Challenge Exercise) 16:38
• Lecture
  Abstract Classes Part 2 10:55
• Lecture
  Inheritance Challenge Part 2 10:04

OOP Part 2 - Composition, Encapsulation, and Polymorphism - Old content for Java 01:24:38

• Lecture
  Abstract Class Challenge Part 1 19:46
• Lecture
  Introduction 00:37
• Lecture
  Abstract Class Challenge Part 2 12:53
• Lecture
  Composition 17:19
• Lecture
  Abstract Class Challenge Part 3 (includes recursion). 19:46
• Lecture
  Composition Part 2 (+Challenge Exercise) 14:17

Java Generics - Old content for Java 11 02:33:10

• Lecture
  Generics Introduction 11:12
• Lecture
  Encapsulation (+Challenge Exercise) 15:15
• Lecture
  Our Generics Class 11:37
• Lecture
  Polymorphism 20:35
• Lecture
  Our Generics Class Part 2 18:57
• Lecture
  Polymorphism (+Challenge Exercise) 18:46
• Lecture
  Our Generics Class Part 3 10:13
• Lecture
  OOP Master Challenge Exercise 16:41
• Lecture
  Generics Challenge 13:08
• Lecture
  OOP Challenge - Solution 16:46

Lambda Expressions - Old content for Java 11 02:22:39

• Lecture
  Lambda Expressions Introduction 15:32
• Lecture
  Lambda Expressions Continued 14:50
• Lecture
  Lambda Expressions Nested Blocks 14:45
• Lecture
  Scope and Functional Programming 15:02
• Lecture
  Functional Interfaces & Predicates 16:37
• Quiz
  Minimum Element 1 question
• Lecture
  More on Predicates & Suppliers 12:06
• Lecture
  Functions 13:11
• Lecture
  Chaining java.util.function Functions 11:56
• Lecture
  Lambda Challenge Part 1 12:07
• Lecture
  Lambda Challenge Part 2 16:33

Streams - Old content for Java 11 48:26

• Lecture
  Streams 13:50
• Lecture
  Streams - Intermediate and Terminal Operations 13:06
• Lecture
  Streams - Flatmap & Lambda Best Practices 21:30

Naming Conventions and Packages. static and final - Old content for Java 11 02:31:28

• Lecture
  Naming Conventions 07:09
• Lecture
  Packages 17:40
• Quiz
  Reverse Array 1 question
• Lecture
  Packages Part 2 11:40
• Lecture
  Packages Part 3 12:05
• Lecture
  Packages (Challenge Exercise) 13:28
• Lecture
  Scope 17:25
• Lecture
  Scope Part 2 and Visibility 12:07
• Lecture
  Scope +(Challenge Exercise) 06:53
• Lecture
  Access Modifiers 16:51
• Lecture
  The static statement 12:32
• Lecture
  The final statement 14:37
• Lecture
  Final Part 2 and Static Initializers 09:01

Java Collections - Old content for Java 11 06:38:57

• Lecture
  Collections Overview 15:47
• Lecture
  Binary Search 15:39
• Lecture
  Your Programming Careers Questions Answered 01:53
• Lecture
  Collections List Methods 18:23
• Lecture
  Comparable and Comparator 18:55
• Lecture
  Maps 16:51
• Lecture
  Map Continued and Adventure Game 16:33
• Lecture
  Adding Exits to the Adventure game 18:04
• Lecture
  Adventure Game challenge 08:13
• Quiz
  Adventure Game 1 question
• Lecture
  Immutable Classes 15:42
• Lecture
  Immutable Class Challenge 04:32
• Lecture
  Sets & HashSet 19:52
• Lecture
  HashSet - equals() and hashCode() 16:52
• Lecture
  Finish off equals() and hashcode() 10:56
• Lecture
  Potential issue with equals() and sub-classing 11:59
• Lecture
  Sets - Symmetric & Asymmetric 15:34
• Lecture
  Finishing Off Sets 09:16
• Lecture
  Sets Challenge Part 1 15:26
• Lecture
  Access to Programming Career Q&A 00:29
• Lecture
  Sets Challenge Part 2 12:50
• Lecture
  Sets Challenge Part 3 18:17
• Lecture
  Sorted Collections 13:11
• Lecture
  StockList Class With Maps 17:05
• Lecture
  Introduction 00:27
• Lecture
  Add a Basket 15:49
• Lecture
  TreeMap and Unmodifiable Maps 20:50
• Lecture
  Challenge Part 1 12:40
• Lecture
  Challenge Part 2 10:52
• Lecture
  Challenge Part 3 07:56
• Lecture
  Challenge Part 4 (Final) 18:04

Basic Input & Output including java.util - Old content for Java 11 08:55:34

• Lecture
  Exceptions 14:00
• Lecture
  Stack Trace and Call Stack 13:04
• Lecture
  Catching and throwing Exceptions 14:20
• Lecture
  Multi Catch Exceptions 08:06
• Lecture
  Introduction to I/O 15:55
• Lecture
  Writing content - FileWriter class and Finally block 14:57
• Lecture
  What Are Variables? 15:13
• Lecture
  Try with Resources 12:12
• Lecture
  FileReader and Closeable 12:55
• Lecture
  BufferedReader 12:59
• Lecture
  Load Big Location and Exits Files 07:29
• Lecture
  Challenge 05:01
• Lecture
  Buffered Writer and Challenge 13:11
• Lecture
  Byte Streams 15:45
• Lecture
  Reading Binary Data and End of File Exceptions 15:44
• Lecture
  Object Input Output including Serialization 14:15
• Lecture
  Finish Object I/O and RandomAccessFile class 16:03
• Lecture
  Create Random Access File 14:29
• Lecture
  Update Static Initializer Block With Random File Access 11:37
• Lecture
  Update Adventure Game to Read Random Access File 14:20
• Lecture
  Java NIO 14:47
• Lecture
  Writing Objects With Java NIO 11:36
• Lecture
  Reading and Writing with Java NIO 15:47
• Lecture
  Writing Binary Files with Java NIO 13:36
• Lecture
  Getting To Know Primitive Data Types - The Byte, Short, Int And Long 18:45
• Lecture
  Reading Files with NIO 15:47
• Lecture
  Absolute and Relative Reads 11:10
• Lecture
  Chained Put Methods 13:55
• Lecture
  Writing Sequentially 13:04
• Lecture
  FileChannel to Copy Files and Pipes with Threads 15:04
• Lecture
  Filesystem 18:02
• Lecture
  More on Paths 12:17
• Lecture
  Exists and CopyFile 11:59
• Lecture
  Move, Rename and Delete 11:16
• Lecture
  File Attributes 12:50
• Lecture
  Read Existing Directory Contents 14:15
• Lecture
  Separators Temp Files and File Stores 12:25
• Lecture
  Walk File Tree 11:33
• Lecture
  Copy Entire Tree 12:58
• Lecture
  Mapping IO and NIO Methods 12:53

Regular Expressions - Old content for Java 11 01:54:14

• Lecture
  Regular Expressions Introduction 16:21
• Lecture
  Character classes and Boundary Matchers 13:55
• Lecture
  Quantifiers and the Pattern and Matcher classes 14:42
• Lecture
  Matcher find and Group Methods 15:03
• Lecture
  And, Or & Not 15:26
• Lecture
  Regular Expressions Challenge Part 1 17:04
• Lecture
  Regular Expressions Challenge Part 2 15:30
• Lecture
  Regular Expressions Challenge Part 3 06:13

Databases - Old content for Java 11 08:12:20

• Lecture
  Section Introduction 01:55
• Lecture
  Database Terminology 10:32
• Lecture
  Getting To Know Primitive Data Types - Float And Double 12:57
• Lecture
  Install and Setup SQLite for Windows 07:56
• Lecture
  Install and Setup SQLite for Mac 02:00
• Lecture
  Install and Setup SQLite for Linux 02:38
• Lecture
  Introduction to SQLite 11:15
• Lecture
  More with SQLite 10:42
• Lecture
  Querying Data With SQL 16:02
• Lecture
  SQL Order by and Joins 13:11
• Lecture
  More Complex Joins 11:44
• Lecture
  Wildcards in Queries and Views 15:17
• Lecture
  Housekeeping and Final SQL Challenge 14:17
• Lecture
  JDBC and SQLite GUI Browser 15:49
• Lecture
  Creating Databases With JDBC in Java 17:26
• Lecture
  JDBC Insert, Update, Delete 15:49
• Lecture
  .executeQuery() and using Constants 20:39
• Lecture
  The Music SQLite Database 12:43
• Lecture
  Write Java Query for Artists 14:46
• Lecture
  Getting To Know Primitive Data Types - Char And Boolean 07:22
• Lecture
  Executing SQL in DB Browser 17:18
• Lecture
  Query Albums by Artist Method 16:23
• Lecture
  Query Artists for Song method 15:03
• Lecture
  Result Set Meta Data 14:38
• Lecture
  Functions and Views 16:38
• Lecture
  Write the Method to Query View 11:48
• Lecture
  SQL Injection Attacks and Prepared Statements 17:01
• Lecture
  Transactions 13:40
• Lecture
  Inserting Records With JDBC 10:08
• Lecture
  Insert Albums, Artists, and Songs 14:00
• Lecture
  Test Insert JDBC Code 18:07
• Lecture
  JDBC with a GUI Program 17:53
• Lecture
  Add Artists 12:35
• Lecture
  Fix Artist and Preload Records 13:23
• Lecture
  Understanding Strings And Finishing Up Primitive Data Types 11:56
• Lecture
  Implement Artist Query 11:57
• Lecture
  Add ProgressBar 09:38
• Lecture
  Handling Updates 15:14

Java Networking Programming - Old content for Java 11 02:23:48

• Lecture
  Networking Overview 09:39
• Lecture
  First Client and Server Apps 15:02
• Quiz
  Adventure Game 1 question
• Lecture
  Multi Threaded Server 14:04
• Lecture
  Multi-Threading and Timeouts 12:46
• Lecture
  UDP Server and Client 18:13
• Lecture
  High Level APIS 18:55
• Lecture
  URL Connections and Input Stream Reader 16:06
• Lecture
  HTTPUrlConnection 17:57
• Lecture
  Alternatives to HTTPUrlConnection 21:06

Archived Videos 30:58

• Lecture
  Old JavaFX Introduction Video for JDK 8 17:31
• Lecture
  Old JavaFX Code Vs FXml Video for JDK 8 13:27

Extra Information - Source code, and other stuff 03:01:42

• Lecture
  Source code for all Programs 28:53
• Lecture
  Bonus Lecture and Information 05:01
• Lecture
  More On Operators And Operator Precedence 19:21
• Lecture
  Getting Started With This Course 07:58
• Lecture
  Which version of Java should you use? 05:16
• Lecture
  Install JDK 10 on Windows 04:48
• Lecture
  Install and Configure Intellij on Windows 09:53
• Lecture
  Free 90 Day Extended Trial of IntelliJ Ultimate Edition Now Available 01:42
• Lecture
  Install JDK 10 on a Mac 02:19
• Lecture
  Install and Configure Intellij on a Mac 09:40
• Lecture
  Install JDK 10 on Linux 04:36
• Quiz
  Adventure Game 1 question
• Quiz
  Immutable Class 1 question
• Lecture
  Install and Configure Intellij on Linux 09:39
• Quiz
  Sets 1 question
• Lecture
  Free 90 Day Extended Trial of IntelliJ Ultimate Edition Now Available 01:42
• Lecture
  Introduction 00:37
• Lecture
  Creating Your First Java Project 12:10
• Lecture
  Exploring The IntelliJ Interface 07:24
• Lecture
  Work in Progress 01:05
• Lecture
  Keywords and Naming Conventions 07:31
• Lecture
  Naming Conventions Challenge 03:39
• Lecture
  Operator Associativity 07:07
• Lecture
  Declaration and Expression Statements 07:32
• Lecture
  Expression Statements, Prefix and Postfix 14:35
• Lecture
  Whitespace 09:14

Course Remaster in Progress 01:36:29

• Lecture
  Code Blocks and Indentation 12:27
• Lecture
  Code Blocks and if, then, and else 09:39
• Lecture
  Boolean, Naming Conventions and Scope 07:11
• Lecture
  Challenge and Code Duplication 09:24
• Lecture
  Defining Methods 08:38
• Lecture
  Executing Methods 03:29
• Lecture
  Method Parameters Overview 09:37
• Lecture
  Removing Code Duplication 06:50
• Lecture
  Returning Data from a Method 08:49
• Lecture
  Using Data from a Method Call 03:03
• Lecture
  Method Recap and Challenge 05:46
• Lecture
  Method Challenge Solution 10:31
• Lecture
  Downloading Slides 00:17
• Lecture
  Bonus - Please Watch! 00:48

Remaster - Course Introduction 02:14

• Lecture
  Checkout my other 42 Udemy courses 00:35
• Lecture
  Extending Trial for IntelliJ Ultimate Edition 01:39

Remaster - Setup and First Steps 28:02

• Lecture
  Which Version of the JDK 01:11
• Lecture
  Link to Important Java Development Kit Youtube Video 00:20
• Quiz
  MegaBytes Converter 1 question
• Lecture
  Installation Overview 04:27
• Lecture
  Link to Important Java Development Kit Youtube Video 00:19
• Quiz
  Number In Word 1 question
• Lecture
  Source code for all Programs 21:45
• Quiz
  Speed Converter 1 question

New Coding Exercises

• Lecture
  Download Slides 00:00
• Quiz
  Input Calculator 1 question
• Quiz
  Positive, Negative or Zero 1 question