Instrukcje warunkowe w Kotlinie – część 1

W tym ćwiczeniu z programowania w Kotlinie utworzysz kolejną grę w kości – Lucky Dice Roll – w której będziesz próbować wyrzucić szczęśliwą liczbę. Program ustawi szczęśliwą liczbę i rzuci kostką. Następnie sprawdzasz wynik rzutu w porównaniu z szczęśliwym numerem i wyświetlasz odpowiedni komunikat. W tym celu dowiesz się, jak porównywać wartości i podejmować różne decyzje w programie w języku Kotlin.

Aby pomóc Ci skupić się na koncepcjach programowania bez konieczności martwienia się o interfejs aplikacji, będziesz używać narzędzia do programowania w Kotlinie w przeglądarce i wyświetlać wyniki w konsoli.

Wymagania wstępne

• Jak otwierać, edytować i uruchamiać kod na stronie https://try.kotlinlang.org/
• Umiejętność tworzenia i uruchamiania programu w Kotlinie, który używa zmiennych, funkcji z argumentami i klas z metodami oraz wyświetla wynik w konsoli.

Czego się nauczysz

• Jak korzystać z instrukcji if i else
• Jak porównywać wartości za pomocą operatorów takich jak większe niż (>), mniejsze niż (<) i równe (==).
• Jak używać instrukcji when, aby wybrać opcję na podstawie podanej wartości.
• Czym jest typ danych Boolean i jak wykorzystywać jego wartości true i false do podejmowania decyzji.

Co utworzysz

• Gra w kości Lucky Dice Roll oparta na języku Kotlin, która pozwala określić szczęśliwą liczbę. Gracz wygrywa, jeśli wyrzuci szczęśliwą liczbę.

Wymagania

• komputer z połączeniem internetowym,

Program Lucky Dice Roller musi określić, czy użytkownik wyrzucił szczęśliwą liczbę, i w takim przypadku wyświetlić gratulacje, a w przeciwnym – komunikat z prośbą o ponowne spróbowanie.

Jako deweloper aplikacji musisz podejmować decyzje dotyczące jej działania i tworzyć różne wyniki dla użytkowników.

Jeśli tworzysz aplikację do zakupów, możesz wyświetlać różne ekrany w zależności od wybranych przez użytkownika opcji dostawy. W przypadku quizu wyświetlasz różne ekrany w zależności od tego, czy odpowiedź gracza jest prawidłowa. W zależności od aplikacji może być wiele możliwych wyników, które należy uwzględnić w kodzie.

W programie Lucky Dice Roller aplikacja powinna obsługiwać różne przypadki, takie jak:

• Jeśli wynik rzutu kostką jest szczęśliwą liczbą, wyświetl komunikat z gratulacjami.
• W przeciwnym razie , jeśli wynik rzutu kostką nie jest szczęśliwą liczbą, wyświetl komunikat, aby spróbować ponownie.

Aby dodać tę logikę do kodu, użyj specjalnych słów kluczowych w Kotlinie, takich jak if, else i when.

Przyjrzyjmy się kilku przykładom.

Użyj instrukcji if, aby skonfigurować warunek, który jest spełniony.

1. Sprawdź poniższy kod. Czy potrafisz odgadnąć, jaki będzie wynik?

fun main() {
   val num = 5
   if (num > 4) {
       println("The variable is greater than 4")
   }
}

2. Skopiuj kod i wklej go w edytorze programu w języku Kotlin, a potem uruchom program, aby zobaczyć dane wyjściowe.

The variable is greater than 4

Proces decyzyjny w tym programie wygląda następująco:

1. Utwórz zmienną num i ustaw jej wartość na 5..
2. Jeśli wartość num jest większa (>) niż 4,, wydrukuj "The variable is greater than 4".
3. W innych sytuacjach nie rób nic.

W przykładzie powyżej wartość num wynosi 5. Instrukcja if porównuje, czy zmienna jest większa niż 4. Ponieważ ten warunek jest spełniony, system wykonuje instrukcje w nawiasach klamrowych i drukuje wiadomość.

Podsumowanie: symbol > to operator porównujący dwie wartości, który sprawdza, czy pierwsza wartość jest większa od drugiej, i zwraca wynik true lub false. Inne popularne operatory to: < (mniejsze niż), == (równe), >= (większe lub równe) i <= (mniejsze lub równe).

Zwróć uwagę na ogólny format instrukcji if:

