javamPokaze || Instrukcje sterujące Javy || Jak kręcić się w kółko i nie zwariować?

Poruszone zagadnienia

• Instrukcje sterujące

• Instrukcja warunkowa if/else

• Pętle
• for
• foreach
• while
• do-while

• Instrukcja switch

• Instrukcje break/continue

Czym w ogóle są instrukcje sterujące?

If/else

if (warunek) {
    // Blok kodu do wykonania, jeśli warunek jest spełniony
}

if (warunek) {
    // Blok kodu do wykonania, jeśli warunek jest spełniony
} 
else {
    // Blok kodu do wykonania, jeśli warunek nie jest spełniony
}

if (warunek1) {
    // Blok kodu do wykonania, jeśli warunek1 jest spełniony
} 
else if (warunek2) {
    // Blok kodu do wykonania, jeśli warunek1 nie jest spełniony, ale warunek2 jest spełniony
} 
else {
    // Blok kodu do wykonania, jeśli żaden z warunków nie jest spełniony
}

if (warunek1) {
// Blok kodu do wykonania, jeśli warunek1 jest spełniony
	if (warunek2) {
	// Blok kodu do wykonania, jeśli warunek2 jest spełniony
	}
} 
else {
// Blok kodu do wykonania, jeśli warunek1 nie jest spełniony
}

int liczba = 10;

	if (liczba > 5) {
      System.out.println("Liczba jest większa od 5");
  } 
	else {
      System.out.println("Liczba nie jest większa od 5");
  }

/*
W tym przykładzie, jeśli wartość zmiennej "liczba" jest większa od 5, 
zostanie wyświetlony komunikat "Liczba jest większa od 5". W przeciwnym razie, 
zostanie wyświetlony komunikat "Liczba nie jest większa od 5".
*/

int liczba = 10;

if (liczba < 0) {
    System.out.println("Liczba jest ujemna");
} 
else if (liczba == 0) {
    System.out.println("Liczba wynosi zero");
} 
else if (liczba < 10) {
    System.out.println("Liczba jest mniejsza od 10");
} 
else {
    System.out.println("Liczba jest większa lub równa 10");
}

/*
Jeśli wartość zmiennej "liczba" jest ujemna, zostanie wyświetlony komunikat 
"Liczba jest ujemna". Jeśli wartość zmiennej "liczba" wynosi zero, zostanie 
wyświetlony komunikat "Liczba wynosi zero". Jeśli wartość zmiennej "liczba" 
jest mniejsza od 10, zostanie wyświetlony komunikat "Liczba jest mniejsza od 10". 
Jeśli żaden z powyższych warunków nie jest spełniony, zostanie 
wyświetlony komunikat "Liczba jest większa lub równa 10".

Drabinka if else if umożliwia sekwencyjne sprawdzanie warunków, aż do znalezienia 
pierwszego, który jest spełniony (ma wartość true). 
*/

Pętle

1. Inicjalizacja
Przypisanie wartości do zmiennej, która będzie swego rodzaju licznikiem wykonania operacji w pętli (tzw. zmiennej sterującej)
 

2. Iterowanie / Iteracja
• Iterowanie - przechodzenie po kolejnych elementach każdej pętli (eksploracja pętli)
• Iteracja - to kolejne przejście całej pętli
 

3. Inkrementacja / Dekrementacja
• Inkrementacja - operacja zwiększania wartości zmiennej o 1, używana często w pętlach do kontrolowania liczby iteracji
• Dekrementacja - operacja zmniejszania wartości zmiennej o 1, również wykorzystywana w pętlach do podobnych celów
 

Pętla for

for (inicjalizacja; warunek; iteracja){ //zwróć uwagę na znak ";" pomiędzy nimi
			intrukcja; 
}

//Przykład

for (int i = 0; i < 10; i++) {
    // Wypisz na ekranie wartość zmiannej "i" 
			System.out.println(i);
}

