Java Course

Lesson 1 • Java Platform and Ecosystem Overview

Covers JVM, JDK, and JRE roles and how Java achieves platform independence. Grounds students in the architecture before writing any code.

Lesson 2 • Primitive Data Types and Variables

Explains the eight primitive types, variable declaration, and type casting rules. Students gain precise control over data representation in memory.

Lesson 3 • Java Syntax and Program Structure

Introduces classes, methods, and the main entry point as the skeleton of every Java program. Builds the syntactic foundation all later chapters depend on.

Lesson 4 • Installing and Configuring the Development Environment

Guides installation of JDK and a modern IDE, then verifies the setup with a first compilation. Ensures every student has a functional workspace from day one.

Lesson 1 • Recursion Fundamentals

Introduces recursive thinking with base cases and recursive calls. Prepares students for tree traversal and divide-and-conquer patterns in later chapters.

Lesson 2 • Looping Constructs

Covers for, while, and do-while loops along with loop control statements. Students learn to iterate over data and avoid common infinite-loop pitfalls.

Lesson 3 • Defining and Calling Methods

Explains method signatures, return types, and invocation mechanics. Establishes reusability as a core design principle applied throughout the course.

Lesson 4 • Scope, Lifetime, and Variable Shadowing

Defines block scope, local variables, and shadowing risks. Prevents subtle bugs that arise when variable names collide across nested scopes.

Lesson 1 • Polymorphism and Dynamic Dispatch

Demonstrates runtime polymorphism through reference types and method dispatch. Students write flexible code that operates on families of related types.

Lesson 2 • Classes, Objects, and Constructors

Defines class blueprints, object instantiation, and constructor overloading. Translates real-world entities into Java class designs.

Lesson 3 • Encapsulation and Access Modifiers

Covers public, private, and protected access levels with getter/setter patterns. Enforces data hiding as the first pillar of OOP.

Lesson 4 • Abstract Classes and Interfaces

Contrasts abstract classes with interfaces and explains when to use each. Completes the OOP foundation needed for design patterns and frameworks.

Lesson 1 • Lists and the ArrayList Class

Introduces the List interface and ArrayList as the most-used collection. Bridges raw arrays to the full Collections Framework introduced next.

Lesson 2 • Arrays and Multidimensional Arrays

Covers array declaration, initialization, and traversal including 2D arrays. Provides the low-level data structure baseline before introducing collections.

Lesson 3 • Sorting and Searching Collections

Applies Comparable, Comparator, and Collections utility methods for ordering. Prepares students for algorithm-level thinking used in advanced chapters.

Lesson 4 • String Manipulation and Immutability

Explains String immutability, the string pool, and key String API methods. Students handle text processing tasks correctly and efficiently.

Lesson 1 • Try-Catch-Finally and Multi-Catch

Covers try-catch blocks, multi-catch syntax, and the finally clause for cleanup. Students handle multiple failure modes without duplicating recovery code.

Lesson 2 • Try-With-Resources and AutoCloseable

Introduces automatic resource management for I/O and database connections. Eliminates resource leaks that arise from manual close calls in finally blocks.

Lesson 3 • Creating Custom Exceptions

Guides design of domain-specific exception classes with meaningful messages. Enables APIs to communicate failure context clearly to callers.

Lesson 4 • Debugging Techniques and Tools

Covers IDE debugger usage, stack trace reading, and logging basics. Students locate and fix defects systematically rather than relying on print statements.

Lesson 1 • Generics and Type Parameters

Explains generic classes, methods, and bounded type parameters. Eliminates unsafe casts and enables reusable, type-safe data structures.

Lesson 2 • The Streams API

Teaches stream creation, intermediate operations, and terminal operations for collection processing. Replaces verbose loops with declarative, pipeline-style data transformations.

Lesson 3 • Functional Interfaces and Lambda Expressions

Introduces @FunctionalInterface, lambda syntax, and method references. Enables passing behavior as data, a prerequisite for the Streams API.

Lesson 4 • Built-In Functional Interfaces

Covers Predicate, Function, Consumer, Supplier, and BiFunction from java.util.function. Students compose reusable behavioral building blocks for stream pipelines.

Lesson 1 • Byte and Character Streams

Explains InputStream, OutputStream, Reader, and Writer hierarchies with buffering. Students handle binary and text data efficiently without resource leaks.

Lesson 2 • Networking with Sockets and HTTP

Covers TCP socket programming and the HttpClient API for HTTP requests. Students build simple client-server communication programs.

Lesson 3 • Working with JSON and Text Formats

Introduces JSON parsing and generation using a standard library. Prepares students for REST API integration covered in supplementary chapters.

Lesson 4 • Object Serialization and Deserialization

Teaches Serializable, ObjectOutputStream, and versioning with serialVersionUID. Students persist object graphs to disk and restore them reliably.

Lesson 1 • Synchronization and Shared State

Covers synchronized blocks, intrinsic locks, and the volatile keyword. Students eliminate race conditions and visibility bugs in shared-memory programs.

Lesson 2 • Executor Framework and Thread Pools

Introduces ExecutorService, thread pool types, and Future for async results. Replaces raw thread management with scalable, configurable execution policies.

Lesson 3 • Concurrent Collections and Atomic Variables

Covers ConcurrentHashMap, CopyOnWriteArrayList, and AtomicInteger for lock-free operations. Students avoid coarse-grained locking that limits throughput.

Lesson 4 • CompletableFuture and Async Pipelines

Teaches CompletableFuture chaining, exception handling, and combining multiple async tasks. Students build non-blocking pipelines that maximize CPU utilization.