Java Leap Year Program

Leap year calculations play a crucial role in calendar systems, scheduling algorithms, and date validations. A leap year occurs every four years, ensuring that our calendar stays aligned with the Earth's orbit.

Without leap years, dates would gradually drift, affecting everything from financial transactions to astronomical calculations.

In this tutorial, you'll learn what defines a leap year, how to implement a Java program to check for leap years, and explore different approaches, including if-else conditions, Java's LocalDate API, and optimized solutions.

Improve your Java programming skills with our Software Development courses — take the next step in your learning journey!

Understanding Leap Year Rules

Leap years follow a simple but precise rule to keep the Gregorian calendar in sync with the Earth’s revolution around the Sun. A year qualifies as a leap year if:

• It is divisible by 4 (e.g., 2024, 2028).
• However, if it is divisible by 100, it must also be divisible by 400 (e.g., 2000 was a leap year, but 1900 was not).

For example:

• Leap Years: 1600, 2000, 2024, 2028
• Non-Leap Years: 1700, 1800, 1900, 2100

These rules ensure that extra leap days are added only when necessary, preventing long-term drift in the calendar.

Also Read: Exploring the 14 Key Advantages of Java: Why It Remains a Developer's Top Choice in 2025

Now that you understand the leap year rules, it's time to implement a Java leap year check. Let’s explore different approaches to writing a Java leap year program, from basic if-else conditions to modern Java methods.

Finding Leap Year Using Java

In Java, checking whether a year is a leap year involves simple modulus-based conditions. The most common approach uses if-else statements to apply the divisibility rules (by 4, 100, and 400).

Java also provides a more modern solution using LocalDate.isLeapYear(), which simplifies the process. In this section, you'll explore multiple implementations, from basic condition checks to optimized, concise methods.

Basic Java Leap Year Program (Using If-Else Condition)

The simplest way to perform Java leap year check is by applying modulus-based conditions in an if-else statement. The program follows these rules:

1. If the year is divisible by 4, it is a leap year unless:

2. The year is also divisible by 100, in which case it must be divisible by 400 to be a leap year.

Implementation: Basic If-Else Leap Year Check:

import java.util.Scanner;

public class LeapYearCheck {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Taking input from the user
        System.out.print("Enter a year: ");
        int year = scanner.nextInt();

        // Applying leap year conditions
        if (year % 4 == 0) {
            if (year % 100 == 0) {
                if (year % 400 == 0) {
                    System.out.println(year + " is a leap year.");
                } else {
                    System.out.println(year + " is not a leap year.");
                }
            } else {
                System.out.println(year + " is a leap year.");
            }
        } else {
            System.out.println(year + " is not a leap year.");
        }

        scanner.close();
    }
}

Explanation:

1. User Input: The program takes an integer year input from the user using Scanner.

2. Divisibility Checks:

• The outer if checks if the year is divisible by 4.
• The second if checks if the year is also divisible by 100 (which may disqualify it as a leap year).
• The innermost if checks if the year is divisible by 400, making it a valid leap year.
• If a year fails any of these checks, it is not a leap year.

Example Runs:

Input: 2024 → Output: 2024 is a leap year.

Input: 1900 → Output: 1900 is not a leap year.

Input: 2000 → Output: 2000 is a leap year.

This approach directly implements the leap year rules using a nested if-else structure, ensuring correctness.

Here are the key takeaways of this approach:

• Nested If-Else ensures correct application of leap year rules.
• Handles edge cases like centuries correctly (e.g., 1900 is not a leap year, but 2000 is).
• Uses Scanner to take user input, making it interactive.

This approach provides a clear, structured way to determine leap years while ensuring correctness based on Gregorian calendar rules.

Also Read: String Functions In Java | Java String [With Examples]

Java Leap Year Program Using Scanner for User Input

User input validation is essential in Java programs to handle unexpected or invalid entries gracefully. This section enhances the basic leap year program by:

• Allowing user input via Scanner.
• Handling non-numeric inputs to prevent runtime errors.
• Ensuring that only valid positive integers are accepted.

Java Implementation: Leap Year Check with User Input Validation:

import java.util.Scanner;

