Условные операторы в Kotlin — часть 1

В этой лабораторной работе на Kotlin вы создадите ещё одну игру в кости — Lucky Dice Roll, — пытаясь выбросить счастливое число. Ваша программа задаёт счастливое число и бросает кости. Затем вы сравниваете результат броска со счастливым числом и выводит соответствующее сообщение. Для этого вы научитесь сравнивать значения и принимать различные решения в своей программе на Kotlin.

Чтобы сосредоточиться на концепциях программирования, не беспокоясь о пользовательском интерфейсе приложения, вы будете использовать браузерный инструмент программирования Kotlin и выводить результаты в консоль.

Предпосылки

• Как открыть, редактировать и запустить код в https://try.kotlinlang.org/
• Умение создавать и запускать программу на языке Kotlin, которая использует переменные, функции с аргументами, классы с методами и выводит результат на консоль.

Чему вы научитесь

• Как использовать операторы if и else
• Как сравнивать значения с помощью таких операторов, как больше ( > ), меньше ( < ) и равно ( == ).
• Как использовать операторы when для выбора варианта на основе заданного значения.
• Что такое Boolean тип данных и как использовать его true и false значения для принятия решений.

Что вы построите

• Lucky Dice Roll — игра в кости на Kotlin, в которой можно выбрать счастливое число. Игрок выигрывает, если выпадет счастливое число.

Что вам нужно

• Компьютер с подключением к Интернету.

Ваша программа Lucky Dice Roller должна определить, выбросил ли пользователь счастливый номер и получает ли он поздравления или вместо этого получает сообщение с просьбой повторить попытку.

Как разработчику приложения вам придется принимать решения о том, как приложение должно себя вести и создавать различные результаты для своих пользователей.

Если вы разрабатываете приложение для покупок, вы можете отображать разные экраны в зависимости от выбранного пользователем варианта доставки. В игре-викторине вы можете отображать разные экраны в зависимости от правильности ответа игрока. В зависимости от приложения, возможны различные варианты исходов, которые следует учесть в коде.

В вашей программе Lucky Dice Roller приложение должно обрабатывать различные случаи, такие как:

• Если при броске кубиков выпадет счастливое число, выведите на экран поздравительное сообщение!
• В противном случае, если при броске кубиков выпало не счастливое число, выводится сообщение с предложением повторить попытку.

Чтобы добавить эту логику в свой код, используйте специальные ключевые слова Kotlin, такие как if , else и when .

Давайте рассмотрим несколько примеров.

Используйте оператор if , чтобы задать условие, которое будет выполнено.

1. Взгляните на код ниже. Можете ли вы угадать, что получится на выходе?

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

2. Скопируйте и вставьте код в редактор программ Kotlin, запустите программу и посмотрите на результат.

The variable is greater than 4

Процесс принятия решений по этой программе:

1. Создайте переменную num и присвойте ей значение 5.
2. Если верно, что num больше ( > ) 4 , выведите "The variable is greater than 4" .
3. Во всех остальных ситуациях не делайте ничего.

В приведенном выше примере num равно 5. Оператор if проверяет, больше ли переменная 4. Поскольку это так, система выполняет инструкции в фигурных скобках и выводит сообщение.

Резюме: Символ > — это оператор для сравнения двух значений, чтобы определить, больше ли первое значение второго, и возвращающий результат true или false . Другие распространённые операторы: < меньше, == равно, >= — больше или равно, и <= меньше равно.

Обратите внимание на общий формат оператора if :

• Начните с ключевого слова if .
• Далее следуют две скобки () . Внутри скобок указывается условие. Условие может быть true или false . Например, больше ли одно число другого.
• Далее следуют две фигурные скобки {} . Внутри фигурных скобок вы размещаете код, который будет выполнен, если условие true .

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

Логический тип данных для значений «истина» и «ложь»:

