Java:Coś działającego

Ok, wiem, jesteś pierdołą i nic nie zrozumiałeś z poprzednich kursów. Albo nie wiesz, że rozumiesz. To wróć i przeczytaj je jeszcze raz, po jednym zdaniu - bo po to są napisane, abyś je cholero czytał. I nie zadawał pytań, jak coś jest wytłumaczone, tylko nie od razu łapiesz.

Już sobie ulżyłem, więc teraz zajmiemy się czymś dla prawdziwych mężczyzn - sterowaniem programem. Czyli magiczne sztuczki, żeby program coś robił lub nie robił i to ustaloną ilość razy.

## Warunki

Wytłumaczę to na przykładzie.

Pewnie zdarzyło ci się kiedykolwiek, że miałeś potrzebę pójścia do toalety. Ot tak, normalna reakcja. Jednak czujesz, że mocz naciska na ściany twojego pęcherza już od zbyt długiego czasu i ten niczym zbyt długo oblężana twierdza w końcu się podda. Idziesz do toalety.

Jednak - tutaj zaskoczenie - toaleta jest zajęta. Więc nie możesz z niej skorzystać.

W tym przypadku to to, czy ktoś jest w środku czy nie, jest naszym **warunkiem**. Od tego warunku zależą dalsze działania. Zauważ, że gdy toaleta byłaby wolna, bez problemu byś z niej skorzystał.

W informatyce takim warunkiem jest wartość zdania logicznego. Nie wyobrażaj sobie po ostatnim określeniu jakichś wielkich rzeczy, bo to było na matmie. Jak zapomniałeś, toś pierdoła. Ja to tylko szybko nakreślę.

Wynikiem zdania logicznego mogą być dwie wartości - **prawda** lub **fałsz** (true lub false). Np. zdanie logiczne "dwa większe od jednego" daje nam wartość "prawda", bo, jak pewnie bystrze spostrzegłeś, to są fakty. Jednak jeśli powiem "dwa mniejsze od jednego" to skłamię, czyli zdanie to ma wartość "fałsz". No i w sumie na takiej zasadzie działa każdy warunek.

### Operatory warunkowe

Ten tytuł oznacza mniej więcej tyle, że dowiesz się za chwilę, jak formułować zdania logiczne w Javie.

Otóż użyjesz do tego operatorów

```
> - większy od
< - mniejszy od
>= - większy lub równy
<= - mniejszy lub równy
== - równy
!= - nierówny

```

Wszystko wydaje się proste i zrozumiałe oprócz dwóch ostatnich znaków.

Java nie zawsze chce cię zniszczyć. Czasem potrzebuje twojego zaufania, abyś nie wiedział, że ona cię niszczy. Dlatego tym razem, z bardzo praktycznych powodów, do wykorzystania masz takie znaki jak "==" i "!=". Podwójny znak równości jest tutaj dlatego, że pojedynczy znak równości zawsze zmienia wartość zmiennej. Dlatego teraz, abyś cholero nie zepsuł programu, używasz podwójnego znaku równości. Dzięki temu przez przypadek nie zmienisz wartości. Znak nierówności natomiast musisz po prostu wkuć (jak pewnie wkuwasz całą resztę kursu).

Jednak Java jest tak przydatna jak matma w szkołach i pozwala na trzy dodatkowe tricki:

```
! - negacja (nie)
&& - koniunkcja (i)

```

Dzięki temu możemy na przykład uzyskać takie rzeczy:

```
3 > 2   // prawda (true)
2 >= 3    // fałsz (false)
!(2 >= 3)    // prawda (true)
3 > 2 && 2 > 3    // fałśz (false) ponieważ true && false

```

No ale ty już to powinieneś wywnioskować i wiedzieć, a nie będę ci matematyczne równania logiczne rozpisywał!

Dodatkowo, jak w każdym języku programowania, można zamiast liczb podstawić zmienne. Dzięki temu nie wiesz przed startem programu, jaki będzie wynik równania logicznego. Np. w przypadku, gdy użytkownik wpisze "1" powinno się stać coś innego niż jak wpisze "2". Gdybyś z góry wiedział podczas pisania programu, co wpisze użytkownik, to trochę mijałoby się z celem pisanie tych cholernych warunków, które tylko wprowadzają ci zamęt w mózgu.

