Java: Complete Language Course
Master Java from first principles to advanced patterns, covering syntax, OOP, collections, concurrency, and the Java ecosystem. You will build real projects including a CLI task manager, a multi-threaded file processor, and a RESTful data service.
Course Content
6 modules · 30 lessonsJava Fundamentals
Write, compile, and run Java programs using variables, data types, operators, and control flow.
How Java compilation and the JVM work
JDK vs JRE vs JVM, compilation steps, bytecode, class files, platform independence, javac command
Java primitive data types and variable declaration
int, long, double, float, boolean, char, byte, short, variable declaration, type sizes, default values
Java operators and expression evaluation order
arithmetic operators, comparison operators, logical operators, assignment operators, operator precedence, short-circuit evaluation, integer division
Java if-else and switch control flow
if statement, else-if chain, nested conditionals, switch statement, switch expression, fall-through, break, default case
Java for loop, while loop, and loop control
for loop syntax, while loop, do-while loop, enhanced for-each loop, break, continue, nested loops, infinite loop prevention
Object-Oriented Programming in Java
Model real-world problems using classes, objects, inheritance, polymorphism, and encapsulation.
Java classes and objects explained
class definition, fields, methods, constructors, object instantiation, new keyword, this keyword, method signatures
Java encapsulation with private fields and getters setters
access modifiers, private fields, public getters, public setters, data hiding, validation in setters, encapsulation principle
Java inheritance and the extends keyword
extends keyword, superclass, subclass, method inheritance, constructor chaining with super, method overriding, @Override annotation, is-a relationship
Java polymorphism and method overriding at runtime
runtime polymorphism, dynamic dispatch, upcasting, downcasting, instanceof check, abstract classes, abstract methods
Java interfaces and implementing multiple contracts
interface definition, implements keyword, multiple interfaces, default methods, functional interfaces, interface vs abstract class, contract programming
Java Collections Framework
Store, search, and manipulate data efficiently using Java's built-in List, Set, Map, and Queue implementations.
Java ArrayList vs LinkedList — when to use each
ArrayList, LinkedList, List interface, dynamic resizing, index access, insertion performance, iteration, List.of, mutable vs immutable lists
Java HashMap and HashSet for fast lookups
HashMap, HashSet, Map interface, Set interface, key-value pairs, hash function, O(1) lookup, duplicate handling, null keys, entrySet iteration
Java generics and type-safe collections
generic classes, generic methods, type parameters, bounded type parameters, wildcards, type erasure, raw types, compile-time safety
Java Streams API for collection processing
Stream creation, filter, map, reduce, collect, sorted, distinct, findFirst, method references, lazy evaluation, terminal vs intermediate operations
Java Iterator pattern and Comparable for sorting
Iterator interface, hasNext, next, Iterable, Comparable, compareTo, Comparator, Collections.sort, custom sort order, natural ordering
Exception Handling and I/O
Write robust Java programs that handle errors gracefully and read from or write to files and streams.
Java checked vs unchecked exceptions explained
Exception hierarchy, Throwable, Error, checked exceptions, unchecked exceptions, RuntimeException, throws declaration, compiler enforcement, common exceptions
Java try-catch-finally and multi-catch blocks
try block, catch block, finally block, multi-catch, exception variable, exception message, stack trace, re-throwing, try-with-resources preview
Java try-with-resources and AutoCloseable
try-with-resources, AutoCloseable, Closeable, resource declaration, automatic close, suppressed exceptions, multiple resources, custom AutoCloseable
Reading and writing text files in Java
FileReader, FileWriter, BufferedReader, BufferedWriter, Files.readAllLines, Files.writeString, Path, Paths, NIO.2, charset, line separator
Custom exceptions in Java — when and how to create them
custom exception class, extending Exception vs RuntimeException, constructors, exception message, chained exceptions, domain-specific errors, exception hierarchy design
Concurrency and Multithreading
Write thread-safe Java programs that exploit multi-core hardware using threads, locks, and the concurrency utilities.
Java threads — creating and starting threads
Thread class, Runnable interface, lambda threads, thread lifecycle, start vs run, thread name, daemon threads, Thread.sleep, join method
Java synchronized keyword and race conditions
race condition, critical section, synchronized method, synchronized block, intrinsic lock, monitor, visibility problem, mutual exclusion, thread safety
Java ExecutorService and thread pool basics
ExecutorService, Executors factory, thread pool, fixed pool, cached pool, submit, Future, Callable, shutdown, awaitTermination, task queue
Java atomic classes and concurrent collections
AtomicInteger, AtomicLong, AtomicReference, CAS operation, ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue, ArrayBlockingQueue, thread-safe collections
Java CompletableFuture for async non-blocking code
CompletableFuture, supplyAsync, thenApply, thenAccept, thenCompose, exceptionally, allOf, anyOf, async pipeline, ForkJoinPool, non-blocking chaining
Modern Java Features and Best Practices
Write idiomatic modern Java using lambdas, records, sealed classes, Optional, and design patterns.
Java lambda expressions and functional interfaces
lambda syntax, functional interface, @FunctionalInterface, Predicate, Function, Consumer, Supplier, BiFunction, method references, type inference
Java Optional — avoiding NullPointerException properly
Optional creation, of, ofNullable, empty, isPresent, get, orElse, orElseGet, map, flatMap, filter, ifPresent, Optional anti-patterns, return type usage
Java records for immutable data classes
record syntax, canonical constructor, compact constructor, accessor methods, equals and hashCode, toString, record limitations, when to use records, record vs class
Java sealed classes and pattern matching with switch
sealed class, permits clause, sealed interface, final subclasses, record patterns, switch pattern matching, exhaustiveness checking, algebraic data types
Java design patterns — Builder, Strategy, and Observer
Builder pattern, method chaining, immutable objects, Strategy pattern, interchangeable algorithms, Observer pattern, event listeners, open-closed principle, separation of concerns