public class LeapYearScanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int year = 0;

        // Asking for user input and validating it
        while (true) {
            System.out.print("Enter a valid year: ");
            if (scanner.hasNextInt()) { // Check if input is an integer
                year = scanner.nextInt();
                if (year > 0) { // Ensure it's a positive year
                    break;
                } else {
                    System.out.println("Year must be a positive number. Try again.");
                }
            } else {
                System.out.println("Invalid input. Please enter a numeric year.");
                scanner.next(); // Consume invalid input
            }
        }

        // Leap year validation logic
        boolean isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
        
        // Display result
        if (isLeap) {
            System.out.println(year + " is a leap year.");
        } else {
            System.out.println(year + " is not a leap year.");
        }

        scanner.close();
    }
}

Explanation:

1. Validating User Input

• Uses scanner.hasNextInt() to ensure the user enters a valid integer.
• If the input is not an integer, an error message is displayed, and the input is ignored.
• Ensures the year is positive, prompting the user again if they enter a negative value.

2. Leap Year Calculation

• Uses a single Boolean expression:

boolean isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);

• This replaces the nested if-else structure for a more concise and efficient approach.

3. Graceful Error Handling

• Prevents the program from crashing on invalid input (e.g., "Hello" instead of a number).
• Loops until the user enters a valid, positive integer.

Expected Output:

Test Case 1: Valid Input (Leap Year)

Input:
Enter a valid year: 2024
Output:
2024 is a leap year.

Test Case 2: Valid Input (Not a Leap Year)

Input:
Enter a valid year: 2023
Output:
2023 is not a leap year.

Test Case 3: Invalid Input (Non-Numeric)

Input:
Enter a valid year: abc
Output:
Invalid input. Please enter a numeric year.
Enter a valid year: 2024
2024 is a leap year.

Test Case 4: Invalid Input (Negative Number)

Input:
Enter a valid year: -200
Output:
Year must be a positive number. Try again.
Enter a valid year: 2000
2000 is a leap year.

Here are the key takeaways:

• Ensures input is numeric and positive to prevent runtime errors.
• Uses a loop to re-prompt users until they enter a valid year.
• Improves efficiency by using a single Boolean condition instead of nested if-else.

This user-friendly and error-proof approach makes the leap year program more robust and reliable.

Also Read: Ultimate Guide to Synchronization in Java

Java Leap Year Program Using LocalDate (Java 8+)

With Java 8 and later, the java.time package introduces a modern, reliable way to handle date and time operations. Instead of manually checking divisibility rules, Java provides the built-in isLeapYear() method in the LocalDate class, making leap year calculations cleaner and more readable.

Why Use LocalDate Instead of Manual Conditions?

• Simplifies code – No need for complex if-else checks.
• Improves accuracy – Uses Java’s built-in Gregorian calendar rules.
• More readable – Directly calls isLeapYear() instead of using modulus-based logic.
• Future-proof – Works well with other Java Date-Time APIs.

Java Implementation: Leap Year Check Using LocalDate:

import java.time.Year;
import java.util.Scanner;

public class LeapYearLocalDate {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Taking user input for the year
        System.out.print("Enter a year: ");
        int year = scanner.nextInt();

        // Using LocalDate API to check if it's a leap year
        boolean isLeap = Year.of(year).isLeap();

        // Display result
        if (isLeap) {
            System.out.println(year + " is a leap year.");
        } else {
            System.out.println(year + " is not a leap year.");
        }

        scanner.close();
    }
}

Explanation:

1. Using Year.of(year).isLeap()

• The Year class from java.time provides a direct method .isLeap(), eliminating the need for manual checks.
• It internally follows the Gregorian calendar leap year rules, ensuring accuracy.

2. Simpler and More Readable Code: Instead of multiple if-else conditions, the leap year check is done in one line:

boolean isLeap = Year.of(year).isLeap();

3. Works Well with Other Date APIs

• Easily integrates with LocalDate, ZonedDateTime, and other time-based classes.
• Useful for validating leap years when working with dates in real-world applications.

Expected Output:

Test Case 1: Leap Year (2024)

Input:
Enter a year: 2024
Output:
2024 is a leap year.

