1. Variables

In Kotlin, we 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 = "Opeyemi" //  this is similar to -> final String firstName = "Opeyemi" <- Java

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 = "Olorunleke" // 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 ((its value cannot be changed or read-only), while the latter is mutable (its value can be changed).

val dateOfBirth = "29th March, 1709"
dateOfBirth = "25th December, 1600" // won't compile because value 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. trying to put a String into an Integer decleration

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 multi threading, 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 (only once). But you can still only assign a value once.

val carName: String
carName = "Toyota Matrix" // will compile
carName = "Maybach" // won't 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

// these 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 // tyoe is also inferred by compiler

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

Numbers

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

val myNumberAgain1: Long = myNumber.toLong() // this will compile

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()
val oneX = intValue[0].toInt() // will give wrong value. toInt() functions work effectively with Strings
val oneY = intValue[0].toString().toInt() // we get the 1st character '1' convert it to string the convert it to Integer

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 // 1 is less than 6 AND 6 is greater than 4, therefore  n is true

Strings

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 message1 = "to use the dollar sign do this ${"$"}" //to use the dollar sign do this $
val name = "Opeyemi"
val message2 = "The first letter in my name is ${name.first()}" // The first letter in my name is O
val message3 = "The first letter in my name is ${name[0]}" // The first letter in my name is O

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

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

Arrays

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, 7000L, 3.01f, "Olorunleke","Opeyemi", false)

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

val myArray3 = arrayOf(4, 5, 7, 3, "Chike", false) // this will 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.

You can Read More at >> https://code.tutsplus.com/tutorials/kotlin-from-scratch-variables-basic-types-arrays-type-inference-and-comments–cms-29328

Leave a comment