• Zacznij od słowa kluczowego if.
• Dodaj 2 nawiasy (). W nawiasach podaj warunek. Warunek może mieć wartość true lub false. Na przykład czy liczba jest większa od innej liczby.
• Po nim wpisz dwa nawiasy klamrowe {}. W nawiasach klamrowych umieszczasz kod, który ma zostać wykonany, jeśli warunek jest true.

if (condition-is-true) {
    execute-this-code
}

Typ danych logicznych dla wartości prawda i fałsz:

• Sprawdzanie przez program, czy warunek jest spełniony, nazywa się „oceną warunku”. Wynikiem oceny warunku jest true, jeśli jest on spełniony, lub false, jeśli nie jest spełniony. Deweloperzy mówią też „warunek przyjmuje wartość true” lub „warunek przyjmuje wartość false”.
• Warunki mogą przyjmować tylko wartości true lub false.
• Podobnie jak w przypadku typu danych Int dla liczb całkowitych i IntRange dla zakresów, istnieje typ danych dla true i false, który nazywa się Boolean. Zmienne typu Boolean pojawią się w dalszej części tego kursu.

Użyj instrukcji if, aby skonfigurować warunek, który nie jest spełniony.

1. Zmień wartość num na 3, jak pokazano poniżej. Co się stanie, jeśli uruchomisz ten kod?

fun main() {
   val num = 3
   if (num > 4) {
       println("The variable is greater than 4")
   }
}

2. Skopiuj kod i wklej go w edytorze programu w języku Kotlin, a potem uruchom program, aby zobaczyć dane wyjściowe.

Gdy wartość num wynosi 3, nic nie jest drukowane, ponieważ wartość num jest mniejsza niż 4. Warunek num > 4 jest więc false, a kod między nawiasami klamrowymi nie jest wykonywany i nic nie jest drukowane.

Użyj else, aby utworzyć alternatywę dla niespełnionych warunków

Zamiast nic nie robić, możesz zaoferować użytkownikom alternatywę, gdy warunek nie zostanie spełniony. Podobnie jak w przypadku zwykłego języka możesz to zrobić za pomocą instrukcji else.

1. Dodaj instrukcję else, aby wyświetlić komunikat, gdy num nie jest większe niż 4, jak pokazano poniżej. Co się stanie, jeśli uruchomisz ten kod?

fun main() {
   val num = 3
   if (num > 4) {
       println("The variable is greater than 4")
   } else {
       println("The variable is less than 4")
   }
}

2. Skopiuj kod i wklej go w edytorze programu w języku Kotlin, a potem uruchom program, aby zobaczyć dane wyjściowe.

The variable is less than 4

3. Zwróć uwagę, że gdy num ma wartość 3, program wyświetla komunikat "The variable is less than 4" powiązany z instrukcją else, ponieważ num nie jest większe niż 4 .
4. Zmień num na 5 i ponownie uruchom program. Teraz num jest większe niż 4, więc program wyświetla „The variable is greater than 4”.
5. Zmień wartość num na 4 i uruchom program. 4 nie jest większe od 4, więc program wyświetla „The variable is less than 4”.

Chociaż „The variable is less than 4” jest prawidłowym wynikiem dla warunków ustawionych w kodzie, wydrukowane stwierdzenie jest nieprawdziwe, ponieważ 4 nie jest mniejsze od 4. Możesz dodać kolejny warunek, który sprawdzi trzecią możliwość, czyli czy num jest dokładnie równe 4, i wyświetli prawidłowe stwierdzenie, gdy ten warunek będzie spełniony.

Użyj kombinacji else + if, aby dodać alternatywne warunki.

Możesz mieć więcej niż jeden warunek. W tym przykładzie wszystkie możliwości dla num możesz uwzględnić w ten sposób:

• Jeśli num jest większe niż 4, wydrukuj „The variable is greater than 4”.
• W przeciwnym razie, jeśli num jest równe 4, wydrukuj "The variable is equal to 4".
• W przeciwnym razie wydrukuj "The variable is less than 4".

W instrukcji if-else są one określane jako różne przypadki. Na liście są 3 zgłoszenia.

Zaktualizowany kod wygląda tak:

fun main() {
   val num = 4
   if (num > 4) {
       println("The variable is greater than 4")
   } else if (num == 4) {
       println("The variable is equal to 4")
   } else {
       println("The variable is less than 4")
   }
}

Zwróć uwagę na te zmiany:

• Wartość num została ustawiona na 4, dzięki czemu możesz przetestować nowy warunek.
• Pomiędzy pierwotnymi instrukcjami if i else znajduje się nowa instrukcja else if dla przypadku, gdy num wynosi dokładnie 4.

