Topic 1 - Introduction to Kotlin

What is Kotlin?

• A statically-typed, object-oriented and functional programming language developed by JetBrains - developers of the IntelliJ IDE which Android Studio is based on
• Compiles to Java bytecode, therefore compatible with the Java Virtual Machine
• Because of this, Kotlin code can be mixed with Java code in one application
• Main site: here
• Recommended as the preferred language to develop Android apps, so we will start the module with a look at the basics of Kotlin before beginning Android development

Some Kotlin features

• Null safety: language features to help guard against the dreaded NullPointerException!
• Type inference: type of variables can be inferred by what they are initialised to, so you don't need to explicitly declare the data type
• Lambda functions: anonymous functions which can be passed as arguments to other functions (similar to arrow functions in JavaScript)
• Data classes: concisely create classes which represent data and do not need methods
• Extension functions: add a single function (method) to an existing class without needing to subclass it
• Coroutines: a lightweight approach to multi-tasking. producing code which is easier to follow compared to threads

Hello World in Kotlin

• Here is Hello World in Kotlin:

  fun main (args: Array<String>) {
      println("Hello World!")
  }
  

• Note that in Kotlin, we do not need to create a class; we can use just functions (similar to C++)
• We have a main function, similar to the main method in Java
• fun is the keyword for a function, and println() prints to the console, just like System.out.println() in Java
• Note the different parameter syntax: main() has one parameter, args, which is an Array of Strings (representing the command-line arguments, as in Java)
• Note also that Kotlin does not use semicolons (you can use them, but it is not recommended as it is unnecessary)

Variables example

• This example shows some aspects of how variables work in Kotlin:

  fun main (args: Array<String>) {
      // Declare a as an Int. "val" means it is immutable (cannot be changed)
      val a: Int = 3
  
      // Type inference: "b" is an Int because it is initialised to an Int
      val b = 4
      
      // "c" is a "var", which means it can be changed
      var c = 5    
  
      // increase "c" by one
      c++
  
      // this would give a compiler error as "b" is immutable
      // b++
  
      // this would also give a compiler error as "c" is implicitly an Int
      //c = "A String"
  
      // Some other data types
      val d = 12345678L // Long
      val pi = 3.141592654 // Double
      val f = 1.23f // Float
      val str = "Hello" // String
  
  
      // Print them out. Note how we can embed variables in a string
      // by preceding them with '$'
      println("a is $a, b is $b, c is $c, d is $d, f is $f, pi is $pi, str is $str")
  }
  

• Note how we use val for immutable (unchanging) variables, and var for mutable variables (those which can change)
• Note how the type of a variable can be inferred by what value we assign it to, in all variables above apart from "a", we do not declare the type
• Nonetheless the variables are typed, we cannot place a String in "c", for example
• See here for details on Kotlin data types

Loops in Kotlin

• The program below shows some examples of basic loops:

  fun main (args: Array<String>) {
      // Count from 1 to 10
      for (i in 1..10) {
          println(i)
      }
  
      // Count from 1 to 9 ("until" discounts 10 itself)
      for(j in 1 until 10) {
          println(j)
      }
  
      // count from 1 to 9 in steps of 2
      for(k in 1..9 step 2) {
          println(k)
      }
  }
  

• Note the syntax 1..10. This is called a range expression. It returns a Range object representing the range of numbers 1 to 10.
• Note also the difference between the first two examples; until is a function which returns a Range from the initial number up to, but not including, the final number
  • So the second loop will only count from 1 to 9
• We also have the standard, Java-style while loop too
• See here for full documentation on loops

Conditional statements in Kotlin

• The program below shows some examples of conditional statements in Kotlin:

  fun main (args: Array<String>) {
      println("Enter your name:")
      val n = readLine()
      if (n == "Linus Torvalds") {
          println("You invented Linux")
      } else {
          println("You didn't invent Linux")
      }
  
      println("Enter your grade:")
      val grade = readLine()
      when(grade) {
          "A" -> println("First")
          "B" -> println("2.1")
          "C" -> println("2.2")
          "D" -> println("Third")
          "F" -> { 
              println("Fail")
              println("Please resit in the summer.") 
          }
          else -> println("Invalid grade $grade.")
      }
  }
  

