The Work Gym

Courses / Programming

Java

Write Java from your first method to tested services and technical interviews.

Start lesson 1 Practice interview Take the assessmentPractice the first unit of every course. No account needed.

62lessons

320checked exercises

15projects, cases and exams

Prepares you for Java developer interviews and Java SE 21 certification topics

Projects, case studies and mock exams

Project · BeginnerInventory service

Build a small inventory service with receipts, reservations, releases and a report.

6 steps · 45 min Case study · BeginnerDispatch capacity case

Turn a fictional dispatch manifest into counts, capacity evidence and a checked decision.

6 steps · 45 min Project · IntermediateText adventure engine

Build a room engine with visit history, inventory, a locked exit and movement undo.

6 steps · 55 min Project · IntermediateCSV report generator

Produce a correctly escaped, filtered, grouped report with a reconciled total.

6 steps · 55 min Case study · IntermediateQuota intake audit

Audit syntax, ranges and duplicate identities before returning a release decision.

6 steps · 45 min Project · AdvancedRetail refactor with tests

Build a checked adjustment service while preserving each earlier business rule.

6 steps · 50 min Case study · AdvancedDispatch capacity case

Choose one eligible dispatch site using checked capacity evidence.

6 steps · 45 min Project · ExpertBank ledger project

Build an in-memory ledger with validation, duplicate protection and batch rollback.

6 steps · 60 min Case study · ExpertCheckout incident case

Check the evidence before choosing a checkout recovery.

6 steps Mock exam · ExpertJava SE 21 practice exam A

An original 50-question Java SE 21-style test with a 120-minute clock.

50 questions · 120 min Mock exam · ExpertJava SE 21 practice exam B

An original 50-question Java SE 21-style test with a 120-minute clock.

50 questions · 120 min

Learn Java by writing and running methods in the browser. Start with types, control flow, text and objects. Then work with generics, collections, exceptions, streams, modern Java types and application design. Build an inventory service, a text adventure, a CSV report, a tested refactor and an in-memory ledger.

The Expert level covers concurrency contracts, JVM concepts and plain Java equivalents for framework boundaries, with explicit runtime limits. Finish with original Java interview sets and two 50-question Java SE 21-style timed mocks. Practice interview and assessment tasks use fresh problems in the same workspace.

Beginner

Values and expressions

Return typed values and compute numeric and logical expressions.

4 lessons

1Typed valuesWrite a callable Java method with typed parameters and a returned result.4 exercises · 24 minFree

2Numeric operatorsChoose division, remainder and widening at the correct point in a calculation.4 exercises · 24 minFree

3Boolean expressionsExpress business rules with comparisons and short-circuit logic.4 exercises · 24 minFree

Practice setValues practiceApply numeric and logical expressions to fresh workplace tasks.Free

Decisions and methods

Choose branches, repeat work and compose small methods.

4 lessons

5Conditional branchesChoose one result from ordered conditions and categorical values.4 exercises · 24 minWith a plan

6Counted and conditional loopsRepeat work with an explicit boundary and a changing loop state.4 exercises · 24 minWith a plan

7Method compositionBreak calculations into helpers while preserving argument and return-value rules.4 exercises · 24 minWith a plan

Practice setControl flow practiceSelect, repeat and compose earlier calculations on fresh data.With a plan

Text and arrays

Transform immutable text and traverse independent array data.

3 lessons

9Immutable text and buildersCompare and transform text without losing returned values or separators.4 exercises · 24 minWith a plan

10Fixed-size arraysRead fixed-size sequences and preserve independent array state.4 exercises · 24 minWith a plan

Practice setText and array practiceUse earlier text and array rules on new labels, readings and grids.With a plan

Objects and delivery

Protect object state and deliver checked services and recommendations.

4 lessons

12Encapsulated objectsCreate independent objects with valid updates and useful text descriptions.4 exercises · 24 minWith a plan

ProjectInventory serviceBuild a small inventory service with receipts, reservations, releases and a report.With a plan

Case studyDispatch capacity caseTurn a fictional dispatch manifest into counts, capacity evidence and a checked decision.With a plan

Practice setBeginner transfer practiceCombine validated object state with numeric, logical and sequence skills.With a plan

Intermediate

Object contracts

Model value identity, behavior and access boundaries, then build a stateful adventure engine.

5 lessons

16Identity and valueDefine value identity without confusing references, hashes or display text.4 exercises · 24 minWith a plan

17Inheritance and dispatchApply behavior through base types while concrete objects supply the rule.4 exercises · 26 minWith a plan

18Interfaces and accessKeep implementation choices behind contracts and make access rules explicit.4 exercises · 24 minWith a plan

ProjectText adventure engineBuild a room engine with visit history, inventory, a locked exit and movement undo.With a plan

Practice setObject contracts practiceApply the unit contracts to new data without step-by-step instructions.With a plan

Collection design

Choose generic APIs, collection implementations and ordering rules, then build a CSV report.

5 lessons

21Generic API contractsWrite helpers that preserve types and accept safe producers or consumers.4 exercises · 28 minWith a plan

22Collection behavior and costsChoose order, uniqueness and end operations deliberately.4 exercises · 28 minWith a plan

23Traversal, order and statesRemove safely, resolve ties and model a closed set of states.4 exercises · 28 minWith a plan

ProjectCSV report generatorProduce a correctly escaped, filtered, grouped report with a reconciled total.With a plan

Practice setCollection contracts practiceApply the unit contracts to new data without step-by-step instructions.With a plan

Failure boundaries

