Java Developer Course

Lesson 1 • Java Syntax and Program Structure

Introduces classes, the main method, statements, and comments as Java's structural building blocks. Connects syntax rules to how the compiler processes source files.

Lesson 2 • Primitive Types, Variables, and Operators

Covers all eight primitive types, variable declaration, and arithmetic and logical operators. Builds the data-manipulation foundation needed for control flow.

Lesson 3 • Control Flow Statements

Teaches if-else, switch, loops, and branching keywords to direct program execution. Prepares students to implement decision logic in upcoming method and class work.

Lesson 4 • Installing and Configuring the Dev Environment

Guides installation of JDK and a modern IDE, plus environment variable configuration. Ensures every student has a functional workspace before writing code.

Lesson 1 • Encapsulation and Access Modifiers

Applies private, protected, public, and package-private modifiers to enforce data hiding. Teaches getter and setter design as the standard encapsulation pattern.

Lesson 2 • Classes, Objects, and Constructors

Defines classes as blueprints and objects as instances, covering fields, methods, and constructors. Establishes the object model that all OOP patterns in this chapter depend on.

Lesson 3 • Interfaces and Design Contracts

Explores interface features including default methods, static methods, and functional interfaces. Prepares students for lambda expressions and API design in later chapters.

Lesson 4 • Inheritance and Method Overriding

Covers extends, super, and method overriding to build class hierarchies. Shows how inheritance promotes code reuse while maintaining type safety.

Lesson 1 • Strings and Text Processing

Covers String immutability, StringBuilder, and key String API methods for text manipulation. Directly supports input parsing and output formatting tasks throughout the course.

Lesson 2 • Arrays and the Arrays Utility Class

Teaches single and multi-dimensional array declaration, traversal, and the Arrays utility methods. Provides the low-level data structure baseline before introducing collections.

Lesson 3 • Iterators and the Collections Utility Class

Covers Iterator, ListIterator, and Collections utility methods for sorting and searching. Bridges raw collection use to the stream-based processing introduced later.

Lesson 4 • Wrapper Classes and Autoboxing

Explains Integer, Double, and other wrapper classes and the autoboxing mechanism. Resolves common pitfalls when mixing primitives with generic collections.

Lesson 1 • Java Exception Hierarchy

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

Lesson 2 • Try-Catch-Finally Blocks

Teaches try, catch, multi-catch, and finally syntax for structured exception handling. Ensures students can isolate failure points and guarantee resource cleanup.

Lesson 3 • Custom Exceptions and Best Practices

Guides creation of domain-specific exception classes and establishes exception design guidelines. Promotes clean API contracts and meaningful error messages in production code.

Lesson 4 • Try-With-Resources and AutoCloseable

Introduces the try-with-resources statement for automatic resource management. Connects to I/O and database resource handling covered in later chapters.

Lesson 1 • Built-in Functional Interfaces

Explores Predicate, Function, Consumer, Supplier, and their variants from java.util.function. Provides the vocabulary needed to compose stream operations fluently.

Lesson 2 • Generics Fundamentals

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

Lesson 3 • Lambda Expressions and Method References

Introduces lambda syntax as concise implementations of functional interfaces. Connects to built-in functional interfaces and the Stream API used in subsequent sections.

Lesson 4 • Stream API: Terminal Operations and Collectors

Covers collect, reduce, count, findFirst, and Collectors factory methods for aggregation. Completes the functional pipeline model and introduces parallel stream considerations.

Lesson 1 • File and Directory Operations with NIO.2

Covers Path, Paths, Files, and DirectoryStream for modern file-system manipulation. Replaces legacy File API usage with the more robust and expressive NIO.2 approach.

Lesson 2 • Object Serialisation

Teaches Serializable, ObjectOutputStream, and ObjectInputStream for persisting object graphs. Highlights versioning with serialVersionUID and security considerations.

Lesson 3 • Working with Properties and Configuration Files

Demonstrates Properties class and .properties file loading for externalised configuration. Connects to real-world application configuration patterns used in enterprise development.

Lesson 4 • Classic I/O Streams

Introduces InputStream, OutputStream, Reader, and Writer hierarchies for byte and character I/O. Establishes the stream model that NIO.2 and serialisation build upon.

Lesson 1 • Advanced Concurrency: Locks and CompletableFuture

Explores ReentrantLock, ReadWriteLock, and CompletableFuture for composable async pipelines. Equips students to build responsive, non-blocking workflows in modern Java applications.

Lesson 2 • Concurrent Collections and Atomic Variables

Covers ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue, and atomic classes. Provides thread-safe data structures that avoid explicit locking overhead.

Lesson 3 • Synchronisation and Visibility

Teaches synchronised blocks, methods, and the volatile keyword to enforce memory visibility. Directly addresses the race conditions and stale data issues common in shared-state programmes.

Lesson 4 • Executor Framework and Thread Pools

Introduces ExecutorService, thread pool types, and Future for managed task execution. Replaces raw thread management with scalable, configurable concurrency infrastructure.

Lesson 1 • Creational Design Patterns

Implements Singleton, Factory Method, Builder, and Prototype patterns with Java examples. Provides reusable object-creation strategies that reduce coupling in application code.

Lesson 2 • Prepared Statements and Transactions

Teaches PreparedStatement for parameterised queries and transaction control with commit and rollback. Prevents SQL injection and ensures data integrity in multi-step operations.

Lesson 3 • JDBC Fundamentals

Covers DriverManager, Connection, Statement, and ResultSet for relational database interaction. Establishes the low-level database access layer that ORM tools abstract in later work.

Lesson 4 • Structural and Behavioural Design Patterns

Covers Adapter, Decorator, Proxy, Observer, and Strategy patterns with practical Java implementations. Equips students to structure flexible, maintainable codebases aligned with industry standards.