• Note how if/else is similar to Java
• The when statement is not in Java; it is similar to switch but has some interesting additional features, see next slide
• Note the use of else inside when to handle unmatched conditions (e.g. here, if the grade is not A, B, C, D or F)

Conditional expressions

• An important difference in Kotlin compared to java is that conditionals can be used as expressions, i.e. they can return a value which can be assigned to a variable
• eg.

  fun main (args: Array<String>) {
      println("Enter your name:")
      val n = readLine()
  
      // "msg" contains the result of the if statement
      val msg = if (n=="Linus Torvalds") "You invented Linux" else "You didn't invent Linux"
      println(msg)
  
      println("Enter your grade:")
      val grade = readLine()
  
      // "degree" contains the result of the when statement
      val degree = when(grade) {
          "A" -> "First" // Return "First" when grade is "A"
          "B" -> "2.1" // Return "2.1" when grade is "B"
          "C" -> "2.2"
          "D" -> "Third"
          "F" -> "Fail"
          else -> "Invalid grade $grade."
      }
      println("Degree awarded: $degree.")
  }
  

• Note in this example how we store the result of the if statement in the variable msg
  • ...so that msg wil contain either You invented Linux or You didn't invent Linux, depending on the name typed in
• Also notice how the when statement similarly returns a value, i.e. "First" when the grade is "A", "2.1" when the grade is "B", etc.

Basic arrays, including for-in and if-in

• Arrays are available in Kotlin, like most other languages
• THe in keyword in Kotlin allows us to do foreach-style loops with arrays and easily work out if a value is in an array

• fun main (args: Array<String>) {
      val langs = arrayOf("Python", "Java", "JavaScript", "PHP", "Kotlin")
      println("Languages you are learning at university:")
      for(curLang in langs) {
          println(curLang)
      }
      println("Please enter a programming language:")
      val lang = readLine()
      val msg = if(lang in langs) "learning" else "not learning"
      println("You are $msg $lang at university.")
  }
  

• Note the use of the if statement as an expression again (if(lang in langs)...)
• Next time we will cover some additional features of arrays, and lists

Nullability

• One of the really useful features of Kotlin is null safety
• With Kotlin, you can declare a variable to either be nullable or non-nullable
• Non-nullable variables will produce a compiler error if you attempt to store 'null' in them
• Thus we can guard against the dreaded NullPointerException

Non-nullable variables