### Instrukcja if

A więc w końcu, młody Zakonniku Klawiatury, doszło do tego, że muszę ci pokazać tajniki sterowania programem.

A więc wyobraźmy sobie program, który pobiera liczbę od użytkownika. Gdy użytkownik jakimś sposobem domyśli się, że pobiera się liczbę i że jedyną słuszną liczbą jest 42, to wyświetlmy mu radosny komunikat o tym.

```
public class Program {
  public static void main(String args[]) {
    Scanner scanner = new Scanner(System.in);
    int liczba = scanner.nextInt();
    System.out.println("Wpisałeś jedyną słuszną liczbę!");
  }
}

```

Prześledźmy działanie programu. Program pobiera liczbę od użytkownika i wyświetla tekst. Za każdym razem. Czyli oczywiście nie robi tego, co miał robić.

Z pomocą przyjdzie nam instrukcja if! **If** to magiczne hasło, które pozwala nam uruchomić jakieś polecenia (instrukcje), gdy wyrażenie jest prawdziwe. Na przykład gdy liczba będzie wynosiła 42, to wyświetlimy tekst.

If używa się zawsze z nawiastem, w którym jest warunek. Poza tym możesz wstawić do nawiasu dowolną liczbę nawiasów, tylko wszystkie muszą być zamknięte. Za nawiasem powinna być klamra, ponieważ w klamrze będą instrukcje, które program wykona tylko w przypadku, gdy warunek jest prawdziwy. Dlatego klamra służy do odróżnienia ifa od reszty programu, który działa niezależnie od warunków.

```
public class Program {
  public static void main(String args[]) {
    Scanner scanner = new Scanner(System.in);
    int liczba = scanner.nextInt();
    if(liczba == 42) {
      System.out.println("Wpisałeś jedyną słuszną liczbę!");
    }
  }
}

```

Przyjrzyj się dokładnie temu programowi (bo jesteś zbyt leniwy, aby to normalnie zrobić). Widzisz ifa? Specjalnie dla ciebie napisałem dwa programy, abyś mógł porównać. Ale nie dziękuj, nie jesteś specjalny.

Popatrz, co się teraz dzieje. Program pobiera od użytkownika liczbę, zapisuje ją w "liczba". Od razu potem mamy warunek - liczba równa się 42. Od tego momentu mamy dwie możliwości - to prawda lub nieprawda. W pierwszym przypadku program wykona instrukcje w klamrach (wyświetli tekst). W drugim przypadku po prostu zignoruje klamry i, akurat w naszym programie, popełni seppuku, czyli zakończy działanie (bo pod klamrą nic nie ma).

### If-else

Dobra, a co jeśli chcemy wytknąć użytkownikowi używanie niesłusznych liter?

Ulepszmy nasz program:

```
public class Program {
  public static void main(String args[]) {
    Scanner scanner = new Scanner(System.in);
    int liczba = scanner.nextInt();

    if(liczba == 42) {
      System.out.println("Wpisałeś jedyną słuszną liczbę!");
    }

    System.out.println("Używasz niesłusznych liczb");
  }
}

```

I... spieprzyliśmy. Co prawda w przypadku innej liczby niż 42 program zignoruje klamry i wyświetli tylko to, co jest poza nimi ("Używasz niesłusznych liczb"), ale w przypadku 42 zdarzy się coś nieoczekiwanego. Program zgodnie z przyjętym warunkiem wyświetli nam "Wpisałeś jedyną słuszną liczbę!", po czym z powodu braku innych rzeczy do roboty w klamrze dokończy dzieła - wyświetli nam też "Używasz niesłusznych liczb".

Trochę mija się z celem podawanie sprzecznych informacji - to w końcu używamy słusznej liczby czy nie?

Przyjrzyj się programowi. Instrukcja if pozwala nam wykonać pewne rzeczy warunkowo, czyli pod warunkiem (że liczba jest równa 42). Niestety if nie kończy nam programu - jest tylko jego częścią. Jego klamry więc są tylko "efektem ubocznym" warunku, a nie jedyną możliwością programu. Zapamiętaj - ify nie dają ultimatum.

