В прошлой статье мы узнали о некоторых основных концепциях Kotlin, таких как условные операторы, циклы и операторы перехода. Перед прочтением этой статьи убедитесь, что вы прочитали последнюю статью Основы Kotlin — Часть 3. Давайте узнаем больше о Kotlin.

Функции:

Функции в любом языке программирования — это группа взаимосвязанных блоков кода, выполняющих определенную задачу. Функции позволяют нам разбивать программу на различные небольшие подмодули. Функции повышают удобочитаемость кода, возможность его повторного использования и упрощают управление программой.

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

  • Стандартная библиотечная функция.Стандартная библиотечная функция — это встроенные библиотечные функции, которые могут быть определены неявно и доступны для использования.
fun main(args: Array<String>){  
var number = 16
var result = Math.sqrt(number.toDouble())  
print("$result")  
}
Output : 4

В приведенном выше фрагменте кода:

sqrt() — это функция, определенная в библиотеке, которая возвращает квадратный корень числа.

Функция print() выводит сообщение в стандартный поток вывода.

  • Определяемые пользователем функции. Определяемые пользователем функции создаются пользователем и могут использоваться для расширенного программирования. Здесь функции объявляются с использованием ключевого слова fun.
fun main(){
   functionName()
}
fun functionName(){
     //body of function
}

Здесь мы вызываем функцию в основную функцию для запуска кода внутри тела functionName().

Template for function in Kotlin:
fun functionName(argument name:argument type):return type{
      //body of function
}

Ниже приведен пример пользовательской функции

fun main() {
  val x=6
  val y=8
  println("Sum of $x and $y is "+add(x,y))
}
fun add(x:Int, y:Int):Int{
    return x+y
}

Здесь мы создаем функцию add, которая принимает два аргумента типа int, и возвращаемый тип этой функции также int. Мы вызвали эту функцию внутри нашей основной функции.

Хвостовая рекурсия:

Kotlin поддерживает стиль функционального программирования, известный как хвостовая рекурсия. Когда мы пытаемся сделать большое количество рекурсивных вызовов функций, мы получаем ошибку java.lang.StackOverflowError. Для этого в Kotlin есть функция tailrec. Когда функция помечена модификатором tailrec и соответствует требуемой форме, компилятор оптимизирует рекурсию, оставляя вместо нее быструю и эффективную версию на основе цикла. Хвостовая рекурсия следует одному правилу реализации. Это правило заключается в следующем:

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

Например, чтобы вычислить факториал любого числа, мы можем использовать следующий метод:

fun main(args: Array<String>) {  
    val number = 10  
    val result: Long  
    result = factorial(number)  
    println("Factorial of $number = $result")  
}  
  
tailrec fun factorial(n: Int, run: Int = 1): Long {  
    return if (n == 1){  
        run.toLong()  
    } else {  
        factorial(n-1, run*n)  
    }  
}
Output : 
Factorial of 10 = 3628800

Лямбда-выражения:

Лямбда — это функция, у которой нет имени. Лямбда определяется фигурными скобками {}, которые принимают переменную в качестве параметра (если есть) и тело функции. тело функции записывается после переменной (если она есть), за которой следует оператор -›.

Syntax of lambda expression:
{ variable -> body_of_function}

Синтаксис лямбда-выражения

Полная синтаксическая форма лямбда-выражений выглядит следующим образом:

val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }
  • Лямбда-выражение всегда заключено в фигурные скобки.
  • Объявления параметров в полной синтаксической форме заключаются в фигурные скобки и имеют необязательные аннотации типов.
  • Тело идет после знака ->.
  • Если предполагаемый тип возвращаемого значения лямбда-выражения не равен Unit, последнее (или, возможно, единственное) выражение внутри тела лямбда-выражения рассматривается как возвращаемое значение.
Program for adding two numbers using lambda
fun main(args: Array<String>) {  
    println(sum(5,6))
}  
val sum = { x: Int, y: Int -> x + y }
Output : 11

Обработка исключений в Котлине:

Исключение в программировании определяется как проблема времени выполнения, которая возникает в программе и приводит к завершению программы. Исключения могут возникать из-за меньшего объема памяти, массива за пределами границ, таких условий, как деление на ноль. Для решения этого типа ошибок в программе используется обработка исключений.

Обработка исключений определяется как процесс, который обрабатывает проблемы во время выполнения, а также поддерживает поток программы во время выполнения.

В Kotlin все классы исключений являются потомками класса Throwable. Kotlin использует выражение «throw» для создания объекта исключения.

Существует четыре типа ключевых слов, используемых при обработке исключений. Эти:

  • try: блок try содержит блок инструкций, которые могут создать исключение. За ним всегда следует либо catch, либо finally, либо и то, и другое.
  • catch: используется для перехвата исключения из блока try.
  • наконец: используется для проверки обработки исключения.
  • throw: используется для явного создания исключения.
Example of try-catch
fun main (args: Array<String>){  
    try {   
        val res =  9/ 0  
        
    } catch (e: ArithmeticException) {  
        println(e)  
    }
}
Output :
java.lang.ArithmeticException: / by zero

Мы можем вызвать исключение явно, используя ключевое слово throw.

Example of try-catch using throw keyword
fun main (args: Array<String>){  
    try {   
       println("Inside throw")
       throw Exception("Exception throwed")
} catch (e: Exception) {  
        println(e)  
    }
}
Output:
Inside throw 
java.lang.Exception: Exception throwed

Это все для этой статьи. Продолжим в следующей статье.

Счастливого обучения!