1. Skopiuj i wklej powyższy kod w edytorze programu w języku Kotlin, a potem uruchom program, aby zobaczyć dane wyjściowe.

The variable is equal to 4

2. Eksperymentuj ze zmianą wartości num i sprawdzaj, jak wpływa to na dane wyjściowe. Zmień wartości num na 2 i 6, aby zobaczyć, jak każdy z warunków jest spełniony true.

Kontrola przepływu

Jeśli przyjrzysz się powyższym instrukcjom if-else, zobaczysz, że kod będzie wykonywany (przepływ) zgodnie z warunkami. Sposób, w jaki kierujesz wykonaniem za pomocą tych warunków, nazywa się „przepływem sterowania” programu.

• Załóżmy, że wynik rzutu kostką num to 3. Program sprawdza pierwszy warunek (num > 4). Jest to fałsz, więc program sprawdza następny warunek (num == 4), który również jest fałszywy. Następnie program wykonuje kod instrukcji else, która jest ostatnią opcją.
• Jeśli liczba oczek na kostce to 6, pierwszy warunek (num > 4) jest spełniony. Program wyświetla komunikat "The variable is greater than 4". Ponieważ ten warunek jest spełniony, nie musi sprawdzać reszty i kończy działanie instrukcji if-else.
• Aby dodać alternatywne warunki, użyj kombinacji „else + if”.

W tej sekcji, korzystając z informacji zdobytych w poprzednim zadaniu, zaktualizujesz program Dice Roller, aby sprawdzić, czy wyrzucono zdefiniowaną liczbę szczęśliwą. Jeśli tak, wygrywasz!

Konfigurowanie kodu startowego

Zaczynasz od programu Lucky Dice Roller z kodem podobnym do kodu rozwiązania poprzedniego programu Kotlin Dice Roller. Możesz edytować funkcję main() w poprzednim kodzie, aby ją dopasować, lub skopiować i wkleić poniższy kod, aby rozpocząć.

fun main() {
    val myFirstDice = Dice(6)
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.numSides} sided dice rolled ${diceRoll}!")
}

class Dice (val numSides: Int) {

    fun roll(): Int {
        return (1..numSides).random()
    }
}

Sprawdź, czy wylosowano szczęśliwy numer

Najpierw utwórz szczęśliwy numer, a potem porównaj z nim wynik rzutu kostką.

.

1. W main() usuń instrukcję println().
2. W main() dodaj val o nazwie luckyNumber i ustaw jego wartość na 4. Kod powinien wyglądać tak:

fun main() {
    val myFirstDice = Dice(6)
    val rollResult = myFirstDice.roll()
    val luckyNumber = 4
}

3. Poniżej dodaj instrukcję if z warunkiem w nawiasach (), który sprawdza, czy rollResult jest równe (==) luckyNumber. Zostaw trochę miejsca między nawiasami klamrowymi {}, aby móc dodać więcej kodu.

fun main() {
    val myFirstDice = Dice(6)
    val rollResult = myFirstDice.roll()
    val luckyNumber = 4
    if (rollResult == luckyNumber) {

    }
}

4. W nawiasach klamrowych {} dodaj instrukcję println, aby wydrukować "You win!".

fun main() {
    val myFirstDice = Dice(6)
    val rollResult = myFirstDice.roll()
    val luckyNumber = 4

    if (rollResult == luckyNumber) {
        println("You win!")
    }
}

5. Uruchom program. Może być konieczne uruchomienie go kilka razy, zanim zobaczysz w wyniku zwycięską wiadomość.

You win!

Odpowiadaj, gdy szczęśliwa liczba nie została wylosowana

Brak informacji zwrotnej z programu, jeśli użytkownik nie wygrał, może sprawić, że będzie się zastanawiać, czy program działa prawidłowo. Zawsze warto reagować, gdy użytkownik wykona jakąś czynność. W przypadku programu Lucky Dice Roller możesz poinformować użytkowników, że nie wygrali, używając instrukcji else.

1. Dodaj instrukcję else, aby wydrukować "You didn't win, try again!".

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   if (rollResult == luckyNumber) {
       println("You win!")
   } else {
       println("You didn't win, try again!")
   }
}

2. Uruchom program, a użytkownicy zawsze otrzymają powiadomienie, niezależnie od wyniku.