Test Case 2: Not a Leap Year (1900)

Input:
Enter a year: 1900
Output:
1900 is not a leap year.

Test Case 3: Leap Year (2000)

Input:
Enter a year: 2000
Output:
2000 is a leap year.

Test Case 4: Not a Leap Year (2023)

Input:
Enter a year: 2023
Output:
2023 is not a leap year.

Here are the key takeaways:

• Simplifies leap year checks using Year.of(year).isLeap().
• More accurate and future-proof than manual conditions.
• Integrates seamlessly with other Java Date-Time APIs.

Using LocalDate or Year is the modern, efficient way to handle leap year calculations in Java 8+ applications!

Also Read: Multithreading in Java - Learn with Examples

Optimized Java Leap Year Program Using Ternary Operator

For small-scale applications where brevity matters, the ternary operator (? :) provides a concise one-liner to check for leap years. This approach eliminates the need for nested if-else statements, making the code more compact and readable.

Why Use the Ternary Operator?

• Reduces code length – Single-line expression instead of multiple conditions.
• Easier to read and maintain – Avoids deep nesting of if-else.
• Best for quick checks – Useful in inline expressions or simple scripts.

Java Implementation: Leap Year Check Using Ternary Operator:

import java.util.Scanner;

public class LeapYearTernary {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Taking user input
        System.out.print("Enter a year: ");
        int year = scanner.nextInt();

        // Ternary operator for leap year check
        String result = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) 
                        ? year + " is a leap year." 
                        : year + " is not a leap year.";

        System.out.println(result);

        scanner.close();
    }
}

Code Explanation:

1. Using a Single Ternary Expression:

• The condition (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) checks for a leap year.
• If true, it returns "year is a leap year."; otherwise, "year is not a leap year.".

2. Compact and Readable: Converts multi-line if-else logic into a one-liner, making it ideal for quick calculations.

3. Efficient Execution: No redundant condition checks—directly evaluates the expression and prints the result.

Expected Output:

Test Case 1: Leap Year (2024)

Input:
Enter a year: 2024
Output:
2024 is a leap year.

Test Case 2: Not a Leap Year (1900)

Input:
Enter a year: 1900
Output:
1900 is not a leap year.

Test Case 3: Leap Year (2000)

Input:
Enter a year: 2000
Output:
2000 is a leap year.

Test Case 4: Not a Leap Year (2023)

Input:
Enter a year: 2023
Output:
2023 is not a leap year.

Here are the key takeaways:

• Uses a one-liner ternary operator for a concise leap year check.
• Best suited for simple applications, quick checks, and inline expressions.
• Reduces unnecessary nesting compared to traditional if-else structures.

This method provides an efficient and minimalistic way to check leap years, making it perfect for small-scale applications and quick evaluations!

Also Read: Top 13 String Functions in Java | Java String [With Examples]

While implementing a leap year check is straightforward, certain edge cases and performance challenges must be addressed. Let’s dive into handling negative years, large inputs, and compatibility across Java versions.

Performance Considerations and Edge Cases in Leap Year Calculation

When implementing a Java leap year check, it's important to consider edge cases and performance bottlenecks, especially when dealing with negative years (BC years), large inputs, and Java version compatibility.

1. Handling Negative Years (BC Years)

Issue: Java does not inherently distinguish between BC and AD years, but historical computations may require handling negative year values.

Some historical calendars, such as the Julian calendar, define leap years differently.

Solution: Allow negative years in input and handle them similarly to positive years. If working with historical calculations, consider adjusting logic for pre-Gregorian calendar rules.

Example:

int year = -44; // 44 BC
boolean isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
System.out.println(year + " BC is " + (isLeap ? "a leap year." : "not a leap year."));

2. Checking Performance for Large Inputs

Issue: Java int (32-bit) supports values up to 2,147,483,647. If working with very large years, an integer overflow can occur.

Large computations (e.g., checking leap years for an extensive range) may affect performance.

Solution: Use long instead of int for large years. If handling astronomical or historical simulations, consider using BigInteger.

Example: Using long for Large Year Inputs

