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 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.

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. 

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). 

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:

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.

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. 

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. 

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

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.

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. 

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

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.

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:

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. 


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

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

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. 

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. 

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


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

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. 

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

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. 

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:


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 Envato Tuts+.

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

Leave a Comment

Scroll to Top