• Программа, проверяющая выполнение условия, называется «оценкой условия». Результат оценки условия — true , если оно выполнено, и false , если не выполнено. Разработчики также говорят: «условие оценивается как true » или «условие оценивается как false ».
• Условия могут быть оценены только как true или false .
• Подобно тому, как существует тип данных Int для целых чисел и IntRange для диапазонов, существует тип данных для значений true и false , называемый Boolean . Переменные типа Boolean познакомятся с переменными типа Boolean далее в этом курсе.

Используйте оператор if чтобы задать условие, которое не выполняется.

1. Измените значение num на 3, как показано ниже. Что, по вашему мнению, произойдёт при запуске этого кода?

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

2. Скопируйте и вставьте код в редактор программ Kotlin, запустите программу и посмотрите на результат.

Если num равно 3, ничего не печатается, поскольку значение num меньше 4. Таким образом, условие, что num больше 4, false , и код между фигурными скобками не выполняется, и ничего не печатается.

Используйте else для создания альтернативы в случае невыполнения условий.

Вместо того, чтобы ничего не делать, вы можете предложить пользователям альтернативу, если условие не выполняется. Как и в обычном языке, это можно сделать с помощью оператора else .

1. Добавьте оператор else , чтобы вывести сообщение, когда num не больше 4, как показано ниже. Что, по вашему мнению, произойдёт при запуске этого кода?

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

2. Скопируйте и вставьте код в редактор программ Kotlin, запустите программу и посмотрите на результат.

The variable is less than 4

3. Обратите внимание, что когда num имеет значение 3, программа выводит сообщение "The variable is less than 4" связанное с оператором else поскольку num не больше 4.
4. Измените num на 5 и запустите программу снова. Теперь num действительно больше 4, и программа выведет « The variable is greater than 4 ».
5. Измените num на 4 и запустите программу. Теперь 4 не больше 4, и программа выведет « The variable is less than 4 ».

Хотя « The variable is less than 4 » является правильным выводом для условий, заданных вами в коде, это напечатанное утверждение неточно, поскольку 4 не меньше 4. Что вы можете сделать, так это добавить еще одно условие, которое проверяет третью возможность, равно ли num точно 4, и выводит правильное утверждение, если это условие истинно.

Используйте комбинацию else + if для добавления альтернативных условий.

Условий может быть несколько. В вашем примере вот как можно охватить все возможные варианты для num :

• Если num больше 4, выведите « The variable is greater than 4 ».
• В противном случае, если num равно 4, вывести "The variable is equal to 4" .
• В противном случае выведите "The variable is less than 4" .

В операторе if-else они называются различными вариантами. Перечислены 3 варианта.

Обновленный код выглядит следующим образом:

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")
   }
}

Обратите внимание на следующие изменения:

• Значение num теперь установлено на 4, чтобы вы могли проверить новое условие.
• Между исходными операторами if и else находится новый оператор else if для случая, когда num равно ровно 4.

1. Скопируйте и вставьте указанный выше код в редактор программ Kotlin и запустите программу, чтобы увидеть вывод.

The variable is equal to 4

2. Поэкспериментируйте с изменением значения num и посмотрите, как это повлияет на результат. Измените num на 2 и 6, чтобы увидеть true каждого из условий.

Поток управления

Если взглянуть на приведенные выше операторы if-else, то можно увидеть, что код будет выполняться, или протекать, в соответствии с условиями. Таким образом, способ управления выполнением с помощью этих условных операторов называется «потоком управления» программы.

• Допустим, вы бросили кубик, num равно 3. Программа проверяет первое условие (число > 4). Оно ложно, поэтому программа проверяет следующее условие (число == 4), которое также ложно. Затем программа выполняет код оператора else, который является последним вариантом.
• Если выпавшее число равно 6, первое условие (число > 4) истинно. Программа выводит сообщение "The variable is greater than 4" . Поскольку это условие истинно, остальные проверки не требуются, и всё выполняется с помощью оператора if-else.
• Используйте комбинацию else + if для добавления альтернативных условий.

В этом разделе, используя знания, полученные в предыдущем задании, вы обновите программу Dice Roller, чтобы она проверяла, выпало ли у вас заданное счастливое число. Если да, вы выиграли!