long year = 5_000_000_000L; // Large future year
boolean isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
System.out.println(year + " is " + (isLeap ? "a leap year." : "not a leap year."));

Why long? It supports values up to 9,223,372,036,854,775,807, preventing integer overflow.

3. Ensuring Compatibility with Different Java Versions

Issue: Java 7 and below rely on manual modulus-based logic for leap year checks.

Java 8+ introduces Year.of(year).isLeap(), which simplifies leap year validation using the java.time API.

Solution: If using Java 8+, prefer Year.of(year).isLeap() for accuracy and readability. If supporting legacy Java versions, stick to modulus-based logic.

Example: Java 8+ Compatible Leap Year Check

import java.time.Year;

public class LeapYearJava8 {
    public static void main(String[] args) {
        long year = 2024; 
        System.out.println(year + " is " + (Year.of((int) year).isLeap() ? "a leap year." : "not a leap year."));
    }
}

Why Use Year.of(year).isLeap()? It ensures consistency with Gregorian calendar rules and works seamlessly with modern Java applications.

Here are the key takeaways:

• Handle negative years carefully when working with historical data.
• Use long or BigInteger for very large year values to prevent overflow.
• Prefer Year.of(year).isLeap() in Java 8+ for simplified and accurate leap year calculations.
• For legacy Java versions, stick to manual modulus-based logic.

By addressing these edge cases and performance concerns, you can build a robust and future-proof leap year program!

Common Mistakes and Debugging Tips in Leap Year Calculation

Even though leap year logic seems straightforward, small mistakes can lead to incorrect results. Below are some of the most common pitfalls developers encounter and how to debug them effectively.

1. Misinterpreting the 100-Year and 400-Year Rules

Mistake: Some developers assume that a year divisible by 100 is always a leap year.

Example of incorrect logic:

if (year % 4 == 0 && year % 100 != 0) { // Incorrect
    System.out.println(year + " is a leap year.");
}

This incorrectly excludes years divisible by 400, such as 2000, which is a leap year.

Corrected Approach:

boolean isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);

Fix: Ensure that century years (divisible by 100) must also be divisible by 400 to be leap years.

Example Corrections:

• 1900 is not a leap year (divisible by 100 but not by 400).
• 2000 is a leap year (divisible by 400).

2. Forgetting Input Validation

Mistake: The program may crash if a user enters non-numeric input or negative years.

Example of problematic input:

Enter a year: Hello

• Causes InputMismatchException when using Scanner.nextInt().
• Accepting negative years without validation may produce unintended results.

Corrected Approach:

Scanner scanner = new Scanner(System.in);
int year;

while (true) {
    System.out.print("Enter a valid year: ");
    if (scanner.hasNextInt()) {
        year = scanner.nextInt();
        if (year > 0) break;
        else System.out.println("Year must be a positive number.");
    } else {
        System.out.println("Invalid input. Please enter a numeric year.");
        scanner.next(); // Consume invalid input
    }
}

Fix:

• Use hasNextInt() before nextInt() to avoid invalid input crashes.
• Re-prompt users if they enter negative years or non-numeric input.

3. Overcomplicating Conditions When a Modulus Check Suffices

Mistake: Some developers use nested if-else structures, making the code harder to read and maintain.

Overcomplicated Code:

if (year % 4 == 0) {
    if (year % 100 == 0) {
        if (year % 400 == 0) {
            System.out.println(year + " is a leap year.");
        } else {
            System.out.println(year + " is not a leap year.");
        }
    } else {
        System.out.println(year + " is a leap year.");
    }
} else {
    System.out.println(year + " is not a leap year.");
}

This works but is unnecessarily verbose.

Optimized Code Using a Single Boolean Expression:

boolean isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
System.out.println(year + (isLeap ? " is a leap year." : " is not a leap year."));

Fix:

• Removes unnecessary nesting, making the code more readable and efficient.
• Directly evaluates conditions using a single Boolean expression.

Here are some debugging tips:

1. Test with known leap years and non-leap years

• Use edge cases: 1600, 1700, 1800, 1900, 2000, 2024, 2023.
• Ensure results match the Gregorian calendar rules.

2. Add print statements for debugging

