Instrukcje warunkowe w programowaniu służą do warunkowego wykonywania instrukcji, w zależności od tego, czy pewien warunek (bądź warunki) jest spełniony, czy nie.

Instrukcje warunkowe sprawdzają prawdziwość pewnego warunku bądź warunków, tzn. sprawdzają, czy warunek jest prawdą (true) bądź fałszem (false). Warunki, które dają w wyniku wartości true bądź false zapisujemy za pomocą operatorów relacyjnych, o których wkrótce sobie opowiemy.

Spójrzmy na przykład użycia instrukcji warunkowej:

public class SprawdzMianownik {
  public static void main(String[] args) {
    double licznik, mianownik;

    licznik = 5;
    mianownik = 0;

    if (mianownik != 0) {
      System.out.println("Wynik: " + licznik / mianownik);
    } else {
      System.out.println("Mianownik nie moze byc = 0!");
    }
  }
}

W powyższym przykładzie skorzystaliśmy z instrukcji warunkowej do sprawdzenia, czy mianownik jest różny od 0. Sprawdzamy tutaj prawdziwość wyrażenia mianownik jest różny od 0 przy pomocy nowego operatora różne od ( != ):

• jeżeli mianownik jest różny od 0, to wykonana zostania instrukcja, która wypisuje na ekran wynik dzielenia zmiennej licznik przez mianownik,
• w przeciwnym razie, zostanie wykonana instrukcja, która wypisze na ekran komunikat o błędnej wartości mianownika.

Tylko jedna z instrukcji System.out.println zostanie wykonana. Ten przykład korzysta z instrukcji warunkowej if, a także sekcji else.

Składnia instrukcji warunkowych¶

Spójrzmy na składnię instrukcji warunkowych w języku Java:

if (warunek1) {
  instrukcja1;
} else if (warunek2) {
  instrukcja2;
} else if (warunek3) {
  instrukcja3;
} else {
  instrukcja_else;
}

Aby skorzystać z instrukcji warunkowej:

• najpierw używamy słowa kluczowego if,
• następnie, w nawiasach zapisujemy jeden bądź więcej warunków, których wartości mogą przyjmować jedną z dwóch możliwości: true bądź false,
• po warunku, w nawiasach klamrowych, umieszczamy instrukcje, które mają zostać wykonane w przypadku, gdy warunek będzie spełniony (będzie miał wartość true).

Spójrzmy na przykład prostej instrukcji warunkowej:

public class ProstaInstrukcjaIf {
  public static void main(String[] args) {
    int x = 5;

    if (x > 0) {
      System.out.println("x jest wieksze od 0.");
    }
  }
}

W powyższym przykładzie sprawdzamy, czy zmienna x zawiera wartość większą od 0 za pomocą nowego operatora większe od ( > ).

Po instrukcji if możemy napisać kolejny człon instrukcji if, poprzedzając go słowem kluczowym else. Jeżeli pierwszy warunek nie będzie spełniony, to sprawdzony zostanie kolejny warunek itd.:

public class ProstaInstrukcjaIf {
  public static void main(String[] args) {
    int x = 5;

    if (x > 0) {
      System.out.println("x jest wieksze od 0.");
    } else if (x < 0) {
      System.out.println("x jest mniejsze od 0.");
    }
  }
}

Zmodyfikowaliśmy przykład – dodaliśmy do niego kolejny warunek, poprzedzony słowem kluczowym else. Jeżeli warunek x > 0 okazałby się fałszem, to sprawdzony zostałby warunek x < 0.

Na końcu instrukcji warunkowej możemy umieścić sekcję else, która zostanie wykonana, gdy żaden z warunków nie zostanie spełniony:

public class ProstaInstrukcjaIf {
  public static void main(String[] args) {
    int x = 5;

    if (x > 0) {
      System.out.println("x jest wieksze od 0.");
    } else if (x < 0) {
      System.out.println("x jest mniejsze od 0.");
    } else {
      System.out.println("x jest rowne 0.");
    }
  }
}

W finalnej wersji przykładowego programu dodaliśmy do instrukcji warunkowej sekcję else, która nie ma żadnego warunku – instrukcje w niej zawarte zostaną wykonane, gdy żaden z poprzednich warunków nie będzie spełniony.

Liczba warunków w instrukcjach warunkowych jest nieograniczona. Dodatkowo, instrukcja warunkowa nie musi zawierać ani sekcji else if, ani else, ale jeżeli zawiera sekcję else, to musi ona być na końcu. Warunki sprawdzane są zawsze w kolejności od pierwszego do ostatniego.

Instrukcje w instrukcjach warunkowych¶

Liczba instrukcji wykonywanych w ramach danej sekcji warunkowej jest nieograniczona – nie musi to być tylko jedna instrukcja:

import java.util.Scanner;

public class DzieleniePrzezZero {
  public static void main(String[] args) {
    double licznik, mianownik;

    // uzycie metody getInt omowionej w poprzednim rozdziale
    System.out.println("Podaj licznik:");
    licznik = getInt();

    System.out.println("Podaj mianownik:");
    mianownik = getInt();

    if (mianownik != 0) {
      double wynik = licznik / mianownik;
      System.out.println("Wynik dzielenia: " + wynik);
    } else {
      System.out.println("Mianownik nie moze byc = 0!");
    }
  }
  public static int getInt() {
      return new Scanner(System.in).nextInt();
  }
}

W tym przykładzie korzystamy z funkcjonalności do pobierania liczb od użytkownika, poznanej pod koniec rozdziału o zmiennych. Pierwsza sekcja instrukcja warunkowej ma przypisane dwie instrukcje do wykonania – definicję zmiennej wynik wraz z jej inicjalizacją oraz wypisanie jej wartości na ekran.

W opisie składni instrukcji warunkowych zobaczyliśmy, że instrukcje do wykonania w ramach danej sekcji warunkowej muszą być otoczone nawiasami klamrowymi.

Jeżeli jednak do sekcji warunkowej przypisana jest tylko jedna instrukcja, to nie musimy otaczać jej nawiasami klamrowymi – poniższy przykład jest poprawny:

public class ProstaInstrukcjaIf {
  public static void main(String[] args) {
    int x = 5;

    if (x > 0)
      System.out.println("x jest wieksze od 0.");
    else if (x < 0)
      System.out.println("x jest mniejsze od 0.");
    else
      System.out.println("x jest rowne 0.");
  }
}

W tym przykładzie, instrukcje podlegające pod kolejne sekcje instrukcji if nie są otoczone nawiasami klamrowymi.

Możemy stosować wiele instrukcji warunkowych w naszym kodzie – każdy zestaw powiązanych ze sobą instrukcji warunkowych będzie sprawdzany osobno:

public class KilkaInstrukcjiWarunkowych {
  public static void main(String[] args) {
    int temperatura = 25;
    int dzienTygodnia = 6;

    if (temperatura >= 20) {
      System.out.println("Cieplo!");
    } else {
      System.out.println("Zimno.");
    }

    if (dzienTygodnia >= 6) {
      System.out.println("Weekend!");
    }
  }
}

W tym przykładzie mamy dwie niezależne instrukcje warunkowe – pierwsza sprawdza wartość zmiennej temperatura, a druga – wartość zmiennej dzienTygodnia. Uruchomienie tego programu spowoduje wypisanie na ekran:

Formatowanie instrukcji warunkowych¶

Instrukcje warunkowe do tej pory zapisywaliśmy w następujący sposób:

if (x > 0) {
  System.out.println("x jest wieksze od 0.");
} else if (x < 0) {
  System.out.println("x jest mniejsze od 0.");
} else {
  System.out.println("x jest rowne 0.");
}

Formatowanie, jakie użyliśmy:

• klamra otwierająca instrukcje danej sekcji jest w tej samej linii, co warunek:

  if (x > 0) {
  

• klamry zamykające instrukcje warunkowe są w osobnych liniach,
• jeżeli mam kolejne sekcje warunkowe else if bądź sekcję else, to umieszczamy słowa kluczowe po klamrach zamykających poprzednie sekcje:

  } else if (x < 0) {
  
  } else {
  

• po nawiasie zamykającym warunek, a przed klamrą otwierającą sekcję instrukcji do wykonania, znajduje się jedna spacja:

  (x > 0) {
  

• instrukcje do wykonania w ramach danej sekcji mają pojedyncze wcięcia (złożone z dwóch spacji):

  if (x > 0) {
    System.out.println("x jest wieksze od 0.");
  } else if (x < 0) {
  

Formatowanie instrukcji warunkowych w taki sposób nie jest wymogiem, ale ogólnie przyjętą konwencją. Moglibyśmy zapisać powyższy kod w następujący sposób i nadal byłoby on poprawny:

if (x > 0){
  System.out.println("x jest wieksze od 0."); }
else if (x < 0)
{
System.out.println("x jest mniejsze od 0.");
}
else { System.out.println("x jest rowne 0."); }

W ramach spójności i czytelności kodu warto jednak stosować się do ogólnie przyjętego sposobu zapisywania instrukcji warunkowych.