Functions in Kotlin are declared with the fun keyword. Following the keyword comes the function name, then parentheses, which contain optional function parameters. In Kotlin, return type comes at the end of the function definition, after a colon.

Here's a function in Kotlin that adds two numbers and returns the result:

fun add(a: Int, b: Int): Int {
    val result: Int = a + b 
    return result
}

This function accepts two parameters of type Int (32-bit integer), has a local variable of type Int, and also returns an Int.

If you are familiar with Java, you might have noticed that types of parameters and local variables come after their name. In Java their type declaration comes first.

Calling this function would look like this:

val result: Int = add(1, 1)

In Java, every declaration, such as a field or a function, has to be inside a class. Kotlin doesn’t have...

Local variables can be declared in two ways: first, with the val  keyword, then they are immutable (the variable cannot be reassigned). If you are coming from Java, val would be equal to variables declared with a final keyword.

Secondly, you can declare a local variable with a var keyword; then it is considered mutable and the value can be reassigned after a declaration.

The following command demonstrates that it will not compile, because the bar local variable cannot be reassigned:

fun immutable() {
   val bar: String = "Kotlin"
   bar = "Kotlin is awesome" // compiler error
}

And, when declared with var, the compiler allows a local variable to be reassigned:

fun mutable() {
   var bar: String = "Kotlin"
   bar = "Kotlin is awesome" 
}

You should favor immutable variables. The compiler will...

Local functions are functions declared inside a function. They are also called nested functions. They are popular in scripting languages, but some other modern Object-Oriented languages, like Scala, Swift, and C# (since 7.0) also have them. One of the uses of local functions is code reuse. You can extract a piece of code that is repeated inside a local function so the code can be reused:

fun printUserDetails(user: User) {
    fun tryPrint(str: String) {
        if (str.length > 5) {
            println(str)
        } 
       else  {
            println("I print strings with more than 5 characters")
       }
    }
    tryPrint(user.firstName)
    tryPrint(user.lastName)
    tryPrint(user.address)
}

You can see how the function tryPrint is declared inside the printUserDetails function.  We can call the nested function just as we would a normal function...

Declaring types in Kotlin is optional. This is a feature of a Kotlin compiler called Type inference. The compiler can infer the type from the context of the usage. Kotlin is a strongly and statically typed language, so omitting types doesn’t mean that you lose type safety. 

Here’s an example of type inference:

val str = "Kotlin"

str variable is of type String and the compiler knows this from the String literal that is initializing the variable. That’s why, if you try to assign a different type to this variable, you'll get a compiler error, as can be seen in the following:

var str = "Kotlin"
str = 1 // compiler error

Type inference doesn’t just work on local variables, but also on functions with expression bodies, generic types, closures and lambdas. You’ll see more type inference in practice in following...

If you are familiar with Java, then you probably know that Java has primitive (value) types and reference types.

The differences between them are that primitive type variables store the actual value of the type in their memory location (usually on the Stack) and reference type variables store the reference (memory address) to another memory location (on the Heap) where the actual data is stored.

Primitive types in Java also have their Boxed (Boxing is an automatic conversion of a primitive type to a reference type) version, a reference type. For example, a primitive int (32-bit integer) has a reference type in type Integer.

Kotlin doesn’t have this distinction between primitive and reference type. This doesn’t mean a Kotlin compiler cannot emit primitive types in Java bytecode. In fact, it would be really inefficient if Kotlin had only reference...

When you want to state that a reference type doesn’t point to a memory address, you can assign it a null value. If you have ever used Java, you probably experienced the NullPointerException fail, as it is one of the most common errors. This error is raised by the runtime when you dereference a null variable.

This decision, to have nulls in Java, is criticized a lot and is also sometimes called  a Billion Dollar mistake. The introduction of the optional type in Java 8, tries to address this problem.

Kotlin tries to prevent these mistakes with supporting nullability in its type system. With nullable types, Kotlin tries to prevent null pointer errors during compilation and reduce the possibility of null pointer errors during runtime.

All types in Kotlin can be nullable, and only then can they have a null value assigned. Nullable types are declared with...

To cast from one type to another, Kotlin uses the as keyword. Here’s how you would cast Any type to an Int type:

fun casting(any: Any) {
    val num = any as Int
}

During runtime, before casting, the JVM will check if the source type can be cast to target type. If not, ClassCastException will be thrown.

There is also the safe casting operator, as?. This operator checks, before casting, whether or not types are compatible. If they are, then it works as a normal asoperator. If not, a null value is assigned. Notice how in this example, the local variable num has to be declared as a nullable type:

fun safeCasting(any: Any) {
    val num: Int? = any as? Int
}

Safe casts can be used with all other null...