System.out.println("Checking divisibility: " + year);
System.out.println("Divisible by 4? " + (year % 4 == 0));
System.out.println("Divisible by 100? " + (year % 100 == 0));
System.out.println("Divisible by 400? " + (year % 400 == 0));

Helps trace where the logic fails in complex conditions.

3. Run the program in different Java versions

• Ensure compatibility with Java 7 and Java 8+.
• Prefer Year.of(year).isLeap() in Java 8+ for accuracy.

Here are some key takeaways:

• Follow the correct 100-year and 400-year rule logic to avoid miscalculations.
• Always validate user input to prevent crashes from non-numeric values.
• Simplify conditions using Boolean expressions instead of deep if-else nesting.
• Use print statements and edge cases for debugging to catch logical errors early.

Also Read: Length Of String In Java

Avoiding common pitfalls ensures your Java leap year program is efficient and accurate. Let’s wrap up with best practices, including choosing the right approach, testing edge cases, and ensuring compatibility with modern Java frameworks.

Best Practices and Final Thoughts

When implementing a Java leap year check, choosing the right approach depends on application requirements, maintainability, and performance considerations. Below are the best practices to follow:

1. Choose the Right Approach Based on Application Needs

• If working with legacy Java versions (Java 7 and below) → Use modulus-based if-else logic.
• If building a modern application (Java 8+) → Use LocalDate or Year.of(year).isLeap() for built-in reliability.
• If performance and code simplicity matter → Use the ternary operator for a concise, one-liner check.

2. Use LocalDate for Modern Java Applications

• Year.of(year).isLeap() in Java 8+ provides a cleaner, more accurate way to check for leap years.
• Works well with other date-time operations, reducing manual calculations.
• Ensures compatibility with internationalized and calendar-based applications.

3. Test Edge Cases to Ensure Accuracy

Always test with multiple cases, including:

• Common Leap Years → 1600, 2000, 2024
• Non-Leap Years → 1700, 1800, 1900, 2100
• Negative Years (BC Years) → -44, -100, -400
• Large Numbers (Performance Test) → 5,000,000,000

Use automated unit testing to validate edge cases:

assert Year.of(2024).isLeap() == true;  // Leap Year
assert Year.of(1900).isLeap() == false; // Not a Leap Year
assert Year.of(2000).isLeap() == true;  // Leap Year

Whether you’re handling user input, optimizing performance, or integrating with modern Java APIs, these techniques help build reliable applications that accurately determine leap years.

Also Read: String Array In Java: Java String Array With Coding Examples

To solidify your understanding of Java programming, test your knowledge with this quiz. It’ll help reinforce the concepts discussed throughout the tutorial and ensure you're ready to apply them in your projects.

Quiz to Test Your Knowledge on Java Leap Year Program

Assess your understanding of leap year rules, implementation methods, edge cases, and best practices by answering the following multiple-choice questions. Dive in!

1. Which of the following conditions correctly identifies a leap year?

a) A year divisible by 4 is always a leap year

b) A year divisible by 100 is always a leap year

c) A year divisible by 4 and not by 100, unless also divisible by 400

d) A year is a leap year only if it’s divisible by 400

2. Which Java class provides a built-in method to check leap years in Java 8+?

a) Date

b) Calendar

c) Year

d) Time

3. What will the following condition return for the year 1900?

boolean isLeap = (1900 % 4 == 0 && 1900 % 100 != 0) || (1900 % 400 == 0);

a) true

b) false

c) Throws an exception

d) Depends on the Java version

4. Which Java approach is the most concise way to check for a leap year?

a) Using an if-else structure

b) Using a ternary operator

c) Using Year.of(year).isLeap()

d) Using recursion

5. Why should you use Scanner.hasNextInt() before reading user input in a leap year program?

a) To prevent InputMismatchException from non-numeric input

b) To check if the year is a leap year

c) To avoid infinite loops

d) To convert user input into a floating-point number

6. Which of the following edge cases should be considered when checking for leap years?

a) Very large years (e.g., 5,000,000,000)

b) Negative years (BC years)

c) Non-numeric input from the user

d) All of the above

7. What is the output of Year.of(2024).isLeap() in Java 8+?

a) true