• By default, given data types (String, etc.) are non-nullable
`
• So this code will not compile, beacuse we declare s as a non-nullable String and attempt to assign null to it

  fun main (args: Array<String>) {
      var s: String = null
      println(s.length);
  }
  

• This is a better result than Java, in which the program would compile, but crash with a NullPointerException when we try to access the length...

Nullable variables

• What about cases where we want the variable to be nullable?
• For example, a collection of data which doesn't exist until we open a file and read it in from the file
• In this case, we explicitly declare the variable as nullable by adding a question-mark ? to the data type
• So, will this code successfully compile?

  fun main (args: Array<String>) {
      var s: String? = null
      println(s.length);
  }
  

The safe-access operator

• The answer is no, because even though we declared s as a nullable string, we then try to access the length of a String object which is null
• In Java this type of operation would throw a NullPointerException
• Kotlin's null-safety forces you to deal with this using the safe-access operator, ?.
• Here is the previous example, rewritten to use the safe-access operator:

  fun main (args: Array<String>) {
      var s: String? = null
      println(s?.length);
  }
  

• Here, due to the safe-access operator, we will only access the length if "s" is not null

A practical example, and introducing Elvis

• The previous example was to illustrate the nullable concept only, and obviously does not do anything interesting
• This example shows a more practical use of the safe-access operator; note that readLine() returns a nullable String (String?):

  fun main (args: Array<String>) {
      println("Please enter a number:")
      val str1 = readLine() // this might return null, e.g. if we are in a non-console environment
  
      // Elvis: Set a EITHER to the return value of toInt(), or 0 if str1 is null
      val a = str1?.toInt() ?: 0
  
      println("Please enter another number:")
      val str2 = readLine() // this might return null
  
      // Elvis: Set b EITHER to the return value of toInt(), or 0 if str2 is null
      val b = str2?.toInt() ?: 0
  
      // Note how we can embed full expressions inside strings with $
      println("The sum of the two numbers is ${a+b}");
  }
  

• This example reads in two numbers as (nullable) strings, tries to convert them to integers with the toInt() method, and prints the sum
• Note how the safe-access operator is used to call toInt() in case str1 is null
• What of the new operator, ?: though?
• This is known as the Elvis operator (why? apparently because it's the emoticon for Elvis Presley)
• In cases where we're trying to call a method (or access an attribute) of a nullable with the safe-access operator, the Elvis operator allows us to set a value for a variable normally obtained from the return value of the method in cases where the nullable is null
• So if either string (str1 or str2) is null, the corresponding Int (a or b) will be assigned the value 0 rather than the return value of toInt()
• More on nullability here.

Functions in Kotlin

• The following example shows the use of functions in Kotlin, including parameters and return types:

  fun printString(s: String, nTimes: Int)
      for(i in 1..nTimes) {
          print(s)
      }
      print("\n")
  }
  
  fun cube(number: Double) : Double {
      return number * number * number
  }
  
  fun main (args: Array<String>) {
      printString("*", 3)    
      printString("#", 4)    
      printString("!", 5)    
      println("The cube of 3 is: ${cube(3.0)}")
  }
  

• Note the syntax for parameters
  • (s: String, nTimes: Int)
  and return types
  • fun cube(number: Double) : Double)
• Note also how we can put function calls in quotes using $, and {} to contain the expression
  • println("The cube of 3 is: ${cube(3.0)}")

Classes and Objects in Kotlin

• Like Java, you can do OO programming in Kotlin
• Classes and objects work similarly to Java, but there are some differences and enhancements
• Here is a basic example (the famous Cat class...)

  class Cat (n: String, a: Int, w: Int) {
  
      // Attributes
      val name: String
      var age: Int
      var weight: Int
      
      // Init block, for performing tasks on creation of the object
      init {
          name = n
          age = a
          weight = w
      }
  
      fun walk() {
          this.weight--
      }
  
      fun display() {
          println("Name: $name Age: $age Weight: $weight")
      }
  }
  
  fun main (args: Array<String>) {
      val felix = Cat("Felix", 10, 10)
      val tom = Cat("Tom", 5, 5)
      felix.walk()
      tom.walk()
      felix.display()
      tom.display()
  }
  

• Note how we place the constructor parameters (name, age and weight) immediately after the class name - this is different to Java in which we create a constructor function inside the class body
• Note also the init block. This contains code we want to run when the object is first created. Here, we simply set the attributes equal to the constructor parameters
• The methods walk() and display() are similar to Java.

Making our class more concise - automatically setting constructor parameters equal to class attributes

• This version of the previous example is more concise:

  class Cat (val name: String, var age: Int, var weight: Int) {
  
      fun walk() {
          this.weight--
      }
  
      fun display() {
          println("Name: $name Age: $age Weight: $weight")
      }
  }
  
  
  fun main (args: Array<String>) {
      val felix = Cat("Felix", 10, 10)
      val tom = Cat("Tom", 5, 5)
      felix.walk()
      tom.walk()
      felix.display()
      tom.display()
  }
  

• Note how we specify either val or var before each constructor parameter
• This automatically makes each parameter an attribute of the class
• vals will be immutable, vars will be mutable
• Thus, unlike the previous version, we do not have to declare the attributes inside the class, or use an init block

Data classes - concisely representing complex data structures

• In many cases, we need to create classes which represent a complex data structure, but do not need methods
• A good example would be a Point class, to represent a 2D point (with x and y coordinates)
• In Java, you could do this (note how x and y are public, to avoid the need for getters and setters; an implementation which wanted to make x and y immutable would need to make them private and add getter methods):

  public class Point {
      public int x, y;
  
      public Point (int x, int y) {
           this.x = x;
           this.y = y;
      }
  }
  

• However, having to create a constructor to initialise the attributes to the constructor parameters is a pain
• In Kotlin, in an extension of the previous example, you can create a Point class with just one line of code:

  data class Point(val x:Int, val y: Int)

• That is it! This will create a Point class, with a two argument constructor (x and y), and two immutable (because of val) attributes, also x and y
• This could be used in a main() function as follows:

  data class Point(val x:Int, val y: Int)
  
  fun main (args: Array<String>) {
      val p = Point(0, 5)
      val p2 = Point(5, 2)
      println("${p.x} ${p.y}")
      println("${p2.x} ${p2.y}")
  }
  

• Much more concise code!

Introducing some more Kotlin collections

• Last time we looked at how to create simple arrays
• However, we can also use Java-style collections in Kotlin, e.g. List, HashMap
• The syntax and initialisation methods are, however, a little different
• In Kotlin, collections divide into mutable collections (those that can be altered) and immutable collections (those which cannot, which are more efficient in cases where the data in the collection never changes)

The List

• This example shows basic use of a List:

  fun main(args: Array<String>) {
      val peopleList = listOf("Mark Cranshaw", "Rob Cooper", "Al Monger", "Mark Udall", "Margaret Jones")
      for(p in peopleList) {
          println("$p was formerly a lecturer at Solent University.")
      }
  }
  

  We create a list of former lecturers at the university and use a for/in loop to iterate through each
• Note that listOf() returns an immutable list (a list of type List); this cannot be altered (e.g. it does not have an add() method)

Creating a Mutable List

• This example shows basic use of a mutable List:

  fun main(args: Array<String>) {
      val peopleList = mutableListOf("Mark Cranshaw", "Rob Cooper", "Al Monger", "Mark Udall", "Margaret Jones")
      peopleList.add("Roger Forster")
      for(p in peopleList) {
          println("$p was formerly a lecturer at Solent University.")
      }
  }
  

  Note how we use mutableListOf
• This returns an object of type MutableList, which has an add() method
• Also note that peopleList is val, not var, even though it's a MutableList
  • Even though we add new data to the list, the actual object reference peopleList (which represents the memory address of the list) does not change
  • Hence we can use a value for this example
• We can create an empty list by omitting the arguments, e.g:

  val peopleList = mutableListOf<String>()

More on Functions in Kotlin

• In Kotlin, functions can be stored in variables and passed as arguments to other functions
  • In this respect, Kotlin is similar to JavaScript
• This property of functions makes them first class (see the Kotlin documentation)
• This can allow for some powerful programming techniques, e.g. operating on all members of an array or list using a function, allowing us to adopt a functional programming style
• ..or, allowing us to pass a function as a callback to another function, helping this function become more loosely-coupled

Anonymous Functions

• An anonymous function is a function with no declared name after the fun keyword
• Anonymous functions can be passed in as arguments to another function, or referred to via variables
• Here is a basic example of an anonymous function, referred to by the variable funcReference here:

  fun main(args: Array<String>) {
      val funcReference = fun(i: Int): Int { return i*i*i }
      println(funcReference(3))
      val secondRef = funcReference
      println(secondRef(4))
  }
  

• Note how we set funcReference equal to a function which has one Int parameter, returns Int and calculates and returns the cube of the number
• funcReference is a reference to this anonymous function
• We can use this reference to call the function
• Notice how we can also set up a second reference (secondRef here) to the function, and use that to call it

Passing functions as arguments to other functions

• In Kotlin, we can pass functions as arguments to other functions
• The parameter type for a function passed into another is:

  (ParamType1, ParamType2, ParamType3...) -> returnType

  where ParamType1, ParamType2, ParamType3 etc. are the parameter types for the function being passed in, and returnType is the return type of that function
• This is probably better explained via example, so here is one:

  fun main(args: Array<String>) {
      val cubeFunction = fun(i: Int): Int { return i*i*i }
      execFunction(cubeFunction)
  }
  
  fun execFunction ( f: (Int) -> Int) {
      println(f(3)) // call the function passed in with an argument of 3, i.e. the cube of 3 will be calculated
  }
  

  Note that we pass cubeFunction in as an argument to execFunction
• The corresponding data type of the parameter, f, is (Int) -> Int, to indicate that the function being passed in takes one Int and returns an Int
• If the function being passed in returns nothing, we specify Unit as the return type, e.g:

  fun main(args: Array<String>) {
      val printStars = fun(i: Int){ 
          for(count in 1..i) {
              print("*")
          }
          print("\n")
      }
      execFunction(printStars)
  }
  
  fun execFunction ( f: (Int) -> Unit) {
      f(3)// call the function passed in with an argument of 3, i.e. three stars will be printed
  }
  

  This time we pass in a function which prints a given number of stars, but does not return anything, hence specifying Unit as the return type of the function passed into execFunction

Lambda functions

• Lambda functions are similar to ordinary anonymous functions but use a special, concise syntax
• Here is the first example rewritten to use a lambda function:

  fun main(args: Array<String>) {
      val cubeLambda: (Int) -> Int =  { i -> return i*i*i }
      println(cubeLambda(3))
  }
  

• Note how we write a lambda: we enclose the whole function (the parameters as well as the function body) in braces { }, and separate the parameters and the function body with the -> token
• Note how we have to specify the type of the lambda:

  val cubeLambda: (Int) -> Int

  This is because we do not specify the parameter types in the lambda, therefore we have to specify the type of the variable holding it
• Note how in our case, the lambda only has one statement (return i*i*i), but they can actually have multiple statements, one statement per line; e.g.

  val someLambda: (Int) -> Int = { parameter->
      statement1
      statement2
      return someValue
  }
  

• See the Kotlin documentation for more details

Making the lambda more concise - I

• We can make the previous version more concise
• With lambdas, the value declared in the last line is always automatically returned
• So the code below will also have the same effect as the previous example:

  fun main(args: Array<String>) {
      val conciseCubeLambda: (Int) -> Int =  { i -> i*i*i }
      println(conciseCubeLambda(3))
  }
  

  Because the last statement of the lambda is always returned, and that last statement here is i*i*i, it follows that i*i*i will be returned from the lambda in this example, and the desired effect of returning the cube will be achieved

Making the lambda more concise - II - the implicit "it"

• It doesn't stop there!
• In cases in which a lambda has just one parameter - a common situation - we can refer to that one parameter implicitly using the keyword it
• Thus, we can rewrite the cube example as follows:

  fun main(args: Array<String>) {
      val cubeLambdaWithIt: (Int) -> Int =  { it*it*it }
      println(cubeLambdaWithIt(3))
  }
  

  Because the it parameter always corresponds to a single argument passed in (3 in this example), and because the value of last statement of a lambda is always returned, it follows that this example will also calculate the cube of the argument passed into the lambda

Real-world use of lambdas

• A very common real-world use of lambdas is to write code in a functional style
• A typical pattern in functional code is to apply a given function to all members of an array, list or map
• This leads to more readable, intuitive code with the details of looping through the collection hidden away
• Collections (lists, maps) have a range of functions (methods) which apply a lamda to some or all members of the collection
• The simplest is forEach(), which applies a lambda to all members of a collection:

  fun main(args: Array<String>) {
      val peopleList = listOf("Mark Cranshaw", "Rob Cooper", "Al Monger", "Mark Udall", "Margaret Jones")
      peopleList.forEach { person -> println(person) }
  }
  

• Note how the forEach() method of the list takes a lambda as an argument
• The lambda will be applied to all members of peopleList, with each person in turn being passed into the lambda as the person parameter
• The result, therefore, will be that each person will be printed
• Note also how we can omit the parentheses () when passing in a lambda as the first argument to a function

Question

• How can we make

  peopleList.forEach { person -> println(person) }

  more concise?
• Answer will be given out in class!

Further reading

I have prepared some notes on additional basic Kotlin topics, including inheritance and map data structures. We may be able to cover these at the start of the lab session. If not, please read the notes here.