/*
1. Inicjalizacja:
	Na początku deklarujemy zmienną i przypisujemy jej wartość początkową równą 0.
	Ta zmienna będzie używana jako licznik pętli. Możemy jej oczywiście ustawić dowolną
	wartość.

2. Warunek
 Sprawdzamy czy i < 10 
- Jeśli ten warunek jest prawdziwy, pętla zostanie wykonana
- Jeśli warunek jest fałszywy, pętla zostanie zakończona

W tym przypadku warunek jest prawdziwy (true), więc po wykonaniu jednego przebiegu pętli
(czyli po wypisaniu na ekranie wartości "i") następuje iteracja

3. Iteracja
	Wyrażenie i++ zwiększa wartość "i" o 1
	Oznacza to, że przy każdym przejściu przez pętlę wartość "i" będzie się inkrementować
	na końcu

Należy pamietać, że operacje na zmiennej "i" zaczynają się wykonywanać od wartości 
równiej 0, ponieważ zmienna sterujaca i = 0. 
-----------------------------------------------------------------
Output:
0
1
2
3
4
5
6
7
8
9
-----------------------------------------------------------------
Każda wartość zmiennej "i" od 0 do 9 zostanie wyświetlona w oddzielnej linii. 
To jest wynik iteracji pętli, w której wartość zmiennej "i" zaczyna się od 0, 
zwiększa się o 1 przy każdym przebiegu i kończy na 9.

Zagnieżdżona pętla for

for (inicjalizacjaPierwszejZmiennej; warunek; inkrementacja) {

	    instrukcja; // Kod wykonujący się w zewnętrznej pętli

    for (inicjalizacjaDrugiejZmiennej; warunek; inkrementacja) {

					instrukcja;  // Kod wykonujący się w wewnętrznej pętli
    }
}

//Przykład

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 2; j++) {
        System.out.println("i: " + i + ", j: " + j);
    }
}
/* 
Pętla zewnętrzna:
Zaczynamy od przypisania wartości zmiennej "i". Jeśli jej wartość spełnia warunek i < 3,
wtedy wchodzimy w wewnętrzną pętle zagnieżdżoną ze zmienną "j". 

Pętla wewnętrzna:
Będziemy wykonywać tutaj instukcję tak długo, aż zmienna "j" osiągnie wartość 2 po 
wszystkich iteracjach (pętla się nie wykona dla j = 2, bo jej warunek to j < 2).
Po wykonaniu wszystkich iteracji opuszczamy pętle wewnętrzną, wracając tym samym do pętli
zewnętrznej. Z uwagi na fakt, że wykonany został cały blok kodu w tej pętli 
(czyli wszystkie operacje z pętli zagnieżdżonej ze zmienną "j") to w tym momencie iterujemy
zmienną sterującą "i" zwiększając jej wartość o 1. W tym momencie działanie pętli 
zewnętrzej zaczyna się na nowo. Sprawdzany jest warunek i < 3. Jeśli tak, wchodzimy w 
pętle wewnętrzną itd. 

Podsumowując, w pętli zewnętrznej dla każdej wartości zmiennej "i" od 0 do 3, 
pętla wewnętrzna zostanie wykonana dwa razy (bo jej warunkiem jest j < 2). 
W wyniku tego, na ekranie zostaną wyświetlone komunikaty.

Output:
-----------------------------------------------------------------
i: 0, j: 0
i: 0, j: 1
i: 1, j: 0
i: 1, j: 1
i: 2, j: 0
i: 2, j: 1
-----------------------------------------------------------------
*/

Pętla foreach

for (typElementu element : lista) {
    // Wykonaj operacje na element
}

/*
Kod przedstawia pętlę, która służy do wykonania tej samej operacji na każdym elemencie
listy (np. talicy). Każdy element jest tymczasowo przechowywany w zmiennej o nazwie 
"element", a następnie na nim są wykonywane określone operacje. Pętla ta umożliwia 
przetwarzanie wielu elementów listy w sposób automatyczny.
*/

//Przykład

ArrayList <String> lista = new ArrayList<>();
lista.add("Janek");
lista.add("Ania");
lista.add("Zosia");

        for (String element : lista) {
            System.out.println(element);
        }

/*
W tym przykładzie tworzymy ArrayList o nazwie lista i dodajemy trzy elementy 
typu String. Następnie używamy pętli foreach, aby przejść przez każdy element z tej 
listy i wyświetlić go na w konsoli (w tym wypadku imiona)

Output:
-----------------------------------------------------------------
Janek
Ania
Zosia
-----------------------------------------------------------------
*/

Pętla while

while(warunek){
	instrukcja;
}

//Przykład 

int i = 0;
while (i < 10) {
    // Wykonuj kod, dopóki "i" jest mniejsze od 10
    i++;     //zwiększ wartość "i" o 1 
}