b) false

c) Throws an exception

d) Requires additional calculations

8. Which of the following statements about century years is correct?

a) Century years are always leap years

b) Century years are never leap years

c) Century years must be divisible by 400 to be leap years

d) Century years must be divisible by 100 but not by 400 to be leap years

9. Which data type should you use to handle very large year values to prevent overflow?

a) int

b) float

c) long

d) double

10. What is the main advantage of using Year.of(year).isLeap() over manual modulus-based conditions?

a) It runs faster than a modulus check

b) It follows the Gregorian calendar rules automatically

c) It works only with even years

d) It does not require an internet connection

This quiz ensures you have a solid grasp of leap year calculations, performance optimizations, and real-world considerations in Java.

Also Read: Top 8 Reasons Why Java Is So Popular and Widely Used in 2025

You can continue expanding your skills in Java with upGrad, which will help you deepen your understanding of advanced Java concepts and real-world applications.

Upskill with upGrad to Keep Up With Industry Trends

upGrad’s courses provide expert training on Java programming, date-time handling, and algorithmic problem-solving, including leap year calculations and real-world application development. You’ll gain hands-on experience with conditional logic, modular arithmetic, Java’s LocalDate API, and performance optimization to build efficient and reliable programs.

Below are some relevant upGrad courses:

• Core Java Basics
• JavaScript Basics from Scratch
• Learn Basic Python Programming
• Data Structures & Algorithms
• AI-Powered Full Stack Development Course by IIITB

You can also get personalized career counseling with upGrad to guide your career path, or visit your nearest upGrad center and start hands-on training today!

Similar Reads:

• Step by Step Java Tutorial Concepts - From Beginner to Pro
• What is Java? Java Programming Language Explained
• History of Java
• Java Tutorial for Beginners
• How Java Program Works?
• What is Java JDK? Java Development Kit
• C++ Vs Java: Choosing the Right Language for Your Project
• Difference between Python and Java
• Difference Between Java and JavaScript
• C++ Vs Java: Choosing the Right Language for Your Project
• Difference between Python and Java
• Difference Between Java and JavaScript
• From Java Source Code to Executable
• Java Installation on Linux: A Beginner-Friendly Guide
• Step-by-Step Guide: Installing Java on Windows 10
• Java Hello World Program: Your First Step into Java Programming

FAQs

1. Why does my leap year program fail for negative years (BC years)?

LocalDate follows ISO-8601, which doesn't support negative years. Use manual modulus-based logic for historical leap years.

2. Why does Year.of(year).isLeap() throw an exception for very large numbers?

Year.of(int year) only supports int range. Use BigInteger for astronomical calculations.

3. How do I optimize my leap year check for large-scale applications?

Use a lookup table or precomputed values instead of recalculating leap years for the same range repeatedly.

4. Why does my program crash when the user enters a non-numeric value?

Scanner.nextInt() throws InputMismatchException. Use scanner.hasNextInt() to validate input before reading it.

5. How can I efficiently determine the number of leap years in a given range?

Use count = (end/4 - end/100 + end/400) - (start/4 - start/100 + start/400); to compute it in O(1) time.

6. Why does my ternary-based leap year program give incorrect results?

Complex ternary conditions can cause logic errors. Use if-else if readability or correctness is affected.

7. How do I handle leap years in different calendar systems?

The Julian calendar (before 1582) had a different rule. Use custom logic instead of Java’s LocalDate.

8. What happens if I use double instead of int for leap year calculations?

Floating-point modulus (%) may introduce precision errors. Always use integer-based calculations.

9. Why does my program allow invalid years like 0000 or -1?

Java allows 0 as 1 BC in ISO-8601. Add validation to restrict non-positive years if needed.

10. How can I make my leap year function reusable?

Wrap it in a utility method:

public static boolean isLeapYear(int year) { return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); }

11. How can I write unit tests for my leap year function?

Use JUnit:

@Test public void testLeapYear() { assertTrue(isLeapYear(2024)); assertFalse(isLeapYear(1900)); }

This ensures correctness for multiple test cases.

Take the Free Quiz on Java

Answer quick questions and assess your Java knowledge

Start Quiz