W tym momencie użytkownicy wiedzą, czy wygrali, ale nie wiedzą, dlaczego. Zawsze informuj użytkowników, aby wiedzieli, jakie będą skutki ich działań. Wyobraź sobie, że Twój program to wniosek o pożyczkę. „Nie otrzymasz kredytu, ponieważ Twoja ocena kredytowa jest niska” to znacznie bardziej informująca odpowiedź niż „Przykro nam, nie możemy Ci przyznać kredytu. Spróbuj ponownie”. W przypadku aplikacji Lucky Dice Roller możesz wyświetlać użytkownikom różne komunikaty informacyjne po każdej przegranej. Aby to zrobić, użyj wielu instrukcji else if.

3. Dodaj instrukcje else if, aby wydrukować inną wiadomość dla każdego zwinięcia. W razie potrzeby skorzystaj z formatu, którego używaliśmy w poprzednim zadaniu.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   if (rollResult == luckyNumber) {
       println("You win!")
   } else if (rollResult == 1) {
       println("So sorry! You rolled a 1. Try again!")
   } else if (rollResult == 2) {
       println("Sadly, you rolled a 2. Try again!")
   } else if (rollResult == 3) {
       println("Unfortunately, you rolled a 3. Try again!")
   } else if (rollResult == 4) {
       println("No luck! You rolled a 4. Try again!")
   } else if (rollResult == 5) {
       println("Don't cry! You rolled a 5. Try again!")
   } else {
       println("Apologies! you rolled a 6. Try again!")
   }
}

W powyższym kodzie

• Sprawdź, czy rollResult to luckyNumber.
• Jeśli rollResult to luckyNumber, wydrukuj zwycięską wiadomość.
• W przeciwnym razie sprawdź, czy wartość rollResult wynosi 1, a jeśli tak, wyświetl komunikat o ponowieniu próby.
• W przeciwnym razie sprawdź, czy wartość rollResult wynosi 2, a jeśli tak, wyświetl inny komunikat o ponownej próbie.
• W przeciwnym razie sprawdzaj dalej, aż dojdziesz do numeru 5.
• Jeśli liczba nie była żadną z liczb od 1 do 5, jedyną pozostałą opcją jest 6, więc nie musisz przeprowadzać kolejnego testu z użyciem else if. Możesz po prostu przechwycić tę ostatnią opcję za pomocą ostatniej instrukcji else.

Wskazówka: w bloku kodu if-else możesz mieć tylko 1 instrukcję if i 1 instrukcję else, ale pomiędzy nimi możesz umieścić dowolną liczbę instrukcji else if.

Wielokrotne użycie else if jest bardzo powszechne, dlatego Kotlin ma prostszy sposób ich zapisywania.

Testowanie wielu różnych wyników lub przypadków jest w programowaniu bardzo powszechne. Czasami lista możliwych wyników może być bardzo długa. Jeśli np. rzucasz 12-ścienną kostką, między sukcesem a ostatecznym else będzie 11 else if. Aby ułatwić pisanie i czytanie tego rodzaju instrukcji, co pomaga uniknąć błędów, Kotlin udostępnia instrukcję when.

Zmienisz program tak, aby używał instrukcji when. Instrukcja when zaczyna się od słowa kluczowego when, po którym następują nawiasy (). W nawiasach wpisz wartość do przetestowania. Po nim następują nawiasy klamrowe {}, w których umieszcza się kod do wykonania w różnych warunkach.

1. W programie w main() wybierz kod od pierwszego wyrażenia if do nawiasu klamrowego } zamykającego ostatnie wyrażenie else i usuń go.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4
}

2. W main(), pod deklaracją luckyNumber, utwórz instrukcję when. Ponieważ funkcja when musi być testowana w porównaniu z wynikiem zaokrąglonym, umieść rollResult w nawiasach (). Dodaj nawiasy klamrowe {} z dodatkowymi odstępami, jak pokazano poniżej.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   when (rollResult) {

   }
}

Jak poprzednio, najpierw sprawdź, czy rollResult jest takie samo jak luckyNumber.

1. W nawiasach klamrowych {} instrukcji when dodaj instrukcję, która sprawdza, czy rollResult jest równe luckyNumber, a jeśli tak, wyświetla zwycięską wiadomość. Wygląda ono tak:

luckyNumber -> println("You win!")

Oznacza to, że:

• Najpierw umieść wartość, z którą chcesz porównać rollResult. To luckyNumber.
• Następnie dodaj strzałkę (->).
• Następnie dodaj działanie, które ma zostać wykonane w przypadku dopasowania.

Odczytuj to jako „Jeśli rollResult jest luckyNumber, wydrukuj wiadomość "You win!"”.

