Kotlin From Scratch: Variables, Basic Types, and Arrays

Kotlin is a modern programming language that compiles to Java bytecode. It is free and open source, and promises to make coding for Android even more fun.

Kotlin From Scratch: Variables, Basic Types, and Arrays

Kotlin is 100% interoperable with Java. In other words, it can be used together with Java in the same project. So you can refactor parts of your Java code to Kotlin and it won’t break. In addition to that, it is concise, expressive, and has great tooling. Kotlin can be used on the back-end (server-side), but it’s getting a lot of attention right now as a language for Android app development. Kotlin is now supported by Google as a first-class language for Android development, so the popularity of Kotlin is set to explode!

In this first tutorial in the Kotlin From Scratch series, you’ll learn about the language basics: comments, variables, simple types, arrays, and type inference.


To follow along with me, you will need the Kotlin plugin on Android Studio. Alternatively, you could use the online playground or IntelliJ IDEA Community Edition.

1. Variables

In Kotlin, use val to declare a constant or var keywords to declare a variable. You can specify a type such as String or Int after the variable name. In the example below, we declared a constant firstName of type String with the val keyword.

val firstName: String = "Chike" 

But you’ll soon realize that in Kotlin, it’s often possible to omit the type from the declaration and the compiler won’t complain.

val lastName = "Mgbemena" // will still compile

In the code above, you’ll observe that we did not explicitly state the type String. The code above will still work because the compiler has implicitly inferred the type using type inference. We’ll come back to this!

The difference between the val and var keywords is that the former is immutable or read-only (its value cannot be changed), while the latter is mutable (its value can be changed).

val dateOfBirth = "29th March, 1709" 
dateOfBirth = "25th December, 1600" // cannot be changed

var car = "Toyota Matrix"
car = "Mercedes-Maybach" // can be changed

Note that for a variable declared with the var keyword which has its type inferred by the compiler, assigning another value of a different type won’t work. In other words, the value of the variable can change, but its type cannot! For example:

var age = 12
age = "12 years old" // Error: type mismatch

It is highly recommended that you start by making your variables immutable by declaring them with the val keyword, so as not to maintain too many states. This makes your code safer for multithreading, because it ensures your variables cannot be modified by other threads unexpectedly.

Another thing you should know about the val keyword is that you can declare it with a type only and assign it a value later. But you can still only assign a value once.

val carName: String
carName = "Toyota Matrix" // will compile

In Java, it’s possible to declare multiple variables of the same type on a single line, but this doesn’t work in Kotlin. In Kotlin, all variable declarations must be on their own lines.

val carName = "BMW", streetName = "Oke street" // this won't compile

// this will compile
var carName = "BMW"
var streetName = "Oke street"

2. Type Inference or Deduction

Kotlin is a strongly typed language that supports type inference or deduction. This is the mechanism employed by the compiler to find out types from context. Java doesn’t have a type inference mechanism, which means you must explicitly declare the type of every function or variable. Type inference helps reduce the boilerplate code you have to write.

val country = "Nigeria" // type is inferred by compiler
val code = 234

The code above would compile even though we did not explicitly state the type for the variable country. The compiler is smart enough to know that the country is of type String, because the value, “Nigeria”, is a string.

3. Basic Types

In Java, we have two types of type—primitive (e.g. int, long, boolean, byte, char, etc.) and reference types (e.g. array, String). Java uses wrappers (like java.lang.Integer) to make primitive types behave like objects. But in Kotlin, there is no such distinction. Instead, all types are objects.


The integer types available in Kotlin are:

  • Long—64 bit
  • Int—32 bit
  • Short—16 bit
  • Byte—8 bit

The floating-point types are:

  • Double—64 bit
  • Float—32 bit
val myInt = 55
val myLong = 40L
val myFloat = 34.43F
val myDouble = 45.78
val myHexadecimal = 0x0F
val myBinary = 0b010101

You can observe that we created a Long literal by adding the suffix L, and for Float we added the suffix F or f.  Numbers can also be written in hexadecimal notation using the 0x or 0X prefix and in binary using the 0b or 0B prefix. Note that in all these cases, Kotlin can use type inference to know the type we want instead.

val myLong = 19L
val myLongAgain: Long = 40

To convert a number from one type to another, you have to explicitly invoke the corresponding conversion function. In other words, there is no implicit conversion between types of numbers.

val myNumber = 400
val myNumberAgain: Long = myNumber // throws Error: Type mismatch

Each number type has helper functions that convert from one number type to another: toByte(), toInt(), toLong(), toFloat(), toDouble(), toChar(), toShort().

val myInt = 987
val myLong = myInt.toLong()

In the code above, we are converting from an integer to a long. We can also do the reverse by using the method toInt() on the long variable. Note that this will truncate the value to fit the smaller size of an Int type if need be—so be careful when converting from larger types to smaller ones!