Настройте свой стартовый код

Вы запускаете Lucky Dice Roller с кодом, похожим на код решения предыдущей программы Kotlin Dice Roller. Вы можете отредактировать функцию main() в вашем предыдущем коде, чтобы она соответствовала, или скопировать и вставить код ниже, чтобы начать работу.

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()
    }
}

Проверьте, выпало ли счастливое число.

Сначала придумайте счастливое число, а затем сравните результат броска кубика с этим числом.

.

1. В main() удалите оператор println() .
2. В main() добавьте val с именем luckyNumber и задайте ему значение 4. Ваш код должен выглядеть следующим образом.

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

3. Ниже добавьте оператор if с условием внутри скобок () , который проверяет, равен ли rollResult ( == ) значению luckyNumber . Оставьте немного места между фигурными скобками {} , чтобы можно было добавить больше кода.

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

    }
}

4. Внутри фигурных скобок {} добавьте оператор println , чтобы напечатать "You win!"

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

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

5. Запустите программу. Возможно, вам придётся запустить её несколько раз, прежде чем вам повезёт и вы увидите сообщение о победе!

You win!

Реагируйте, если счастливое число не выпало

Отсутствие обратной связи от программы в случае, если пользователь не выиграл, может заставить пользователя задуматься, не сломалась ли программа. Рекомендуется всегда отвечать на действия пользователя. В программе Lucky Dice Roller вы можете сообщить пользователю о том, что он не выиграл, используя оператор else .

1. Добавьте оператор else , чтобы вывести "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. Запустите программу, и независимо от результата ваши пользователи всегда будут уведомлены.

На этом этапе пользователи знают, выиграли они или нет, но не знают, почему. Всегда предоставляйте пользователям информацию, чтобы они понимали результат своих действий! Представьте, что ваша программа — это заявка на кредит. «Ваша заявка не была одобрена, потому что у вас низкий кредитный рейтинг» — это гораздо информативнее, чем «Извините, вам не дадут кредит, попробуйте ещё раз!» В Lucky Dice Roller вы можете выводить пользователям разные информационные сообщения для каждого проигрышного броска. Для этого используйте несколько операторов else if .

3. Добавьте операторы else if , чтобы вывести разные сообщения для каждого броска. При необходимости воспользуйтесь форматом, который вы изучили в предыдущем задании.

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!")
   }
}

В коде выше вы

• Проверьте, является ли rollResult luckyNumber .
• Если rollResult — это luckyNumber , выведите сообщение о выигрыше.
• В противном случае проверьте, равен ли rollResult 1, и если да, выведите сообщение «Повторите попытку».
• В противном случае проверьте, равен ли rollResult 2, и если да, выведите другое сообщение о повторной попытке.
• В противном случае продолжайте проверку до цифры 5.
• Если число не было ни одним из диапазонов от 1 до 5, то единственным оставшимся вариантом является 6, поэтому нет необходимости в еще одной проверке с помощью else if , и вы можете просто перехватить этот последний вариант с помощью заключительного оператора else .

Совет: в блоке кода if-else может быть только один оператор if с одним оператором else , но между ними может быть столько операторов else if , сколько вам нужно.

Поскольку наличие множественных вариантов else if встречается очень часто, в Kotlin предусмотрен более простой способ их записи.

Тестирование множества различных исходов, или случаев, очень распространено в программировании. Иногда список возможных исходов может быть очень длинным. Например, если бы вы бросали 12-гранный кубик, между «успехом» и «финалом» было бы 11 else if else . Чтобы упростить написание и чтение подобных операторов и избежать ошибок, в Kotlin предусмотрен оператор when .

Вы собираетесь изменить свою программу, чтобы использовать оператор when . Оператор when начинается с ключевого слова when , за которым следуют круглые скобки () . Внутри круглых скобок указывается проверяемое значение. За ним следуют фигурные скобки {} , чтобы код выполнялся при различных условиях.