Handle named failures, close resources and preserve owned state, then audit an intake decision.

5 lessons

26Failure categoriesKeep parse errors, rejected values and accepted records separate.4 exercises · 25 minWith a plan

27Resource ownershipClose owned resources on success, failure and early return.4 exercises · 24 minWith a plan

28Defensive value boundariesPreserve owned state when callers retain mutable references.4 exercises · 25 minWith a plan

Case studyQuota intake auditAudit syntax, ranges and duplicate identities before returning a release decision.With a plan

Practice setFailure boundary practiceApply the unit contracts to new data without step-by-step instructions.With a plan

Advanced

Functional pipelines

Build ordered transformations, grouped reports and explicit absence handling.

5 lessons

31Lambda contractsChoose a functional interface that matches the rule, and preserve composition order.4 exercises · 18 minWith a plan

32Ordered stream pipelinesMatch pipeline order to the required filtering, transformation and final result.4 exercises · 18 minWith a plan

33Collectors and grouped resultsGroup by the correct key and merge duplicate rows without losing their contribution.4 exercises · 18 minWith a plan

34Optional lookup resultsRepresent absence through each lookup and defer fallback work until it is needed.4 exercises · 18 minWith a plan

Practice setFunctional pipeline practiceCombine the unit rules on fresh courier, studio and warehouse data.With a plan

Modern value models

Model values, handle closed alternatives and preserve time and snapshot boundaries.

5 lessons

36Record value modelsUse generated record behavior and establish value rules during construction.4 exercises · 18 minWith a plan

37Sealed hierarchies and patternsMatch types explicitly and place guarded subsets before their general case.4 exercises · 18 minWith a plan

38Calendar and timeline boundariesUse calendar operations for dates and timeline operations for elapsed time.4 exercises · 18 minWith a plan

39Immutable text and snapshotsPreserve exact text characters and isolate mutable arrays at snapshot boundaries.4 exercises · 18 minWith a plan

Practice setValue model practiceApply value, boundary and snapshot rules to fresh fulfillment and travel tasks.With a plan

Testable designs

Separate responsibilities and prove stateful Java behavior through executable checks.

6 lessons

41Small substitutable designsSeparate variation from traversal and preserve the contract of every substitute.4 exercises · 18 minWith a plan

42Behavioral assertion runnerSeparate assertion behavior from suite control and isolate each fixture.4 exercises · 18 minWith a plan

ProjectRetail refactor with testsBuild a checked adjustment service while preserving each earlier business rule.With a plan

Case studyDispatch capacity caseChoose one eligible dispatch site using checked capacity evidence.With a plan

Interview setLow-level design interviewImplement observable invariants across original easy, medium and hard design tasks.With a plan

Practice setTestable design practiceReapply substitutable behavior, narrow boundaries and independent assertions.With a plan

Expert

Concurrent services

Trace schedules and protect service invariants within stated runtime limits.

5 lessons

47Thread interleavings and monitorsTwo workers each add a delta to a shared starting balance. The explicit schedule is A-read, B-read, A-write, B-write. Return the final balance under that schedule. This is a sequential trace of a race, not native concurrent execution.4 exercisesWith a plan

48Atomic operationsStart an AtomicInteger at initial. Apply every delta with addAndGet and return the final value. Each call is atomic on a full JVM; several calls together are still separate operations.4 exercisesWith a plan

49Executors, futures and virtual threadsA deterministic executor model accepts the first capacity jobs while accepting is true. Return accepted job ids in order. capacity is nonnegative. This models admission only; ExecutorService and native worker scheduling are unavailable in this workspace.4 exercisesWith a plan

ProjectBank ledger projectBuild an in-memory ledger with validation, duplicate protection and batch rollback.With a plan

Practice setConcurrent service practiceApply earlier Java contracts to fresh inputs and changed boundaries.With a plan

JVM and application boundaries

Reason about memory, module access, text and plain Java application boundaries.

5 lessons

52JVM memory and initializationObjects are numbered 0 through links.length-1. Each has one outgoing reference, or -1. Starting at root, count distinct reachable objects, stopping on null or a cycle. Return 0 for root -1. This is a reachability model, not a measurement of the browser collector.4 exercisesWith a plan

53Modules, resources and textA public type is accessible only when the caller reads the owner module and the package is exported. Return whether both conditions hold. Named modules are explained here through their access contract; this single-file browser workspace does not execute module-path commands.4 exercisesWith a plan

54Plain Java framework equivalentsInject an integer adjustment policy into a plain Java service. Return base plus adjustment through the service. This demonstrates constructor injection without Spring Boot; no container, annotations or HTTP server run here.4 exercisesWith a plan

Case studyCheckout incident caseCheck the evidence before choosing a checkout recovery.With a plan

Practice setPlatform contract practiceApply earlier Java contracts to fresh inputs and changed boundaries.With a plan

Interviews and certification

Solve Java interviews and original timed certification-style questions.

6 lessons

Interview setJava easy interviewImplement original Java tasks and defend each contract with a boundary case.With a plan

Interview setJava medium interviewImplement original Java tasks and defend each contract with a boundary case.With a plan

Interview setJava hard interviewImplement original Java tasks and defend each contract with a boundary case.With a plan

Mock examJava SE 21 practice exam AAn original 50-question Java SE 21-style test with a 120-minute clock.With a plan

Mock examJava SE 21 practice exam BAn original 50-question Java SE 21-style test with a 120-minute clock.With a plan

Practice setExpert transfer practiceApply earlier Java contracts to fresh inputs and changed boundaries.With a plan