Java-Code

public boolean istSchaltjahr(int jahr)
{
if(jahr%4 == 0 && (jahr%100 != 0 || jahr%400 == 0)
{
return true;
}
return false; 
}

Java-Code

public class Schaltjahr {
   public static boolean isSchaltjahr ( int year ) {
      if ( year % 400 == 0 ) 
	 return true ;
      if ( ( year % 4 == 0 ) && ( ! ( year % 100 == 0 ))) 
	 return true ;
      return false ;
    }
   public static void main( String[] args ) {
      if ( args.length != 1 ) {
	 System.out.println( "Error! Call java Schaltjahr <Jahreszahl>!" ) ;
	 System.exit( 1 ) ;
      }
      else {
	 int year = Integer.parseInt( args[ 0 ] ) ;
	 if ( year < 1 ) {
	    System.out.println( "Jahr muss >= 1 sein!" ) ;
	    System.exit( 2 ) ;
	 }
	 else {
	    System.out.print( "Das Jahr " + year + " war " ) ;
	    System.out.print( isSchaltjahr( year ) ?"ein" : "kein" ) ;
	    System.out.println( " Schaltjahr!" ) ;
	 }
      }
   }

Java-Code

 
   public static boolean isSchaltjahr(int year) {
      if (year % 4 == 0)
         return true;
      return false;
   }

Java-Code

public static boolean isSchaltjahr(int year) {
   return new GregorianCalendar().isLeapYear(jahr);
}

Java-Code

	public static  Boolean isLeapYear(int i) {
		if ( (i%400)==0   ||     (   (i%4==0)   &&   ((i%100) != 0)   )    ) {
			return true;
		} else {
			return false;
		}		
		
	}

Java-Code

public static boolean isSchaltjahr(int year) {

		if((year%4 == 0) && ((year%100 != 0) || (year%400 == 0))){
			return true;
			
		}else return false;
	}

Java-Code

//©2012 by Julius J. Hoffmann
//written with Eclipse

import java.util.*;  //Importiert Scanner zum Einlesen der Eingabe

public class Schaltjahr {		//Die "ausführende Klasse"
	
	public static boolean isSchaltjahr(int year)				//Die Methode zur Überprüfung, vom typ boolean
	{
		if (year%4 == 0 && (year%100 != 0 || year%400 == 0))	//Kontrollabfrage mit booleschen Operatoren (s.u.)
				return true;									//Rückgabe WAHR, wenn die Regeln zutreffen, -> Methode endet HIER
		return false;											//Rückgabe FALSCH, else entfällt, da die Methode bei return autom. endet
	}		//Ende isSchaltjahr-Methode
	
//-------OPTIONAL:-----------------------------------------------------	

	public static void main(String[] args)								//main-Methode
	{
		System.out.print("Bitte Jahr eingeben");						//Ausgabe des Strings
		Scanner s = new Scanner(System.in);								//legt das Scanner-Objekt an
		int y = s.nextInt();											//liest die manuelle Eingabe ein und speichert sie in der Variablen y
		if (isSchaltjahr(y)) System.out.print(y+" ist ein Schaltjahr");	//Abfrage, kein Vgl. nötig, da dieser auch nur dazu dient  
																		//if einen true/false Wert zu übergeben, Ausgabe, wenn Schaltjahr
		else System.out.print(y+" ist kein Schaltjahr");				//Ausgabe, wenn kein Schaltjahr
		//Hier ist else nötig, da die Methode nach der Ausgabe weiterläuft und sonst beides anzeigen würde
	}	//Ende main-Methode
}	//Ende Klasse

/**
Die verwendeten booleschen Operatoren:
- && -> Und, verbindet mehrere Bedingungen
- || -> Oder, es reicht wenn EINE der beiden Bedingungen zutrifft (im Gegensatz zu XOR!)

Weitere Operatoren:
a&b -> gibt den Rest zurück, so lässt sich mit einer 0-Abfrage kontrollieren ob a ein Teiler von b ist
*/

Java-Code

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

Java-Code

/**
 * @author ElPapito
 * @date 07.05.2015
 */

import java.util.Scanner;

public class JahrAufSchaltjahrPruefen {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.print("Bitte ein Jahr eingeben: ");
		int year = scanner.nextInt();
		scanner.close();

		if (isSchaltjahr(year)) {
			System.out.println("Schaltjahr!");
		} else {
			System.out.println("Kein Schaltjahr!");
		}
	}

	public static boolean isSchaltjahr(int year) {
		if (year % 400 == 0) {
			return true;
		} else if (year % 100 == 0) {
			return false;
		} else if (year % 4 == 0) {
			return true;
		} else {
			return false;
		}
	}

}

Java-Code

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

Java-Code

package java_helloworld;

import java.util.Scanner;

public class IsLeapYear {
	/**
	 * Rules for the leap year: 
	 * 1. x % 4 == 0 
	 * 2. x % 100 != 0 
	 * 3. x % 400 == 0
	 */
	private static boolean leapYear = false;
	private static int year;

	public static boolean isSchaltjahr(int year) {
		if (year % 4 == 0)
			leapYear = true;
		if (year % 100 == 0)
			leapYear = false;
		if (year % 400 == 0)
			leapYear = true;
			
		return leapYear;
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		boolean error = true;

		System.out.println("Schaltjahr");
		System.out.println("Bitte gib das Jahr ein: ");

		while (error) {
			if (sc.hasNextInt())
				year = sc.nextInt();
			else {
				System.out.println("Das ist keine Jahreszahl!");
				System.out.println("Versuch es noch ein Mal: ");
				sc.next();
				continue;
			}
			error = false;
		}
		
		isSchaltjahr(year);
		
		if (leapYear)
			System.out.println("Das Jahr " + year + " ist ein Schaltjahr!");
		else
			System.out.println("Das Jahr " + year + " ist kein Schaltjahr!");
		
		sc.close();
	}
}

Java-Code

/* @Author H.K.
 * @Date 21.02.2016
 * 
 * Programmbeschreibung:
 * Eingegebenes Jahr auf Schaltjahr überprüfen
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class mainprogram {

	public static void main ( String args[] ) throws IOException
	{
		int jahr = 0;
		while (jahr == 0)
		{
		System.out.print ( "Prüfe auf Schaltjahr, bitte das Jahr eingeben: " );
	    BufferedReader input = new BufferedReader ( new InputStreamReader ( System.in ) );
	    String inputString = input.readLine();
	    if (inputString.matches("-?\\d+?")) {
	    jahr = Integer.parseInt(inputString);
            boolean schaltjahr = isSchaltjahr(jahr);
	    System.out.println(schaltjahr);
		}
	    else {
	    	System.out.println("Eingabe ist kein Jahr!");
	    }
		}	
	}
	
	public static boolean isSchaltjahr(int year) {
		boolean isSchaltjahr = false;
		isSchaltjahr = year%4 == 0 && (year%100 != 0 || year%400 == 0);
	    return isSchaltjahr;
	}
}

Java-Code

/*
 * Max F. 07.04.2016
 *
 * Jedes 4. Jahr ist ein Schaltjahr
 * Jedes 100. Jahr ist aber kein Schaltjahr
 * Jedes 400. Jahr ist ein Schaltjahr
 */

public class Schaltjahr {

	public static void main(String[] args) {
		int aktuellesJahr;
		aktuellesJahr=2016;
		if (isSchaltjahr(aktuellesJahr)) //Prüfe mit Methode ob es ein Schaltjahr ist
			System.out.println("Das Jahr "+aktuellesJahr+" ist ein Schaltjahr");
		else
		System.out.println("Das Jahr "+aktuellesJahr+" ist kein Schaltjahr");
	}

	public static boolean isSchaltjahr(int year) {
		if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))//Math. Bestimmung eines Schaltjahres
			return true;
		else
			return false;
	}
}

