1. Meet Java and the JVM
BeginnerUnderstand Java source code, the JDK, compilation, and the edit-compile-run workflow.
Java, the JDK, and the JVM
Java source is compiled to bytecode that runs on a Java Virtual Machine.
The shape of a Java program
A class groups code, and main is a common application entry point.
Variables and console output
Variables name values, and print methods display information for debugging or users.
Module checkpoint: Practice this module by writing a small Java program using meet java and the jvm. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.
2. Types, variables, and expressions
BeginnerWork with Java primitive types, reference variables, conversions, and constants.
Primitive data types
Java primitives represent simple numeric, character, and boolean values.
Reference types and strings
Reference variables can refer to objects such as String instances.
Constants and type conversion
final marks a variable as assignable only once after initialization.
Module checkpoint: Practice this module by writing a small Java program using types, variables, and expressions. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.
3. Operators and decisions
BeginnerUse arithmetic, comparisons, logical operators, conditionals, and switch expressions.
Arithmetic and comparison operators
Operators compute values or compare them to produce a boolean result.
if, else, and boolean logic
Conditional branches execute only when their boolean condition is satisfied.
switch statements and expressions
switch selects among cases based on the value of an expression.
Module checkpoint: Practice this module by writing a small Java program using operators and decisions. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.
4. Loops and iteration
BeginnerRepeat operations with for, while, do-while, nested loops, and safe loop control.
for loops
A for loop groups initialization, a continuation test, and an update.
while and do-while
while tests before running; do-while tests after running the body.
Nested loops and loop control
Nested loops process combinations, while break and continue alter iteration flow.
Module checkpoint: Practice this module by writing a small Java program using loops and iteration. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.
5. Methods, parameters, and scope
BeginnerDesign reusable methods, pass arguments, return values, and understand scope and overloading.
Declaring and calling methods
Methods package reusable behavior behind a name and a defined parameter list.
Parameters and pass-by-value
Java passes arguments by value, including copies of object references.
Scope and method overloading
Scope determines where a name can be used, and overloading provides related method signatures.
Module checkpoint: Practice this module by writing a small Java program using methods, parameters, and scope. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.
6. Arrays, strings, and data handling
BeginnerStore ordered data, use multidimensional arrays, and work safely with String operations.
Arrays and array traversal
An array stores a fixed number of elements of one declared type.
Multidimensional arrays
A two-dimensional array is an array whose elements are themselves arrays.
String operations
String provides methods for searching, extracting, comparing, and transforming text.
Module checkpoint: Practice this module by writing a small Java program using arrays, strings, and data handling. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.
7. Object-oriented programming
IntermediateModel domain concepts with classes, objects, constructors, encapsulation, and records.
Classes and objects
A class defines a type; an object is an instance of that type.
Constructors and encapsulation
Constructors initialize objects, while access modifiers control visibility.
Records, enums, and data modeling
Records and enums provide concise ways to represent structured data and fixed choices.
Module checkpoint: Practice this module by writing a small Java program using object-oriented programming. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.
8. Inheritance, interfaces, and polymorphism
IntermediateBuild extensible designs using inheritance, interfaces, overriding, and composition.
Inheritance and overriding
Inheritance lets a subclass specialize behavior inherited from a superclass.
Interfaces and abstract classes
Interfaces define contracts; abstract classes can share partial implementation and state.
Polymorphism and composition
Polymorphism lets code use a common type while runtime objects supply specialized behavior.
Module checkpoint: Practice this module by writing a small Java program using inheritance, interfaces, and polymorphism. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.
9. Collections and generics
IntermediateChoose collection types, work with generics, and compare elements safely.
Lists, sets, and maps
The Collections Framework provides reusable data structures for common operations.
Generics and type safety
Generics let collections and classes express element types at compile time.
Equality, sorting, and iterators
Consistent equality and ordering rules make collection behavior predictable.
Module checkpoint: Practice this module by writing a small Java program using collections and generics. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.
10. Exceptions and input/output
IntermediateHandle failures intentionally and work with console input, files, and resource lifetimes.
Exceptions and error handling
Exceptions report abnormal conditions and allow a program to handle or propagate failures.
Console input and validation
Input validation checks whether external values meet the program’s expectations.
File I/O and try-with-resources
Java provides stream and NIO APIs for working with files and other I/O resources.
Module checkpoint: Practice this module by writing a small Java program using exceptions and input/output. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.
11. Lambdas, streams, and modern Java
AdvancedUse functional interfaces, lambda expressions, method references, streams, and Optional thoughtfully.
Lambdas and functional interfaces
A lambda expression provides an implementation for a functional interface.
Streams and collectors
Streams process data through pipeline operations such as filter, map, and collect.
Optional and functional style
Optional makes the possible absence of a returned value explicit.
Module checkpoint: Practice this module by writing a small Java program using lambdas, streams, and modern java. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.
12. Concurrency and asynchronous work
AdvancedLearn threads, executors, synchronization, concurrent collections, and CompletableFuture basics.
Threads and tasks
A thread is an execution path, while a task is work that can be scheduled.
Executors and futures
Executors manage task execution, while futures represent results that may arrive later.
Shared state and synchronization
Synchronization coordinates access to shared mutable state between threads.
Module checkpoint: Practice this module by writing a small Java program using concurrency and asynchronous work. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.
13. Testing, build tools, and application design
AdvancedStructure projects, write tests, use build tools, understand packages and debugging, and deliver a maintainable application.
Packages and project structure
Packages organize related types and help avoid naming conflicts.
Unit testing and debugging
Tests verify behavior, while debugging and logging help explain failures.
Build tools and release readiness
Build tools automate compiling, testing, dependency management, and packaging.
Module checkpoint: Practice this module by writing a small Java program using testing, build tools, and application design. Test a normal case, a boundary case, and an invalid or unexpected input; explain why the result is correct.