Z powyższego powodu program posłusznie wykonuje ostatnią instrukcję w programie - informuje o niesłuszności wprowadzonej liczby.

Tym razem uratuje nas odmiana pętli if, jaką jest if-else.

**If-else** składa się z dwóch (i tylko dwóch) części - zwykłego if i, za jego klamrą, słowa else i kolejnej klamry. To, co znajduje się w klamrze "elsa", to rzeczy, które wykonamy w każdym innym przypadku - czyli wtedy, kiedy pierwszy warunek jest fałszem.

```
public class Program {
  public static void main(String args[]) {
    Scanner scanner = new Scanner(System.in);
    int liczba = scanner.nextInt();

    if(liczba == 42) {
      System.out.println("Wpisałeś jedyną słuszną liczbę!");
    } else {
      System.out.println("Używasz niesłusznych liczb");
    }
  }
}

```

Tym razem program sprawdzi, czy liczba równa się 42. Jeśli tak jest, wyświetli pierwszy komunikat. Jeśli jednak tak nie jest, wyświetli drugi komunikat. Zauważ, że za klamrami nic nie ma, dlatego program nie zrobi nic więcej.

### else if

Czasami jeden if nie wystarczy.

Do ifa możemy dodać także alternatywny warunek, czyli np. gdy liczba będzie się równała 666. Do tego służy **else if** i praktycznie używa się go jak zwykłego ifa.

Niżej zamieszczam poprawnie zmodyfikowany już program, bez zbędnego pieprzenia. Spróbuj sam wyczytać, co zrobi w różnych przypadkach.

```
public class Program {
  public static void main(String args[]) {
    Scanner scanner = new Scanner(System.in);
    int liczba = scanner.nextInt();

    if(liczba == 42) {
      System.out.println("Wpisałeś jedyną słuszną liczbę!");
    } else if(liczba == 666) {
      System.out.println("Znasz duże liczby.");
    } else {
      System.out.println("Używasz niesłusznych liczb");
    }

  }
}

```

STOP! Przeczytaj chociaż raz ten program. Co, myślałeś, że mnie oszukasz? Nie ze mną takie numery, leniwy draniu. Ulżysz sobie, jak będziesz się chociaż starał. Nie potrzebujemy więcej bezradnych pierdół zadających bezsensowne pytania, dlatego przyłóż się do Javy.

## Dzień świstaka

A co, jeśli chciałbyś jednak zadawać w kółko te same pytania do kursu Javy, nie próbując zrozumieć odpowiedzi? No cóż, zawsze możesz napisać program.

Jednak pisanie w kółko tego samego mija się z celem i takie kopiuj-wklej jest czasochłonne.

Java posiada bardzo przydatną rzecz, która zastąpi ci pisanie w kółko - mianowicie są to **pętle**. Pętla wykonuje blok instrukcji (klamry) tak długo, jak jej warunek jest prawdą.

To tak, jakbyś miał trzylatka, który będzie zadawał to samo pytanie losową ilość razy. Jak dostrzeżesz pewną analogię, to zrozumiesz, czemu taki trzylatek w ogóle się nie męczy zadając pytania - używa rozbudowanych pętli. Weź przykład z niego i spróbuj zrozumieć to, co jest poniżej.

### Pętla while

Podstawowa pętla. Sprawdza warunek i jeśli jest prawdziwy, wykonuje kod w klamrach. Po wykonaniu kodu w klamrach sprawdza warunek i jeśli jest prawdziwy, wykonuje kod w klamrach. Jak wykona kod w klamrach, sprawdza warunek. Jeśli jest prawdziwy, wykonuje kod w klamrach. Jeśli już skończy wykonywać kod w klamrach, sprawdzi warunek i w przypadku, gdy jest prawdą (true), wykona kod w klamrach. Po wykonaniu kodu w klamrach sprawdzi warunek. Jeśli jest prawdziwy, wykona kod w klamrach. Potem, po wykonaniu kodu z klamer, sprawdzi warunek. Jeśli okaże się być prawdziwy, wykona zadania z klamer. Po skończeniu tego, co miał do roboty w klamrach, sprawdzi jeszcze raz warunek i gdy jego wartość logiczna to prawda, zajmie się wnętrzem klamer. Po skończeniu roboty w klamrach, jedyne co mu pozostanie do roboty to jeszcze raz sprawdzić warunek przed klamrami. Gdy warunek jest prawdziwy, wykona instrukcje w klamrach, po czym sprawdzi warunek. Jeśli za jakimś razem warunek okaże się fałszem (false), to pominie klamrę i przejdzie do reszty programu.