Java-Code

public static boolean isSchaltjahr(int year)
{
    if(year <= 0)
    {
        return false;
    }

    if(year % 400 == 0)
    {
        return true;
    }

    if(year % 100 == 0)
    {
        return false;
    }

    if(year % 4 == 0)
    {
        return true;
    }

    return false;
}

Java-Code

package de.exception.schaltjahr_2;

public class MyCalendar {
	
	public static boolean isLeapyear(int year) {
		/**
		 * Eine Lösung wäre mit der in der LocalDate Klasse verfügbaren isLeapYear(year) Methode auch möglich.
		 */
		return ((year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0)));
	}
}

Java-Code

package de.exception.schaltjahr_2;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

class testLeapYear {

	@Test
	void test() {	
		assertEquals(true, MyCalendar.isLeapyear(2008));
		assertEquals(true, MyCalendar.isLeapyear(2012));
		assertEquals(true, MyCalendar.isLeapyear(2016));
		assertEquals(true, MyCalendar.isLeapyear(2020));
		assertEquals(false, MyCalendar.isLeapyear(2021));
		assertEquals(false, MyCalendar.isLeapyear(2022));	
		assertEquals(false, MyCalendar.isLeapyear(2023));	
		assertEquals(true, MyCalendar.isLeapyear(2024));	
	}

}

