Java Language 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

Teaches all eight primitive types, variable declaration, and type ranges. Provides the data foundation required for every subsequent programming concept.

Lesson 3 • Installing and Configuring the JDK

Guides installation of a current LTS JDK and configuration of PATH and JAVA_HOME. Ensures every student has a consistent, functional baseline environment.

Lesson 4 • Type Casting and Basic Input/Output

Explains widening and narrowing conversions and introduces console I/O via Scanner and System.out. Prepares students to handle real data in programs.

Lesson 5 • Operators and Expressions

Covers arithmetic, relational, logical, bitwise, and assignment operators with precedence rules. Enables students to construct correct, predictable expressions.

Lesson 1 • Switch Statements and Expressions

Teaches traditional switch statements and modern switch expressions with arrow syntax. Demonstrates cleaner multi-branch logic as an alternative to if-else chains.

Lesson 2 • Loop Constructs: for and while

Introduces counted for loops and condition-driven while loops with practical iteration patterns. Enables repetitive task automation in programs.

Lesson 3 • Loop Control: break, continue, and Labels

Explains how break and continue alter loop execution and how labels target nested loops. Gives precise control over complex iteration scenarios.

Lesson 4 • Debugging and Tracing Control Flow

Introduces IDE debugger tools and manual tracing techniques to verify logic correctness. Builds systematic problem-solving habits essential for all future chapters.

Lesson 1 • Variable Scope and Lifetime

Defines local, block, and parameter scope and explains when variables are created and destroyed. Prevents scope-related bugs and clarifies memory usage.

Lesson 2 • Method Overloading

Teaches how to define multiple methods with the same name but different parameter lists. Enables flexible APIs that handle varied input types cleanly.

Lesson 3 • Parameter Passing and Return Values

Explains pass-by-value semantics for primitives and references, and how to return data. Prevents common bugs caused by misunderstanding Java's argument-passing model.

Lesson 4 • Recursion Fundamentals

Introduces recursive method design with base cases and recursive cases. Prepares students for tree traversal and divide-and-conquer algorithms in later chapters.

Lesson 1 • String API and Text Processing

Covers essential String methods for searching, slicing, transforming, and comparing text. Equips students to process real-world textual data effectively.

Lesson 2 • String Basics and Immutability

Explains String creation, the string pool, immutability, and equality comparison. Prevents the most common String-related bugs in Java programs.

Lesson 3 • Single-Dimensional Arrays

Covers array declaration, initialisation, indexing, and iteration. Provides the primary fixed-size data structure used throughout Java programming.

Lesson 4 • Multi-Dimensional Arrays

Teaches 2D and jagged array creation and traversal for matrix-style data. Extends single-array skills to grid and table representations.

Lesson 1 • Classes, Objects, and References

Introduces class definition, object instantiation, and reference semantics. Establishes the core OOP mental model students will use throughout the course.

Lesson 2 • Object Lifecycle and Garbage Collection

Explains object creation, reachability, and JVM garbage collection basics. Builds awareness of memory management without requiring manual deallocation.

Lesson 3 • Encapsulation and Access Modifiers

Teaches private fields with public getters and setters and the four access levels. Enforces data hiding as the foundation of robust class design.

Lesson 4 • Static Members and the this Keyword

Distinguishes instance members from static fields and methods and clarifies this usage. Prevents confusion between class-level and object-level state.

Lesson 1 • Method Overriding and Polymorphism

Teaches @Override, dynamic dispatch, and runtime polymorphism through supertype references. Enables writing code that works with any subclass transparently.

Lesson 2 • Abstract Classes and Methods

Defines abstract classes as partial implementations that enforce subclass contracts. Bridges concrete inheritance and full interface abstraction.

Lesson 3 • The Object Class and Common Methods

Examines Object as the root superclass and overrides toString, equals, and hashCode. Ensures correct behaviour in collections and logging throughout the application.

Lesson 4 • Interfaces and Default Methods

Covers interface declaration, implementation, multiple interface adoption, and default methods. Enables flexible, decoupled design through behavioural contracts.

Lesson 1 • Java Exception Hierarchy

Maps the Throwable, Exception, and Error class tree and distinguishes checked from unchecked exceptions. Provides the conceptual map for all exception-handling decisions.

Lesson 2 • Try-with-Resources

Introduces the AutoCloseable interface and try-with-resources for automatic resource cleanup. Eliminates resource leak bugs common in I/O and database code.

Lesson 3 • Creating Custom Exceptions

Guides design of application-specific exception classes with meaningful messages and context. Enables domain-accurate error reporting in professional codebases.

Lesson 4 • try-catch-finally Blocks

Teaches catching single and multiple exception types, rethrowing, and guaranteed cleanup with finally. Covers the full exception-handling lifecycle in a method.

Lesson 1 • List Implementations

Compares ArrayList and LinkedList for access patterns, insertion, and deletion performance. Enables informed selection between the two most common List types.

Lesson 2 • Generics Fundamentals

Introduces generic classes, methods, bounded type parameters, and wildcards. Provides the type-safety foundation required to use the Collections Framework correctly.

Lesson 3 • Set and Queue Implementations

Covers HashSet, LinkedHashSet, TreeSet, and Queue/Deque implementations with their ordering guarantees. Expands the student's data-structure toolkit beyond lists.

Lesson 4 • Collections Utility Methods and Sorting

Uses Collections and Arrays utility methods, Comparable, and Comparator for sorting and searching. Completes the student's ability to manipulate collections efficiently.