Kod na urządzeniu main() wygląda tak:

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   when (rollResult) {
       luckyNumber -> println("You win!")
   }
}

2. Dodaj wiersze i wiadomości dla możliwych wyników rzutu od 1 do 6 w taki sam sposób jak poniżej. Gotowa funkcja main() powinna wyglądać tak.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   when (rollResult) {
       luckyNumber -> println("You won!")
       1 -> println("So sorry! You rolled a 1. Try again!")
       2 -> println("Sadly, you rolled a 2. Try again!")
       3 -> println("Unfortunately, you rolled a 3. Try again!")
       4 -> println("No luck! You rolled a 4. Try again!")
       5 -> println("Don't cry! You rolled a 5. Try again!")
       6 -> println("Apologies! you rolled a 6. Try again!")
   }
}

3. Uruchom program. Wynik jest taki sam, ale kod jest znacznie bardziej zwarty i czytelny.

Gratulacje! Poznaliśmy 2 sposoby drukowania wiadomości w zależności od warunku. To potężne narzędzie do pisania ciekawych programów.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   when (rollResult) {
       luckyNumber -> println("You won!")
       1 -> println("So sorry! You rolled a 1. Try again!")
       2 -> println("Sadly, you rolled a 2. Try again!")
       3 -> println("Unfortunately, you rolled a 3. Try again!")
       4 -> println("No luck! You rolled a 4. Try again!")
       5 -> println("Don't cry! You rolled a 5. Try again!")
       6 -> println("Apologies! you rolled a 6. Try again!")
   }
}

class Dice(val numSides: Int) {
   fun roll(): Int {
       return (1..numSides).random()
   }
}

• Użyj instrukcji if, aby ustawić warunek wykonania niektórych instrukcji. Jeśli na przykład użytkownik wylosuje szczęśliwą liczbę, wyświetl komunikat o wygranej.
• Typ danych Boolean ma wartości true i false i może być używany do podejmowania decyzji.
• Porównuj wartości za pomocą operatorów takich jak większe niż (>), mniejsze niż (<) i równe (==).
• Aby ustawić wiele warunków, użyj ciągu instrukcji else if. Możesz na przykład wydrukować inną wiadomość dla każdego możliwego wyniku rzutu kostką.
• Na końcu ciągu warunków użyj instrukcji else, aby uwzględnić wszystkie przypadki, które nie zostały wyraźnie opisane. Jeśli obejmiesz przypadki dla 6-ściennych kostek, instrukcja else obejmie liczby 7 i 8 wyrzucone na 8-ściennej kostce.
• Użyj instrukcji when jako zwartej formy wykonywania kodu na podstawie porównania wartości.

Ogólna postać instrukcji if-else:

if (condition-is-true) {

execute-this-code

} else if (condition-is-true) {

execute-this-code

} else {

execute-this-code

}

When statement:

when (variable) {

matches-value -> execute-this-code

matches-value -> execute-this-code

...

}

• Kotlin: Control flow
• Kotlin: when
• Warunki

Uwaga: praktyki są opcjonalne. Dają one możliwość przećwiczenia tego, czego nauczyłeś się w tym ćwiczeniu, a czasami zawierają wyzwanie związane z kodowaniem.

Wykonaj te czynności:

1. Zmień myFirstDice tak, aby miał 8 boków, i uruchom kod. Co się dzieje

Wskazówka: gdy zwiększysz liczbę boków, instrukcja when nie będzie już obejmować wszystkich przypadków, więc w przypadku nieobjętych przypadków nic nie zostanie wydrukowane.

2. Popraw stwierdzenie when, aby uwzględnić wszystkie 8 stron. Możesz to zrobić, dodając przypadki dla dodatkowych numerów. Problem: zamiast dodawać nowy przypadek dla każdego numeru, użyj instrukcji else, aby uwzględnić wszystkie przypadki, które nie są wyraźnie objęte.

Wskazówka: możesz dodać więcej etui, aby zabezpieczyć więcej boków. To dobry sposób, jeśli chcesz, aby każdy numer, który można przekierować, miał inny komunikat. Możesz też użyć instrukcji else i wydrukować ten sam komunikat dla wszystkich boków większych niż 6, które są objęte bieżącym kodem.

3. Zmień myFirstDice tak, aby miał tylko 4 boki. Co się dzieje

Wskazówka: zmiana liczby ścianek kostki na mniejszą niż ta, która jest objęta stwierdzeniem when, nie ma zauważalnego wpływu, ponieważ wszystkie możliwe przypadki są objęte tym stwierdzeniem.