Java-Code

public static boolean isSchaltjahr(int year) {
if (year%4==0){
return true;
}
}

Java-Code

import javax.swing.JOptionPane;

/**
 * Prüfen ob ein Jahr ein Schaltjahr ist.
 * 
 * @author (nOrdan) 
 * @version (29.05.2019 18:12)
 */

public class Schaltjahr
{
    /**
     * Konstruktor für Objekte der Klasse Schaltjahr
     */
    public Schaltjahr()
    {

    }

    public void schaltjahrPruefen()
    {
        boolean valid = false; //Hilfsvariable für die While-Schleife
        while (valid == false) //While-Schleife ,so dass der User nach falscher Eingabe erneut aufgefordert wird ein Jahr einzugeben
        {
            String input = JOptionPane.showInputDialog("Geben sie ihr Jahr ein, welches sie prüfen wollen"); //Eingabe des Users
            try //Hiermit sollen keine Zahleneingaben abgefangen werden siehe beim ersten else 
            {
                if (input == null) 
                {
                    System.exit(0); //Drückt der User auf abbrechen wird null zurück gegeben und das Programm wird beendet
                }
                else if (input.length() == 0)
                {
                    continue; //Gibt der User nichts ein und drückt auf Ok wird die While-Schleife weiter fortgeführt bis der User etwas eingibt und auf Ok drückt
                }
                else
                {
                    int jahr = Integer.parseInt(input); //Umwandlung des Inputs in einen int   
                    valid = true; //Beenden der While-Schleife indem man die Hilfsvariable auf true setzt
                    if (istSchaltjahr(jahr) == true) //Ergebnisrückgabe ob das eingegebene Jahr ein Schaltjahr ist oder nicht
                    {
                        JOptionPane.showMessageDialog(null,"Das Jahr " + jahr + " ist ein Schaltjahr");                
                    }
                    else
                    {
                        JOptionPane.showMessageDialog(null,"Das Jahr " + jahr + " ist kein Schaltjahr");
                    }
                }
            }
            catch (Exception e) //Greift wenn keine Zahl vom User eingegeben wurde, danach erneute Abfrage des Users wegen der While-Schleife
            {
                JOptionPane.showMessageDialog(null,"Invalid Input", "Error", JOptionPane.ERROR_MESSAGE); 
            }   
        }
    }