1. В вашей программе, в main() , выберите код от первого оператора if до фигурной скобки } , закрывающей последний оператор else , и удалите его.

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

2. В main() , под объявлением luckyNumber , создайте оператор when . Поскольку в операторе when необходимо проверять результат свёртки, поместите rollResult между скобками () . Добавьте фигурные скобки {} с дополнительным интервалом, как показано ниже.

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

   when (rollResult) {

   }
}

Как и прежде, сначала проверьте, совпадает ли rollResult с luckyNumber .

1. Внутри фигурных скобок {} оператора when добавьте оператор, который проверяет rollResult на соответствие luckyNumber и, если они совпадают, выводит сообщение о победившей комбинации. Оператор выглядит следующим образом:

luckyNumber -> println("You win!")

Это означает:

• Сначала вы помещаете сравниваемое значение в rollResult . Это luckyNumber .
• После этого добавьте стрелку ( -> ).
• Затем добавьте действие, которое следует выполнить в случае совпадения.

Читается это как: «Если rollResult — luckyNumber , вывести сообщение "You win!" ».

А ваш код main() выглядит так.

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

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

2. Используйте тот же шаблон для добавления строк и сообщений для возможных бросков 1–6, как показано ниже. Готовая функция main() должна выглядеть так.

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. Запустите программу. Результат ничем не отличается, но код стал гораздо компактнее и удобнее для чтения.

Поздравляем! Вы изучили два способа вывода сообщений в зависимости от условия. Это мощный инструмент для написания интересных программ!

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()
   }
}

• Используйте оператор if для задания условия выполнения некоторых инструкций. Например, если пользователь выбросил счастливое число, выведите сообщение о выигрыше.
• Тип данных Boolean имеет значения true и false и может использоваться для принятия решений.
• Сравнивайте значения, используя такие операторы, как больше ( > ), меньше ( < ) и равно ( == ).
• Используйте цепочку операторов else if для задания нескольких условий. Например, выводите разные сообщения для каждого возможного результата броска кубика.
• Используйте оператор else в конце цепочки условий, чтобы перехватить все случаи, которые могут не быть охвачены явно. Если вы охватываете случаи с шестигранной игральной костью, оператор else перехватит числа 7 и 8, выпавшие при бросании восьмигранной игральной кости.
• Используйте оператор when как компактную форму выполнения кода на основе сравнения значений.

Общая форма if-else:

if ( condition-is-true ) {

execute-this-code

} else if ( condition-is-true ) {

execute-this-code

} else {

execute-this-code

}

Когда утверждение:

when ( variable ) {

matches-value -> execute-this-code

matches-value -> execute-this-code

...

}

• Kotlin: Управление потоком
• Котлин: когда
• Условные предложения

Примечание: Практические занятия необязательны. Они дают вам возможность закрепить полученные в этой лабораторной работе знания на практике и иногда включают в себя задания по программированию.

Сделайте следующее:

1. Измените myFirstDice на 8 граней и запустите код. Что произойдёт?

Подсказка: при увеличении количества сторон ваш оператор when больше не охватывает все случаи, поэтому для неохваченных случаев ничего не выводится.

2. Исправьте оператор when , чтобы учесть все 8 сторон. Это можно сделать, добавив варианты для дополнительных чисел. Задача: вместо добавления нового варианта для каждого числа используйте оператор else , чтобы перехватить все варианты, которые не охвачены явно.

Подсказка: можно добавить больше вариантов, чтобы охватить больше граней. Это хороший способ сделать это, если вы хотите, чтобы для каждого выпавшего числа выводилось отдельное сообщение. Или можно использовать оператор else и вывести одно и то же сообщение для всех граней, больших 6, охватываемых текущим кодом.

3. Измените myFirstDice так, чтобы у него было только 4 грани. Что произойдёт?

Подсказка: изменение количества граней кубика до значения меньшего, чем то, которое охватывается оператором when не оказывает заметного эффекта, поскольку охватываются все возможные случаи.