Myślę, że mniej więcej zrozumiałeś, o co chodzi w pętli while. Jej budowa składa się z magicznego słowa while, nawiasu z warunkiem (jak w if) i klamer z instrukcjami. W klamrach powinniśmy zmieniać wartość zmiennej z warunku, ponieważ gdy za każdym razem warunek będzie prawdą, to skończymy z pętlą nieskończoną. A pętla nieskończona będzie dosłownie nieskończona, a więc będzie działała tak długo aż zatnie komputer, a nie będzie można jej przerwać.

Przykładowy program może np. dodawać 1 do zmiennej aż ta dojdzie do 69.

```
int liczba = 0;
while(liczba < 69) {
  liczba = liczba + 1;
}

```

Po skończeniu wykonywania pętli, liczba będzie się równała 69. Dlaczego? Bo będziemy dodawać 1 do skutku, czyli aż liczba nie będzie mniejsza od 69 (aż zdanie "liczba jest mniejsza od 69" będzie fałszywe).

Oprócz tego w pętli można też robić inne rzeczy, jak wyświetlać tekst. Poniższy program pobiera od użytkownika liczbę. Tyle razy zostanie wyświetlony tekst w pętli.

```
public class Program {
  public static void main(String args[]) {
    Scanner scanner = new Scanner();
    int liczba = scanner.nextInt();
    int indeks = 0;
    while(indeks < liczba) {
      System.out.println("W końcu musiało do tego dojść");
      indeks = indeks + 1;
    }
  }
}

```

Zauważ, że porównujemy indeks do liczby (czy jest nadal mniejszy) i wyświetlamy tekst, po czym dodajemy 1 do indeksu. A potem znowu sprawdzamy, czy indeks jest nadal mniejszy od liczby itd.

### for

Jak pewnie zauważyłeś, musieliśmy stworzyć oddzielną zmienną "indeks" dla tej pętli, a także w klamrach dodawać 1 do niej na końcu. Jednak Java pozwala ci na zrobienie to w trochę prostszy i bardziej ogarnięty sposób.

Jest to pętla for. Uważaj teraz, bo pętla for składa się z "for", nawiasu i klamer, ale w nawiasie potrzeba napisać trzy rzeczy.

```
for(int i = 0; i < 69; i++)

```

Pierwsza część to "int i = 0". Jest to nic innego jak utworzenie naszego indeksu. 0 jest liczbą startową, a więc indeks zaczyna się od zera i od zera zaczniemy.

Druga część, po średniku, to jest warunek. Czyli w praktyce to, co było w nawiasie w przypadku "while".

W trzeciej części piszemy instrukcję zmieniającą warunek. To znaczy zmianę indeksu. To znaczy, że masz pierdoło po średniku napisać coś, aby nie wyszła ci pętla nieskończona. Np. "i++", aby dodać jeden i żebyś w końcu doszedł do 69.

Niżej zapisuję ten sam program co wyżej, ale z użyciem pętli for:

```
public class Program {
  public static void main(String args[]) {
    Scanner scanner = new Scanner();
    int liczba = scanner.nextInt();
    for(int i = 0; i < liczba; i++) {
      System.out.println("W końcu musiało do tego dojść");
    }
  }
}

```

Pętla startuje z i = 0 i po każdym wyświetleniu napisu (czyli dojścia do zamknięcia klamer) dodaje 1 do i ("i++"). Warunkiem wykonywania pętli jest "i mniejsze od liczby".

Przeczytaj jeszcze raz na spokojnie i spojrzyj na te różnice pomiędzy powyższym programem. Tak naprawdę działają tak samo. Właśnie to porównanie najlepiej pozwoli ci zrozumieć pętlę "for". A jeżeli nie zrozumiałeś też pętli "while", to już nic ci nie pomoże.