Instrukcje warunkowe byłyby bardziej przydatne, gdybyśmy mogli zapisywać bardziej złożone warunki – możemy to osiągnąć dzięki operatorom warunkowym && oraz ||. Do dyspozycji mamy także operator logiczny !, który zmienia wartość wyrażenia na przeciwne:

• || (or) – logiczne "lub" – zwraca prawdę (true), jeżeli chociaż jeden z jego argumentów jest prawdą, a w przeciwnym razie fałsz (false).
• && (and) – logiczne "i" – zwraca prawdę (true), jeżeli każdy z jego argumentów jest prawdą, a w przeciwnym razie fałsz (false).
• ! (not) – zwraca zaprzeczenie wartości: jeżeli jest nieprawdziwa (false), zwraca prawdę, a gdy jest prawdziwa (true), zwraca fałsz.

Aby zapisać bardziej skomplikowany warunek w instrukcji if, łączymy ze sobą kolejne warunki przy użyciu operatora && bądź ||. Warunki mogą być dowolnie złożone i używać każdego z operatorów dowolną liczbę razy.

Spójrzmy na poniższy przykład – pobieramy od użytkownika dwa boki prostokąta i liczymy jego pole, ale tylko w przypadku, gdy obie podane liczby są poprawnymi bokami prostokąta:

import java.util.Scanner;

public class PoleProstokata {
  public static void main(String[] args) {
    int a, b;

    System.out.println("Podaj pierwszy bok prostokata:");
    a = getInt();
    System.out.println("Podaj drugi bok prostokata:");
    b = getInt();

    // uzywamy operatora && - warunek bedzie spelniony,
    // gdy zarowno zmienna a, jak i b, beda wieksze od 0
    if (a > 0 && b > 0) {
      System.out.println("Pole wynosi " + a * b);
    } else {
      System.out.println("Nieprawidlowe dane.");
    }
  }

  public static int getInt() {
    return new Scanner(System.in).nextInt();
  }
}

Instrukcja warunkowa posiada złożony warunek – sprawdzamy zarówno wartość zmiennej a, jak i b. Warunki są ze sobą złączone za pomocą operatora logicznego && (and), więc całe wyrażenie będzie miało wartość true tylko w przypadku, gdy zarówno warunek a > 0, jak i b > 0, będą spełnione.

Spójrzmy na dwa przykładowe uruchomienia powyższego programu:

Obie liczby są poprawnymi bokami prostokąta, więc na ekranie zobaczyliśmy policzone pole.

Drugim razem użytkownik podał nieprawidłową wartość dla pierwszego boku – w tym przypadku, na ekranie zobaczyliśmy inny komunikat:

Operator logiczny !¶

Operator logiczny ! to jednoargumentowy operator, logiczne zaprzeczenie (not), który oczekuje jako argumentu wartość true bądź false, i zwraca wartość przeciwną, tzn. dla argumentu true zwraca wartość false, a dla false – zwraca true.

Spójrzmy na przykład:

public class OperatorNot {
  public static void main(String[] args) {
    boolean czyPadaDeszcz = true;

    if (!czyPadaDeszcz) {
      System.out.println("Sloneczna pogoda.");
    } else {
      System.out.println("Zostaje w domu!");
    }
  }
}

W tym przykładzie, w warunku instrukcji if, sprawdzamy, czy nie jest prawdą, że pada deszcz, tzn. czy zmienna czyPadaDeszcz jest fałszem? Jeżeli tak, to całe wyrażenie będzie miało wartość true (zaprzeczeniem false jest true) i zobaczymy na ekranie komunikat "Sloneczna pogoda".

Po uruchomieniu programu, na ekranie widzimy jednak:

Ponieważ zmienna czyPadaDeszcz ma wartość true. Zaprzeczeniem tej wartości jest false – warunek if nie jest spełniony (to znaczy nie ma wartości true) i przechodzimy do sekcji else.

Operatora logicznego ! możemy używać także do zaprzeczania bardziej skomplikowanych wyrażeń:

public class OperatorNotZaprzeczenieWyrazeniu {
  public static void main(String[] args) {
    int a, b;

    a = 5;
    b = -10;

    if (!(a > 0 && b > 0)) {
      System.out.println("Niepoprawne dane.");
    } else {
      System.out.println("Pola prostokata = " + a * b);
    }
  }
}

W tym przykładzie zaprzeczyliśmy złożonemu wyrażeniu sprawdzającemu, czy boki prostokąta są poprawne. Jeżeli któryś z boków będzie mniejszy bądź równy 0, czyli warunek:

a > 0 && b > 0

nie zostanie spełniony i będzie miał wartość false, to operator ! spowoduje, że wartość całego wyrażenia zostanie odwrócona i będzie miała wartość true – w takim przypadku, na ekran zostanie wypisany komunikat "Niepoprawne dane." – taki właśnie komunikat zobaczymy, gdy uruchomimy powyższy program:

Dodatkowo, operatora logicznego ! możemy także użyć, by zamienić wartość zmiennej typu boolean na przeciwną wartość:

public class OperatorNotZaprzeczenieBoolean {
  public static void main(String[] args) {
    boolean czyPadaDeszcz = false;

    czyPadaDeszcz = !czyPadaDeszcz;

    System.out.println("Czy pada? " + czyPadaDeszcz);
  }
}

W podświetlonej linii przypisaliśmy do zmiennej czyPadaDeszcz wartość przeciwną tej zmiennej – w ten sposób, zmieniliśmy wartość zmiennej czyPadaDeszcz na przeciwną – w wyniku uruchomienia tego programu, na ekranie zobaczymy: