An introduction to Kotlin for advanced Android beginners, covering command-line compilation of Kotlin files, conditional logic, val/var, basic functions, higher order functions, recursion.

1. Android
Development for
Advanced Beginners
Working with Kotlin
Basic Concepts

2. What is Kotlin?
•A language for Android development
•Official support: Google IO (2017)
•Currently in version 1.0
•Supports Java Frameworks/Libraries
•Kotlin files have a “.kt” extension

3. Kotlin Features
•Code is compiled to byte code
•Compile time code checking
•Run-time code checking
•Integrates with Maven, Gradle, etc
•IntelliJ automatically converts Java to Kotlin

4. Kotlin Features
• provides null safety
•Does not require “;” to separate statements
•Support for functions outside of classes
•Variables are first, then the variable type:
firstName: String

5. Kotlin Primitives
•Numeric: Double, Float, Long, Int, Short, Byte
•Other primitive types: Char, String, Boolean
•Conversion between types must be explicit
•+/-/*/ operator precedence: same as Java

6. A Kotlin “Hello World” Program
•Kotlin code:
fun main(args: Array<String>) {
println("Hello, World!")
}
•Java code:
public class HelloWorld1 {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}

7. Compiling a Kotlin Program
•Step 1: compile HelloWorld.kt:
kotlinc HelloWorld.kt -include-runtime -d HelloWorld.jar
•Step 2: notice the newly created JAR file:
HelloWorld.jar
•Step 3: launch HelloWorld:
java -jar HelloWorld.jar HelloWorld
•Output: Hello, World!

8. A Kotlin Program: Command Line Args
fun main(args: Array<String>) {
if (args.size < 2) {
println("Please enter a string")
return
}
println("Hello, ${args[1]}!")
}

9. Compiling a Kotlin Program
•Step 1: compile CommandLine1.kt:
kotlinc CommandLine1 -include-runtime -d CommandLine1.jar
•Step 2: notice the newly created JAR file:
CommandLine1.jar
•Step 3: launch CommandLine1:
java -jar CommandLine1.jar CommandLine1 Pasta
•Output: Hello, Pasta!

10. Kotlin Variables
•All variable declarations must be initialized
•'var' keyword: a variable that can be modified
•'val' keyword: a variable that cannot be modified
•A 'var' variable generates a getter and setter
•A 'val' variable generates only a getter

11. Kotlin Pointers
•Kotlin avoids the null pointer exception:
Use of the “Elvis” operator
•Sample code that compiles:
val name: String? = null
•Sample code that does not compile:
val name: String? = null
val namelen = name.length

12. Kotlin “val” Example
fun main(args: Array<String>) {
//val x1 : Int = 5
//val x2 : Int = 7
val x1 = 5
val x2 = 7
println("x1 = "+x1)
println("x2 = "+x2)
}
Output:
x1 = 5
x2 = 7

13. Kotlin “var” Example
fun main(args: Array<String>) {
var x1 : Int = 5
var x2 : Int = 7
var x3 = 13
var x4 = 22
val y1 = 8
val y2 = 2

14. Kotlin “var” Example
println("x1 = "+x1)
println("x2 = "+x2)
println("x3 = "+x3)
println("x4 = "+x4)
println("y1 = "+y1)
println("y2 = "+y2)
}
Exercise: compile and run this code sample

15. Kotlin Functions
•Unit-returning functions
•Single-Expression functions
•Variable argument functions
NB: If the compiler can infer the return type, then you do not
need to explicitly declare the return type.

16. Kotlin unit-returning Functions
•they do not return a value
•the return type is Unit
•Unit is optionally specified
•Example:
•fun printHello(name: String?) {
• print("hello")
•}

17. Kotlin Single-Expression Functions
•return a single expression
•the curly braces can be omitted
•the body is specified after an "=" symbol
•These 3 function definitions are equivalent:
fun triple(x: Int): Int {
return 3*x
}
fun triple(x: Int): Int = 3*x
fun triple(x: Int) = 3*x

18. Kotlin User-defined Functions
•def numberFunc(a, b):
• print (a,b)
•def stringFunc(a, b):
• print (a,b)
•numberFunc(3, 8)
•stringFunc('one', 'two')

19. Kotlin Functions with Default Values
•def numberFunc(a, b=10):
• print (a,b)
•def stringFunc(a, b='xyz'):
• print (a,b)
•numberFunc(3)
•stringFunc('one’)

20. Kotlin Lambda Expressions
What is a Lambda Expression?
•a way of representing a function
•a powerful feature in Kotlin
•simplifies Android development

21. Kotlin Lambda Expressions
Kotlin versus Java Lambda Expressions
Kotlin lambda expressions:
•can access/modify all variables that are in scope of their
declarations
Java 8 lambda expressions:
•can only access external variables but cannot modify them

22. Kotlin Lambda Expressions
fun main(args : Array<String>) {
val printHelloWorld = {
println("Hello, world!")
}
// two ways to print result:
printHelloWorld()
printHelloWorld.invoke()
}

23. Kotlin Lambda Expressions
fun main(args : Array<String>) {
val greet = { user: String ->
println("Good afternoon, $user")
}
greet("Sara")
val showAge = { user: String, age: Int ->
println("$user is $age")
}
showAge ("Steve", 35)
}

24. Kotlin Lambda Expressions
fun main(args : Array<String>) {
val max = { a: Int, b: Int ->
if (a > b)
a
else
b
}
println("max of 10 and 4 = "+max(10,4))
}

25. Kotlin Lambda Expressions
fun main(args : Array<String>) {
val add1 = {x: Int, y: Int -> x + y}
val add2 = {x: String, y: String -> x + y}
val x1 = add1(5,7)
val x2 = add2("Hello", "Kotlin")
println("x1 = "+x1)
println("x2 = "+x2)
}

26. Kotlin Lambda Expressions
fun main(args : Array<String>) {
val add1 = {x: String, y: String -> x + y}
val add2 = {x: String, y: Any -> x + y}
val add3 = {x: Any, y: Any -> x + y} // error
val x1 = add1("Hello", "Kotlin")
val x2 = add2("Hello", "Kotlin")
val x3 = add3("Hello", 123)
println("x1 = "+x1) // HelloKotlin
println("x2 = "+x2) // HelloKotlin
println("x3 = "+x3) // error
}

27. Kotlin Higher Order Functions
•What is a Function Type?
it’s a type consisting of:
• a function signature and
• a function return type
• separated by -> operator

28. Kotlin Higher Order Functions
•Function Type Examples:
•() -> Unit // returns Unit
•() -> String // returns String
•(String) -> Unit // returns Unit
•(String) -> Float // returns Float

29. Kotlin Higher Order Functions
fun main(args : Array<String>) {
fun Fn(a:Int, b:Int) : Int {
return a + b
}
val sum = Fn(3, 5)
println("sum = "+sum)
}

30. Kotlin Higher Order Functions
fun main(args : Array<String>) {
fun Fn(a:Int, b:Int, func:(a:Int, b:Int) -> Int) {
val result = func (a, b)
println("Fn result: $result")
}
// add is of type (Int,Int) -> Int:
val add = {x: Int, y: Int -> x + y}
Fn(3, 5, add)
}

31. Kotlin Higher Order Functions
fun main(args : Array<String>) {
fun Fn(a:Int, b:Int, func1:(a:Int, b:Int) -> Int), func2:(a:Int, b:Int) -> Int) {
val result = func1( func2(a, b), func1(a,b) ) // func1(4, 14)
println("Fn result: $result")
}
// add and sub are of type (Int,Int) -> Int:
val add = {x: Int, y: Int -> x + y}
val sub = {x: Int, y: Int -> x - y}
Fn(9, 5, add, sub)
}

32. Kotlin Higher Order Functions
• Kotlin Higher Order Functions:
• The counterpart to many “intermediate operators” in FRP
• Available in various collections:
• Arrays, collections, lists and iterators
• Support method chaining
• Avoid the need for intermediate variables

33. Kotlin Higher Order Functions
• Kotlin Arrays, collections, lists and iterators support the following functions/methods:
• all, any, appendString, contains, count, drop, dropWhile, dropWhileTo, filter, filterNot,
filterNotNull,
• filterNotNullTo, filterNotTo, filterTo, find, flatMap, flatMapTo, fold, foldRight, forEach,
• groupBy, groupByTo, makeString, map, mapTo, partition, plus, reduce, reduceRight,
requireNoNulls,
• reverse, sort, sortBy, take, takeWhile, takeWhileTo, toArray, toCollection, toLinkedList,
toList,
•toSet, toSortedList, toSortedSet

34. Kotlin Higher Order Functions
• Example: working with filters:
val nums = 1 . . 25
val evens = nums.filter { it % 2 == 0 }
val odds = nums.filter { it % 2 == 1 }
evens.forEach { n -> println(n) }
odds.forEach { n -> println(n) }

35. Kotlin Higher Order Functions
• Example: working with the map function:
val numList = 1 . . 5
val times2 = numList.map{ it * 2 }
times2.forEach{ n -> println($n) }

36. Kotlin Higher Order Functions
• Example: working with filters and maps:
val nums = 1 . . 5
val x = nums.filter { it % 2 == 0 }
.map{ it * 3 }
x.forEach { n -> println($n) }
Output: ?

37. Kotlin Higher Order Functions
• Example: working with filters and maps:
val nums = 1 . . 9
val x = nums.filter { it % 4 == 0 }
.map{ it * it }
x.forEach { n -> println($n) }
Output: 16, 64
val nums = 1 . . 9
val x = nums.map { it * it }
.filter { it % 4 == 0 }
x.forEach { n -> println($n) }
Output: 4, 16, 36, 64 // 1,4,9,16,25,36,49,64,81

38. Kotlin Higher Order Functions
• Example: working with reduce:
val numList = 1 . . 5
val sumList = numList.reduce { x, y -> x + y }
println("Reduce sumList = $sumList")

39. Kotlin Higher Order Functions
• Example: working with fold:
val numList = 1 . . 5
val sumList = numList.fold(0) { x, y -> x + y }
println("Fold sumList = $sumList")

40. Kotlin Recursion
• What is Recursion?
• A solution that is composed of smaller solutions of the same type
• Can be easier to define than its iterative counterpart
• Note: problems can have an iterative and recursive solution
• Example 1: the Tower of Hanoi
• Example 2: Sierpinski triangles
• Example 3: Mandelbrot Sets (fractals)

41. Kotlin Recursion
• What are Recursive Functions?
• Functions that are defined in terms of themselves
• Example 1: the factorial function
• Example 2: Fibonacci numbers
• Example 3: Euclid’s algorithm
• Example 4: Ackerman functions

42. Kotlin Recursion
• Add the first n integers: iterative solution
• fun main(args: Array<String>) {
• var num = 5
• var result:Int = 0
• for(i in 1..num) {
• result += i
• }
• print("The sum from 0 to "+num.toString()+" = "+result.toString()+"n")
•}
• NB: the closed form solution is n*(n+1)/2

43. Kotlin Recursion
•Add the first n integers: recursive solution
• fun main(args: Array<String>) {
• var num = 5
• var result:Int
• result = sum(num)
• print(num.toString()+" factorial = "+result.toString()+"n")
•}
•fun sum(num:Int): Int {
• if(num <= 1) return 1
• return num + sum(num-1)
•}

44. Kotlin Recursion
• Factorial function: iterative solution
• fun main(args: Array<String>) {
• var num = 5
• var result:Int = 1
• for(i in 1..num) {
• result *= i
• }
• print(num.toString()+" factorial = "+result.toString()+"n")
•}

45. Kotlin Recursion
•Factorial numbers: recursive solution
• fun main(args: Array<String>) {
• var num = 5
• var result:Int
• result = fact(num)
• print(num.toString()+" factorial = "+result.toString()+"n")
•}
•fun fact(num:Int): Int {
• if(num <= 1) return 1
• return num*fact(num-1)
•}

46. Kotlin Recursion
• Fibonacci numbers: recursive solution
• // F(0) = F(1) = 1
• // F(n) = F(n-1) + F(n-2)
• fun main(args: Array<String>) {
• var num = 5
• var result:Int
• result = F(num)
• print(" Fibonacci " +num.toString()+" factorial = " + result.toString()+ "n ")
•}
•fun F(num:Int): Int {
• if(num <= 1) return 1
• return F(num-1) + F(num-2)
•}

47. Kotlin Recursion
• Fibonacci numbers: iterative solution
• Exercise for you!

48. Kotlin Recursion
• Tail Recursion: factorial function
•fun main(args: Array<String>) {
• var num = 5
• var result:Int
• result = fact(num, 1)
• print(num.toString()+" factorial = "+result.toString()+"n")
•}
•fun fact(num:Int, prod:Int): Int {
• if(num <= 1) return prod
• return fact(num-1, num*prod)
•}