📝 What You'll Learn
Master core Java from the ground up. Cover variables, control flow, arrays, object-oriented programming, inheritance, polymorphism, encapsulation, collections, exception handling, and lambda expressions. Each topic is explained with clear examples, code walkthroughs, and practice exercises designed for self-paced reading.
🏆 Become Oracle Certified
Our curriculum maps directly to the Oracle Certified Foundations Associate (1Z0-811) and Oracle Certified Professional (1Z0-808) exam objectives. Study with structured lessons that mirror the exam topics, reinforce your understanding with practice problems, and build the confidence to pass your certification on the first attempt.
🚀 Career-Ready Java Skills
Go from zero programming knowledge to writing and understanding real Java code. By the end of this course, you'll think like a developer — reading code confidently, solving problems methodically, and understanding the fundamentals that every Java job posting requires. The perfect foundation for junior developer roles or advancing to the paid bootcamp tiers.
Our interactive coding labs use a purpose-built Java editor designed for learning. Write code, hit Run, and see results instantly — no environment setup, no friction, just real Java from day one.
59 Lessons, Over 50 Hands-on Labs, Over 1000 Code Snippets, and 560 Interview Prep Questions — built to prep you for the 1Z0-808 and 1Z0-811 exams.
Start your programming journey with this completely free Java course that takes you from absolute beginner to building real applications. This free Java course is structured to match the depth and quality of paid bootcamps and university CS programs, covering everything from basic syntax to advanced object-oriented programming concepts.
What makes this free Java course different from others:
-
100% Free Forever - No hidden costs, no paywalls, no premium upsells. This free Java course gives you complete access to all 50+ hours of content, over 50 hands-on labs, and 59 lessons at absolutely no charge.
-
Interactive Learning from Day One - Unlike passive video courses, this free Java course includes hands-on coding exercises in every module. You'll write actual Java code in our built-in browser-based editor — no downloads, no setup, just code and run.
-
Oracle Certification Aligned - This free Java course covers all objectives for Oracle's 1Z0-811 (Java Foundations) and 1Z0-808 (Java SE 8 Programmer I) certification exams, giving you skills employers recognize.
-
Modern Java 21 + Legacy Features - Learn the latest Java 21 features while understanding Java 8+ improvements. This free Java course prepares you for both modern projects and maintaining existing codebases.
-
University-Quality Curriculum - Comparable to university courses, but with better Oracle certification preparation and permanent free access.
This free Java course is perfect for:
- Complete beginners who want to learn programming the right way with a structured, comprehensive free Java course
- Self-taught developers seeking organized content instead of scattered YouTube tutorials
- Career switchers preparing for junior Java developer positions
- Students who need certification prep or want to supplement their computer science coursework
- Anyone who wants to learn Java without spending hundreds on bootcamps
Every lesson in this free Java course pairs a detailed explanation with a hands-on coding lab. Read the concept, then immediately practice it — 59 lessons and over 50 labs that build your skills step by step.
Duration: ~3 hours
Learning Objective: Master fundamental Java syntax, understand data types, and learn proper variable naming conventions.
This module covers the building blocks of Java programming including type casting and basic program structure.
| Unit | Lesson | What You'll Learn | Hands on Lab |
|---|---|---|---|
| 1 | Your First Java Program | Set up your environment, write a complete Java program from scratch, compile it, and see output on screen — the full cycle every developer repeats daily | Practice returning exact strings from methods and see your first green checkmarks |
| 2 | Java Syntax and Structure | Understand why Java requires a class wrapper and a main method, how semicolons and braces shape program flow, and the conventions that make code readable to other developers | |
| 3 | Variables and Data Types | Declare variables using int, double, char, boolean, and String — learn how each type stores data differently in memory and when to pick one over another | Declare int, long, double, char, and boolean variables for a rideshare driver profile |
| 4 | Rules for Variables Names | Know exactly which variable names Java allows, which it rejects, and the camelCase conventions that professional codebases follow everywhere | Apply camelCase naming, special identifiers, and boolean prefixes in a grade tracker |
| 5 | Type Casting | Convert between data types without losing data — understand when Java handles conversion automatically and when you need an explicit cast to avoid bugs | Practice widening conversions, narrowing casts, operator precedence, and byte overflow |
Duration: ~3 hours
Learning Objective: Learn to use arithmetic, unary, bitwise, and bit shift operators to perform calculations and
manipulate data. Understand operator precedence and how to build complex expressions in Java.
| Unit | Lesson | What You'll Learn | Hands on Lab |
|---|---|---|---|
| 1 | Arithmetic Operators and Expressions | Use +, -, *, /, and % to build calculations, understand why 7/2 gives 3 in Java (not 3.5), and learn how operator precedence changes results without parentheses | Apply multiplication, integer division, type promotion, and operator precedence |
| 2 | Unary Operators | Grasp the difference between i++ and ++i — a common interview question — and use increment, decrement, and negation operators without introducing subtle bugs | Compare postfix and prefix increment behavior inside arithmetic expressions |
| 3 | Bitwise and Bit Shift Operators | Work with data at the binary level using AND, OR, XOR, and shift operators — the same operations used in graphics, networking, and encryption code | Use AND, OR, left shift, and right shift to extract and assemble RGB color channels |
Duration: ~2 hours
Learning Objective: Master control flow structures including conditional statements (if/else, switch), loops (for,
while, do-while), and learn to control program execution with break and continue statements. Build complex nested loops
and understand logical operators.
| Unit | Lesson | What You'll Learn | Hands on Lab |
|---|---|---|---|
| 1 | Relational and Logical Operators | Compare values with <, >, ==, and != to make your programs react to conditions — the foundation of every if-statement and loop you'll ever write | Apply >=, <, !=, &&, and || operators to evaluate ride eligibility conditions |
| 2 | Logical Operators AND, OR, NOT, and XOR | Chain multiple conditions together with && and || to build real decision logic, and understand short-circuit evaluation that can prevent runtime errors | Apply AND, OR, NOT, and XOR operators to validate stock, shipping, and order conditions |
| 3 | Understanding for loop | Write for loops that repeat code a specific number of times — iterate through data, accumulate totals, and build strings character by character | Use for loops for accumulation, transformed counters, string building, and the continue keyword |
| 4 | Understanding while and do-while | Choose between while and do-while loops based on whether you need to check the condition before or after the first iteration — a distinction that matters in input validation and menu systems | Apply while and do-while loops to condition-based iteration and observe when do-while matters |
| 5 | Nested Loops | Place loops inside loops to process grids, generate patterns, and work with multi-dimensional data — the same technique behind matrix operations and table processing | Use nested loops to traverse a grid, count slots, sum values, and search for elements |
| 6 | Switch Statements, Break, and Continue | Replace long if-else chains with cleaner switch statements, and use break and continue to control exactly when a loop stops or skips an iteration | Apply switch for value dispatch, continue to filter iterations, and break to exit early |
Duration: ~5 hours
Learning Objective: Master Java's String class and string manipulation techniques. Learn string comparison methods (==
vs equals()), explore comprehensive string methods, work with printf formatting, and use regular expressions for pattern
matching.
| Unit | Lesson | What You'll Learn | Hands on Lab |
|---|---|---|---|
| 1 | Printing in Java | Display output with print and println, join strings with the + operator, and avoid the classic trap where "Score: " + 2 + 3 prints "Score: 23" instead of "Score: 5" | Practice string concatenation and fix the classic + operator trap with parentheses |
| 2 | Formatting Output with printf and format | Produce clean, aligned output using printf format specifiers — control decimal places, pad numbers, and build formatted tables the way real applications display data | Apply %s, %d, %.2f format specifiers with field widths and leading zeros |
| 3 | Understanding Strings in Java | Understand why Strings are immutable in Java, how the String Pool saves memory, and why modifying a String actually creates a brand new object every time | Observe string immutability and discover why == fails with new String() |
| 4 | The == operator and the equals method | Avoid the most common Java bug: using == when you should use equals(). Understand why == compares memory addresses while equals() compares actual content — and why this trips up even experienced developers | Debug Integer cache behavior where == silently breaks above 127 |
| 5 | Exploring String Methods | Use substring(), indexOf(), trim(), replace(), and other built-in methods to search, extract, clean, and transform text — the everyday toolkit for processing user input and file data | Apply length, substring, indexOf, and trim to process catalog data |
| 6 | Regular Expressions | Write regex patterns to validate email addresses, phone numbers, and other formatted input — then use Pattern and Matcher to find and extract matching text from larger strings | Use Pattern, Matcher, find(), matches(), and capturing groups on product data |
Duration: ~5 hours
Learning Objective: Learn to work with one-dimensional and two-dimensional arrays in Java. Master array creation,
initialization, traversal, and advanced array methods including sorting, searching, and manipulation techniques.
| Unit | Lesson | What You'll Learn | Hands on Lab |
|---|---|---|---|
| 1 | One-Dimensional Arrays | Store and access collections of data in fixed-size arrays — declare, initialize, loop through elements, and understand why array indexes start at 0 and going out of bounds crashes your program | Traverse, sum, find max, and skip elements in a step count array |
| 2 | Two-Dimensional Arrays | Represent grids, tables, and matrices using arrays of arrays — access individual cells by row and column, and traverse entire 2D structures with nested loops | Access cells, compute totals, and walk diagonals in a 2D parking garage grid |
| 3 | Advanced Array Methods | Sort arrays in one line with Arrays.sort(), find elements instantly with binarySearch(), and copy ranges efficiently — the built-in methods that replace dozens of lines of manual loop code | Apply Arrays.sort(), binarySearch(), and copyOfRange() to shipment weight data |
Duration: ~3 hours
Learning Objective: Master method creation, invocation, and design in Java. Learn about method parameters, return types,
method overloading, pass-by-value mechanics, handling multiple inputs, and working with command-line arguments.
| Unit | Lesson | What You'll Learn | Hands on Lab |
|---|---|---|---|
| 1 | Writing Methods | Break your code into reusable methods with parameters and return values — the single most important skill for writing organized, maintainable programs instead of one giant main method | Write parameterized methods with returns, conditional paths, and method chaining |
| 2 | Handling Multiple Inputs | Pass multiple arguments of different types into a single method, and use varargs (...) when the number of inputs isn't known until runtime | Process registrations using multi-typed parameters and varargs |
| 3 | Understanding Pass by Value and Pass by Reference | Understand why changing a parameter inside a method sometimes affects the original data and sometimes doesn't — Java's pass-by-value rule and how it behaves differently for primitives vs. objects | Observe pass-by-value behavior with primitives, arrays, and string reassignment |
| 4 | Method Overloading | Give multiple methods the same name but different parameter lists, so one method name like add() can handle integers, doubles, or three numbers — the same technique Java uses for println() | Resolve overload selection with type promotion and varargs vs fixed-parameter matching |
| 5 | Command Line Arguments | Accept and parse input directly from the terminal using the String[] args parameter you've seen in every main method — finally understand what that parameter is for | Parse and validate String[] arguments with safe indexing and numeric conversion |
Duration: ~10 hours
Learning Objective: Master the four pillars of OOP: encapsulation, inheritance, polymorphism, and abstraction. Learn to
design and implement classes, work with constructors, understand access modifiers, implement interfaces, handle multiple
inheritance, and apply design patterns like Singleton. This is the most comprehensive module in the course.
| Unit | Lesson | What You'll Learn | Hands on Lab |
|---|---|---|---|
| 1 | Principles of Object-Oriented Programming | Understand the four pillars — encapsulation, inheritance, polymorphism, and abstraction — and why they exist: to organize code so it doesn't collapse under its own complexity as projects grow | |
| 2 | Building Blocks of Object-Oriented Programming | Distinguish between classes and objects, understand what happens in memory when you write new, and see how objects bundle data with the methods that operate on it | Create objects with new, observe reference identity, equality, and aliasing |
| 3 | Creating Classes in Java | Design your own class from scratch with private fields, a constructor, getters, and instance methods — the same structure behind every class in Java's standard library | Build a class with private fields, this keyword, getters, and instance methods |
| 4 | The Art of Object Creation in Java | Write overloaded constructors that let callers create objects with full customization or sensible defaults, and eliminate duplicated code using constructor chaining with this() | Write overloaded constructors with no-arg defaults and this() chaining |
| 5 | Understanding Inheritance | Build class hierarchies with extends so that shared fields and methods are defined once in a superclass and reused by every subclass — no more copying the same code into multiple classes | Extend a superclass with two subclasses using super() and method overriding |
| 6 | Encapsulation and Access Control | Protect object data with private fields and control all access through methods — so no external code can set your bank balance to -9999 without going through your validation logic | Apply private fields, read-only access, and validated setters to protect state |
| 7 | Constructors in Inheritance | Trace exactly what happens when you create a subclass object — how super() chains constructors from the top of the hierarchy down, and why omitting it causes compile errors | Chain super() constructors through a three-level inheritance hierarchy |
| 8 | Parameterized Constructors | Choose between no-arg and parameterized super() calls to control how inherited fields get initialized — and avoid the silent bug where data enters the subclass constructor but never reaches the parent | Match parameterized super() calls correctly to avoid silent data loss in subclasses |
| 9 | Abstract Classes | Define abstract classes that force every subclass to implement specific methods — turning forgotten overrides from silent runtime bugs into compile-time errors the IDE catches instantly | Implement abstract methods in two concrete subclasses using the template pattern |
| 10 | Interfaces | Break through Java's single-inheritance limit with interfaces — let a class implement multiple contracts so it can be both Sortable and Printable, the way Java's own library classes work | Implement Payable and Refundable interfaces with polymorphic method dispatch |
| 11 | Multiple Inheritance and Rules | Combine class inheritance with multiple interfaces in one class, and resolve the conflicts that arise when two interfaces define the same default method | Combine class inheritance with multiple interfaces, constants, and default methods |
| 12 | Understanding Static Members | Understand why Math.PI doesn't need an object and main is always static — use static fields for shared data and static methods for behavior that belongs to the class, not to any single instance | Distinguish static vs instance state with shared counters and per-object readings |
| 13 | The Final Keyword | Lock down variables as constants, prevent methods from being overridden, and seal classes against inheritance entirely — the same way Java's own String class is built to be unchangeable | Apply final to variables, methods, and classes in a security badge system |
| 14 | Singleton Design Pattern | Implement your first design pattern: guarantee a class has exactly one instance across your entire application, the approach used for database connections, loggers, and configuration managers in production code | Implement lazy Singleton initialization and verify one instance across all callers |
Duration: ~5 hours
Learning Objective: Learn to write robust, error-resistant Java programs using exception handling. Understand the
difference between checked and unchecked exceptions, master try-catch blocks, and implement proper error handling
strategies.
| Unit | Lesson | What You'll Learn | Hands on Lab |
|---|---|---|---|
| 1 | Understanding Exceptions in Java | See what actually happens when your program crashes — understand the exception hierarchy, read stack traces, and know the difference between errors you can recover from and errors you can't | Catch ArithmeticException, ArrayIndexOutOfBounds, and NullPointerException in try blocks |
| 2 | The Try and Catch Block | Wrap risky code in try-catch blocks so your program handles problems gracefully instead of crashing, and use finally to guarantee cleanup code runs no matter what | Trace execution order through try-catch-finally with multiple catch blocks |
| 3 | Checked and Unchecked Exceptions | Know why the compiler forces you to handle IOException but not NullPointerException — the checked vs. unchecked distinction that determines whether exception handling is required or optional | Create custom checked and unchecked exceptions and observe compiler enforcement |
Duration: ~4 hours
Learning Objective: Master Java I/O operations for reading and writing files. Learn to work with FileInputStream,
FileReader, byte streams, CharArrayReader, and BufferedReader for efficient file handling. Understand the differences
between byte streams and character streams.
| Unit | Lesson | What You'll Learn | Hands on Lab |
|---|---|---|---|
| 1 | File Handling in Java | Read from and write to files on disk — the essential I/O skill that separates toy programs from real applications that persist data between runs | Write and read files using FileOutputStream byte operations and append mode |
| 2 | FileInputStream and FileReader | Choose between byte streams and character streams for reading files, and understand why picking the wrong one garbles text data or wastes memory on binary files | Read files byte-by-byte, with buffered arrays, and line-by-line with BufferedReader |
| 3 | Byte Streams and CharArrayReader | Process data in memory without touching the file system using ByteArrayInputStream and CharArrayReader — the same approach used for testing, network data, and processing in-memory buffers | Process data with in-memory ByteArrayInputStream, ByteArrayOutputStream, and CharArrayReader |
| 4 | Enhancing IO Performance with Buffered Streams and BufferedReader | Speed up file operations dramatically by reading and writing in chunks instead of one byte at a time — buffered I/O is what makes the difference between code that processes a file in seconds vs. minutes | Apply BufferedWriter and BufferedReader to write, read, and copy files efficiently |
Duration: ~4 hours
Learning Objective: Master the Java Collections Framework including List, Set, and Collection interfaces. Learn to work
with ArrayList, understand Iterator pattern, and choose the right collection type for different scenarios.
| Unit | Lesson | What You'll Learn | Hands on Lab |
|---|---|---|---|
| 1 | Understanding Java Collections Framework | Move beyond fixed-size arrays to dynamic data structures — ArrayList grows automatically, HashSet prevents duplicates, and HashMap stores key-value pairs, each solving a problem arrays can't | Replace fixed-size arrays with ArrayList, HashSet, and HashMap |
| 2 | Understanding the Collection Framework Hierarchy | See how List, Set, Map, and Queue relate to each other in Java's interface hierarchy — knowing this structure lets you swap implementations without rewriting your code | Compare ArrayList, HashSet, TreeSet, and HashMap behavior with the same data |
| 3 | Exploring Java's Collection Interface | Use the Collection interface methods that every list, set, and queue shares: add, remove, contains, retainAll, and iterate with Iterator — write code that works with any collection type | Apply add, remove, retainAll, removeAll, and Iterator on Collection interface |
| 4 | Deep Dive into Java's List and Set Interfaces | Know when to use a List (ordered, allows duplicates, access by index) vs. a Set (unordered, no duplicates, fast lookup) — the choice that comes up in almost every real Java project | Use List index operations and Set uniqueness to manage observation records |
| 5 | Mastering ArrayList and Iterator in Java | Use ArrayList for everyday dynamic lists, and safely remove elements during iteration with Iterator — avoiding the ConcurrentModificationException that trips up nearly every beginner |
Duration: ~4 hours
Learning Objective: Master Java's date and time handling using both legacy (util.Date, Calendar, TimeZone) and modern (
Java 8+ Date and Time API) approaches. Learn to work with LocalDate, LocalTime, LocalDateTime, ZonedDateTime, and format
dates using DateTimeFormatter.
| Unit | Lesson | What You'll Learn | Hands on Lab |
|---|---|---|---|
| 1 | Java Date Handling: Working with the util.Date Class | Work with Java's original Date class — understand its mutability pitfalls and why millions of lines of legacy code still use it, so you can read and maintain older Java projects | Compare, format, and defensively copy Date objects to observe mutability pitfalls |
| 2 | Navigating Java's Calendar and TimeZone Classes | Add days, months, and years to dates using Calendar, and convert times across time zones — the pre-Java-8 approach you'll still encounter in enterprise codebases | Apply Calendar field extraction, date arithmetic, and TimeZone conversion |
| 3 | Java 8 Date and Time API | Use the modern LocalDate, LocalTime, and LocalDateTime classes that replaced the old Date/Calendar mess — immutable, thread-safe, and designed to actually make sense | Use immutable LocalDate, LocalTime, Period, and DateTimeFormatter for scheduling |
| 4 | Java Date and Time API: Advanced Features | Calculate exact durations between events, work with time zones using ZonedDateTime, and measure elapsed time with Instant and ChronoUnit — the tools behind scheduling, logging, and timeout logic | Measure intervals with Instant, ChronoUnit, Period, YearMonth, and ZonedDateTime |
| 5 | Formatting Date and Time using DateTimeFormatter | Format dates into any pattern your application needs — "March 5, 2024" or "2024-03-05" or "05/03/24" — and parse date strings back into objects safely | Parse and reformat dates with custom DateTimeFormatter patterns and round-trip testing |
Yes. Zero hidden charges. You get lifetime access to all 50+ hours of content, over 50 hands-on lab exercises, 56 lessons, and course materials at no cost. Unlike Coursera that charges for certificates or limits access, this free Java course gives you everything -- completely free, permanently.
Coursera lets you "audit" courses but locks graded assignments behind paywalls, charges $49-$79 for certificates, and expires your access after a period. Udemy courses go on sale frequently but still cost money, vary wildly in quality, and often become outdated. This free Java course gives you permanent lifetime access to everything. All lab exercises, materials, and Oracle certification alignment included. You save $200-$500 compared to paid platforms.
Completely. Every module includes hands-on coding exercises where you write actual Java programs. Our built-in browser-based editor lets you code, run, and see results instantly from day one. The 50+ labs provide step-by-step guidance while challenging you to apply concepts immediately. This isn't passive learning -- this free Java course is built around practice.
Absolutely. This free Java course starts from zero programming knowledge. Module 1 covers fundamental concepts like variables and data types. Each lesson builds progressively on previous knowledge with labs at every skill level. Career switchers appreciate the structured, comprehensive approach that mirrors university CS programs without the tuition cost.
The course contains 50+ hours of content. Most students finish in 8-10 weeks studying 5-10 hours per week. You can go faster with intensive study (4-6 weeks at 15-20 hours weekly) or slower with casual evening sessions (3-4 months). Lifetime access means no pressure to rush.
You'll learn all core Java skills needed for entry-level positions: object-oriented programming, data structures fundamentals, exception handling, file I/O, and collections. After completing this free Java course, build 2-3 portfolio projects, contribute to open-source Java projects on GitHub, and practice coding problems on LeetCode or HackerRank. The course gives you the foundation. Portfolio projects show employers you can apply it.
The curriculum aligns with two Oracle certification exams: Java Foundations (1Z0-811) for beginners and Java SE 8 Programmer I (1Z0-808) which is industry-recognized. All exam objectives are covered in this free Java course. Oracle certification exams themselves cost $245-$295 to take separately. This course prepares you thoroughly for both.
Yes. Bootcamps charge $10,000-$15,000 for similar content. This free Java course covers the same core Java curriculum with 50+ hours of structured content comparable to 8-12 week bootcamp modules. Bootcamps offer career services, live instructor support, and cohort networking that this course doesn't provide. But if you're self-motivated, you can absolutely learn Java fundamentals here.
This free Java course includes a built-in browser-based Java editor. Write code, hit Run, and see results instantly — no downloads, no installation, no configuration. You can start coding in seconds right from the lesson page. If you prefer a desktop IDE for larger projects, any Java IDE will work, but the built-in editor is all you need for this course.
You'll have the foundational knowledge employers expect: core Java syntax, OOP principles, exception handling, file I/O, Collections Framework basics, and date-time handling. To be competitive for jobs, also learn Spring Framework and Spring Boot for web applications, SQL and databases, RESTful API development, and unit testing with JUnit. Think of this free Java course as semester one of your Java education. You'll be job-ready after building 2-3 real projects and learning a framework like Spring Boot.
This is a text-based course with an integrated coding environment. You read lessons, write code, and run programs right in your browser. YouTube offers scattered video tutorials with no clear learning path, inconsistent tool recommendations, and often outdated content using Java 6-8. This free Java course provides logical progression through 11 modules, 50+ integrated labs, Oracle certification alignment, regular updates with Java 21, and 560 interview prep questions. Use YouTube for supplemental video explanations if you want, but follow this course as your primary learning path.
The course contains 50+ hours of content and labs. Realistic time investment is 50 hours for lectures and guided labs, plus 50-100 hours for practice exercises, debugging, and experimentation. Expect 100-150 hours total to complete thoroughly. Learning Java is a marathon. This free Java course gives you the roadmap. Your practice determines how quickly you master it.
Perfect for high school students exploring programming before college, preparing for AP Computer Science A exam, or building projects for college applications. This free Java course requires no prior knowledge and teaches professional practices from the start. Many concepts overlap with AP CS curriculum.
Yes. You'll be able to read and understand existing Java codebases, fix bugs in Java projects, add small features to open-source projects, and submit pull requests on GitHub. Start with "good first issue" tags on GitHub repositories.
This free Java course uses Java 21 (LTS) but covers features introduced across versions: Java 8 (Lambda expressions, Stream API, Date/Time API in Module 11), Java 11 (var keyword, String methods), and Java 17 and 21 (modern syntax and best practices). You'll understand both legacy codebases using Java 8+ and modern development.
Just click the Module 1 link above and start reading. No setup needed — everything runs in your browser. Write your first Java program directly in the lesson page, hit Run, and see it work. No registration, no downloads, no payment, no waiting. This free Java course is ready when you are.
Each lesson includes detailed explanations with over 1000 code snippets you can run and modify. Labs show step-by-step instructions with expected outputs. Join our Discord community to ask questions, get help from other students, and share solutions. The course structure anticipates common mistakes and explains concepts multiple ways.
Last Updated: February 20, 2026