    private boolean istSchaltjahr(int jahr)
    {
        if ((jahr % 4 == 0) && ((jahr % 100 != 0) || (jahr % 400 == 0))) //Prüfen ob Schaltjahr nach den Schaltjahrregeln
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

Java-Code

import java.util.Scanner;

public class Main {
	
	public static void main(String argsp[]) {
		
		String userInput;
		Scanner s = new Scanner(System.in);
		System.out.println("Bitte das zu überprüfende Jahr eingeben:");
		
		do {
			userInput = String.valueOf(s.next());
			if(tryParseInt(userInput)) {
				int userNumber = Integer.parseInt(userInput);				
				isSchaltjahr(userNumber);
			}
			else {
				System.out.println("Dies ist keine gültige Eingabe, bitte ein Jahr eingeben:");
			}
		} while(!tryParseInt(userInput));
	}
	
	static boolean isSchaltjahr(int year) {
		if(year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) {
			System.out.println("Das Jahr " + year + " ist ein Schaltjahr");
			return true;
		}
		else {
			System.out.println("Das Jahr " + year + " ist kein Schaltjahr");
			return false;
		}
	}
	
	static boolean tryParseInt(String userInput) {  
	     try {
	    	 Integer.parseInt(userInput);  
	         return true;  
	     } catch (NumberFormatException e) {	    	 
	         return false;
	     }
	}
}

Java-Code

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class Schaltjahr {
	public static void main(String[] args) {

		SchaltjahrPruefen schp = new SchaltjahrPruefen("Schaltjahr prüfen");

	}
}

class SchaltjahrPruefen extends JFrame implements ActionListener {
	JLabel lbl = new JLabel("Geben Sie das Jahr ein: ");
	JTextField tfEingabe = new JTextField(10);
	JTextField tfAusgabe = new JTextField(20);
	JPanel pEingabe = new JPanel();
	JPanel pAusgabe = new JPanel();

	SchaltjahrPruefen(String titel) {
		super(titel);
		setVisible(true);
		setSize(300, 300);
		setLocationRelativeTo(null);
		setLayout(new FlowLayout());

		tfEingabe.addActionListener(this);
		tfAusgabe.setEditable(false);

		pEingabe.add(lbl);
		pEingabe.add(tfEingabe);
		pAusgabe.add(tfAusgabe);

		add(pEingabe);
		add(pAusgabe);

	}

	public static boolean isSchaltjahr(int jahr) {
		if ((jahr % 4 == 0 && !(jahr % 100 == 0)) || (jahr % 400 == 0))
			return true;
		else
			return false;
	}

	@Override
	public void actionPerformed(ActionEvent evt) {

		try {
			int zahl = Integer.parseInt(tfEingabe.getText());
			isSchaltjahr(zahl);
			if (isSchaltjahr(zahl)) {
				tfAusgabe.setText(tfEingabe.getText() + " ist Schaltjahr");
			} else {
				tfAusgabe.setText(tfEingabe.getText() + " ist kein Schaltjahr");
			}
		} catch (NumberFormatException e) {
			tfAusgabe.setText("Bitte Ganzzahl eingeben!");
		}
	}

}

Java-Code

import java.util.Scanner;

public class JahrAufSchaltjahrUeberpruefen {

	public static void main(String[] args) {
		
		System.out.println(isSchaltjahr(new Scanner(System.in).nextInt()));
		
	}
	
	public static boolean isSchaltjahr(int year) {
		
		if (year%4 == 0) {
			
			if (year%100 == 0 && year%400 != 0) {
				return false;
			}
			
			return true;
			
		}
		
		return false;
		
	}

}

Java-Code

/**
 * Test, whether a given year (int) is a leap year.
 * Use a method that returns a boolean.
 */

import java.util.Scanner;

class LeapYear {
    static boolean isLeapYear(int year) {
            if (year % 400 == 0) {
                return true;
            } else if ((year % 4 == 0) && !(year % 100 == 0)) {
                return true;     
            } else {
                return false;
            }
            // shorter possibility: return ((year % 400 == 0) || ((year % 4 == 0) && !(year % 100 == 0)));
        }
        
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int year = 0;
        boolean inputType = false;
        while (!inputType) {
            System.out.println("Please enter a year (integer):");
            try { 
                year = scan.nextInt();
                inputType = true;
            } catch (Exception e) {
                System.out.println("Error: Input is not an integer!");
                scan.next();
            }
        }
        scan.close();
        
        if (isLeapYear(year)) {
            System.out.println(year + " is a leap year.");
        } else {
            System.out.println(year + " is not a leap year.");
        }
    }
}