/*
Ważną informacją jest to, że zmienną sterującą należy zdefiniować poza ciałem pętli. 
W naszym przypadku mamy zmienną typu int z przypisaną wartością 0. Po wykonaniu pętli, 
zmianna ta zostaje zinkrementowana (i++), a pętla wykona się ponownie, aż do momentu 
gdy zmienna int osiągnie wartość 10. Wtedy instrukcja nie wykona się ponownie, gdyż
"i" nie będzie mniejsze od 10 (false). W tym momencie opuszczamy pętlę. 

Jeśli nie mielibyśmy tutaj inkrementacji i++, to pętla wykonywałaby się w nieskończoność,
ponieważ warunek po każdorazowym wykonaniu pętli przyjmowałby wartość "true". 
(bez iteracji wartość zmiennej int zawsze byłaby mniejsza od 10)

Pętla do-while

do{
	instrukcja;
}
while(warunek);
	
// Przykład

int x = 1;
  do {
      System.out.println("Wartość x: " + i);
      i++;
  } 
	while (x <= 5);
  
/*
W tym przykładzie zaczynamy od utworzania zmiennej x i przypisania jej wartości 1.
Następnie pętla do-while, wykona blok kodu przynajmniej raz [wyświetli wartość zmiennej 
"i" w konsoli i wykona inkrementację (i++)], a następnie sprawdzi warunek. Jeśli warunek 
jest spełniony (w tym przypadku i <=5) to pętla zostanie wykonana ponownie.

Output:
-----------------------------------------------------------------
Wartość x: 1
Wartość x: 2
Wartość x: 3
Wartość x: 4
Wartość x: 5
-----------------------------------------------------------------

Instrukcja sterujaca switch

switch(wyrażenie){
	case wartość1:
		instrukcja;
		break;
	case wartość2:
		instrukcja;
		break;
	case wartość3:
		instrukcja;
		break;
	*
	*
	default:
		instrukcja;
}

// Przykład

int opcja = 2;

switch (opcja) {
    case 1:
        System.out.println("Wybrano opcję 1");
        break;
    case 2:
        System.out.println("Wybrano opcję 2");
        break;
    case 3:
        System.out.println("Wybrano opcję 3");
        break;
    default:
        System.out.println("Nie wybrano żadnej opcji");
}
/*
W tym przykładzie zmienna int "opcja" jest porównywana z kolejnymi przypadkami. Jeśli 
"opcja" ma wartość równą danej liczbie to wyświeli się komunikat, a my opuścimy pętlę. 

Gdy opcja = 1  -->  wyświetli się komunikat "Wybrano opcję 1"
Gdy opcja = 2  -->  wyświetli się komunikat "Wybrano opcję 2"
Gdy opcja = 3  -->  wyświetli się komunikat "Wybrano opcję 3"
Jeśli żadna opcja nie pasuje, wyświetli się komunikat "Nie wybrano żadnej opcji"

Ważnym elementem jest tutaj "break". Oznacza, że całkowicie opuszczamy pętle 
po wykonaniu danej instrukcji. Omówimy to w nastepnym akapicie.  

Oczywiście, jako opcję do sprawdzenia możemy użyć również zmiennej String oraz Obiektów:

Output:
-----------------------------------------------------------------
Wartość x: 1
Wartość x: 2
Wartość x: 3
Wartość x: 4
Wartość x: 5
-----------------------------------------------------------------
*/

Instrukcje break/continue

• Instrukcja break jest używana do przerywania wykonywania pętli lub instrukcji warunkowej. Gdy break jest zastosowane, natychmiast opuszczamy najbliższą pętlę lub blok switch, w którym break zostało użyte.

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break; // Przerywamy pętlę, gdy i = 5
    }
    System.out.println(i);
}

Output:
-----------------------------------------------------------------
Wartość x: 1
Wartość x: 2
Wartość x: 3
Wartość x: 4
Wartość x: 5
-----------------------------------------------------------------
*/

• Instrukcja continue
Używana do pominięcia aktualnej iteracji pętli i kontynuowania z kolejną iteracją. Instrukcja continue w Javie pozwala programowi pominąć resztę kodu w bieżącej iteracji pętli i przejść bezpośrednio do kolejnej iteracji. Jest używana, gdy chcemy zignorować pewne warunki i kontynuować wykonywanie pętli.

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) { // 
        continue; // Pomiń iterację, gdy "i" jest parzyste
    }
    System.out.println(i);
}

Output:
-----------------------------------------------------------------
1
3
5
7
9
-----------------------------------------------------------------
*/

// jeśli nie rozumiesz warunku i % 2 == 0, rzuć okiem na ten link: 
https://www.youtube.com/watch?v=ZnjSf4zhh28

Śledź mnie na LinkedIn

Newsletter