You can also convert a String into a number type.

val stringNumber = "101"
val intValue = stringNumber.toInt() 

In the code above, we converted the variable stringNumber into an Int type by calling the method toInt() on the variable. We can write this more succinctly by instead calling the method directly on the string:

val intValue = "101".toInt()

The Boolean Type

The Boolean type in Kotlin is the same as in Java. Its value can be either true or false. The operations disjunction (||), conjunction (&&), and negation (!) can be performed on boolean types, just like Java.

val myTrueBoolean = true
val myFalseBoolean = false

val x = 1
val y = 3
val w = 4
val z = 6

val n = x < z && z > w // n is true


Strings can be created with either double quotes or triple quotes. In addition to that, escape characters can be used with double quotes.

val myString = "This is a String"
val escapeString = "This is a string with new line n"

To create a string that spans multiple lines in the source file, we use triple quotes:

val multipleStringLines = """
        This is first line
        This is second line
        This is third line """

Kotlin also supports string interpolation or string templates. This is an easier way to build dynamic strings than concatenation, which is what we use in Java. Using string templates, we can insert variables and expressions into a string.

val accountBalance = 200
val bankMessage = "Your account balance is $accountBalance" // Your account balance is 200

In the code above, we created a string literal, and inside it, we referred to a variable by the use of a $ character in front of the variable name. Note that if the variable is not correct or doesn’t exist, the code won’t compile.

What about if you need to use $ in your string? You just escape it with $! Also, you can call methods from an interpolated String directly; you have to add curly braces ${} to wrap it.

val name = "Chike"
val message = "The first letter in my name is ${name.first()}" // The first letter in my name is C

Another cool thing you can do is to perform some logic inside the curly braces when creating a String literal.

val age = 40
val anotherMessage = "You are ${if (age > 60) "old" else "young"}" // You are young


In Kotlin, there are two main ways to create an array: using the helper function arrayOf() or the constructor Array().

The arrayOf() Function

For example, let’s create an array with some elements using arrayOf().

val myArray = arrayOf(4, 5, 7, 3)

Now, to access any of the element, we can use its index: myArray[2]. Note that we can pass in values of different types into the arrayOf() as arguments and it will still work—it will be an array of mixed type.

val myArray = arrayOf(4, 5, 7, 3, "Chike", false)

To enforce that all the array values have the same type, e.g. Int, we declare a type by calling arrayOf<Int>() or intArrayOf().

val myArray3 = arrayOf<Int>(4, 5, 7, 3, "Chike", false) // will not compile
val myArray4 = intArrayOf(4, 5, 7, 3, "Chike", false)  // will not compile

We also have other utility functions to create arrays of other types such as charArrayOf()booleanArrayOf()longArrayOf()shortArrayOf()byteArrayOf(), and so on. Behind the scenes, using these functions will create an array of their respective Java primitive types. In other words, intArrayOf() will compile to the regular Java primitive type int[], byteArrayOf() will be byte[], longArrayOf() will be long[], and so on.

The Array() Constructor

Now let’s see how to create an array with Array(). The constructor of this class requires a size and a lambda function. We’ll learn more about lambda functions later in this series, but for now, just understand that it is a simple, inline way of declaring an anonymous function. In this case, the job of the lambda function is to initialize the array with elements.

val numbersArray = Array(5, { i -> i * 2 })

In the code above, we passed 5 as the size of the array in the first argument. The second argument takes in a lambda function, which takes the index of the array element and then returns the value to be inserted at that index in the array. So in the example above, we created an array with elements 0, 2, 4, 6, and 8.


This is an easy one. In Kotlin, comments are just the same as in Java. We can use either block or line comments:

 hello, this is a block comment
 with multiple lines.
 This is another line.
 This is another one again

// this is a single line comment


In this tutorial, you learned the basics of the Kotlin programming language: variables, basic types, type inference, arrays, and comments. In the next tutorial in the Kotlin From Scratch series, you’ll learn about loops, ranges, conditions, collections, and packages in Kotlin. See you soon!

To learn more about the Kotlin language, I recommend visiting the Kotlin documentation. Or check out some of our other Kotlin tutorials here on ThemeKeeper Tuts+.

  • Kotlin From Scratch: Variables, Basic Types, and Arrays
    Android SDK
    Quick Tip: Write Cleaner Code With Kotlin SAM Conversions
    Ashraff Hathibelagal
  • Kotlin From Scratch: Variables, Basic Types, and Arrays
    Android Studio
    Coding Functional Android Apps in Kotlin: Getting Started
    Jessica Thornsby
  • Kotlin From Scratch: Variables, Basic Types, and Arrays
    Android SDK
    Java vs. Kotlin: Should You Be Using Kotlin for Android Development?
    Jessica Thornsby