History

announced in 2011.
1.0 release was in 2016
become first-class citizien in android eco system 2016
Version 1.2 Nov 2017

Philosophy of Kotlin

a statically typed language for multiple applications.

Concise

less code, boilerplates, keywords.
generates code that explicity written with Java.
Semicolon is not required !!.

Safe

null check
auto-detecting of variable type.

Interoperable

Kotlin/JVM can be mixed with Java or any JVM lang.
code works with JVM and Browser(Kotlin/JS).

Tool friendly

supported with Intelij IDEA and Android Studio.

Kotlin & Byte Code

For Java
- each class compiles into a .class bytecode file which depend on classes that are in JRE which we sure it exists.
- file containsonly one pulblic class
For Kotlin
- Starting Application for CLI not like a class but is top-level file that doesnot contain class keyword and must contain main method.
- this file is compiled also into .class file as JVM need it
- as we can not assume kotlin is installed on user machine so we write java Mainkt --classpath kotlind-stdlib.jar ....
- every class is compiled into .class

Keywords

divided into two categories:-

Hard Soft

is reserved all time and in all places reserved in some scopes

val, val, fun, class, interface,.. etc catch (in try clause), import, init , set , constructor, ..etc
Modifier keywords : are words that modifie hard keywords such as open, data, etc

Hard	Soft
is reserved all time and in all places	reserved in some scopes
val, val, fun, class, interface,.. etc	catch (in try clause), import, init , set , constructor, ..etc

Variables

are data container
declared using val, var as var a = 10

val var

immutable data (can not changed) mutable data

must be have intial value not neccessary
can write type or let kotlin infer it so var a = 10 and var a : Int = 10 are same.

val	var
`immutable` data (can not changed)	mutable data
must be have `intial value`	not neccessary

kotlin not auto casting for varibles so

var a = 10 
var b  : Long = a // will raise error although int is smaller than long.
var b  : Long = a.toLong() // Solution

for convention names start with lower case and use camel case for multiple words.
for a constant variable we use
```
companion object {

   const val FIXED_VAL = 100 
}
```
NOTE : should be all upper, use _ for multpile words, val as it immutable
Every thing is class so int, short and other data types are classes that has functions such as (plus, times, toInt, toLong, rem, ..etc).
important point:

a++ a.inc()

a is increamented a increamented but to a new variable so a valuenot changed
when comparing values use == rather than .equals as first one use less code when be compiled as == compiler evalute it at compile time.

a++	a.inc()
a is increamented	a increamented `but to a new variable` so a value`not changed`

String

an array of characters.
can be literal or object val a = String() // accept array of character, bytes. , but val a = String("Hello") is Worng.
there are some useful functions such as indexOf, substring, get(int).
Strings are immutable so when change value kotlin create objects in background so use StringBuilder as same as in Java.

Constants

val a = "RED"	const val a = "RED"
converted into`private static final String a = "RED";`	converted into `public static final String a = "RED";`
also create a get Function	does not create and value is evaluted at compile.
slow	fast

we create a class for constants as follows

class Constants {
    companion object {
        const val A = "A"
        @JvmField val B = "B"
    }
}
// use them as 

println(Constants.A)
println(Constants.B)

Constants.A will be replace at compile time into A
Constants.B will remain same.
so first one is faster than second one.

Function

unit that help us reuse code
same as Java but differs as it can be written outside a class as top-level.

Syntax

fun main(args: Array<String>) {

    // we can use any arrangment of params as we use named one.
    // also op param is by default '+' 
    val res = calc(param2 = 12 ,param1 =  8) // res = 20
    print(res)

}

fun calc (param1 : Int ,param2 : Int , op : String = "+" ): Int{
    when (op){ // is same as switch in Java 
        "+" -> return  param1 + param2
        "-" -> return  param1 - param2
        else -> return -1
    }
}

we notice
- support named argument
- support default values

Manage Null

here are code with different cases

    var a : String? = null
    println(a) // print null
    println(a?.length) // print null, you can not use a.length as a is nullable  
    println(a?.length ?: -1 ) // print -1 (Elvis operator )
    println(a!!.length) // Cause Kotlin NuLLPointerException.u can use try-catch to handle it

println(a?.length) is equiv to as check first if it equal to null it print null otherwise print value of length.
println(a?.length ?: -1 ) same as last but provide a value instead of 'null'
println(a!!.length) enforce call to length and handle exception by yourself.

Iterate over Collection

fun main(args: Array<String>) {

    val arr = arrayOf(1,2,3,4,5)

    for(item in arr){
        println(item) // print each item in a new line
    }

    // until stop at max -1 (i.e max is excluded)
    for (index in 0 until arr.size){
        println(arr.get(index))  // print each item in a new line
    }

    // indices return array of index, step 2 means to update each iteration with 2 
    for(index in arr.indices step  2 ){
        println(arr.get(index))
    }
}

output for first two codes is same 1 2 3 4 5.
last code output is 1 3 5.

Exception

we use try/catch to handle exception and provide useable solution to it.
kotlin does not support checked exception the reason it does not want to delgate exception handling outside this scope(i.e handle it by yourself) so no throws keyword exists.
all exception inherit from Throwable class.

Create Library

we can write functions and wrap them into class to be used from one place
we create a seperate class
write all functions inside companion object

Example:-

class MathLib{
    companion object {
        fun add (param1 : Int, param2 :Int): Int{
            return param1.plus(param2)
        }
    }
}

Class

new data type, template, blueprint for object
declared keyword class
it must has a primary constructor
it may contains serveral constructors but must each one call primary one
decalre secondary constructor by keyowrd constructor
init block is called after calling to primary constructor used to make intial configuration.
Note functions are by default are final so can not be overidden.

Example:-

class Student(var name:String, private var _age: Int) {

    // this is a secondary constructor, it must call primary one
    constructor():this("na" , 10){
        println("Called from secondary ")
    }

    // is called after calling to primary constructor
    init {
        name = name.toUpperCase()
        println("Promary is called ")
    }

    // make another one, provide a get and set
    var age : Int = _age
    get() = field
    set(value) { field = value}
    
}

to add some Encapsulation we decalre some variable with private that make var visible only inside its class and provide set , get for public use

Mix Kotlin & Java

Kotlin can use Java classes to do things that not provided yet in Kotlin or it may require more code
for example Kotlin does not have concurrency formating so you must handle it explicity (i.e code to add symbol, code to decide local and write suitable symbol).

Expamle:-

    val value = 22
    println("It costs ${value}$")

    
    Locale.setDefault(Locale.US)
    val formater : NumberFormat = NumberFormat.getCurrencyInstance()
    println("It costs ${formater.format(value)}")

  
    Locale.setDefault(Locale.FRANCE)

    val formater2 : NumberFormat = NumberFormat.getCurrencyInstance()

    println("It costs ${value}€")
    println("It costs ${formater2.format(value)}")

here formater is reponsible of determine suitable currency symbol based on Local

Packages

used to orgianze related classes, interface in one place
use package keyword.
By opposite of Java, Kotlin allow packages to be not like directory structure.

Collections

Koltin provide fixed-size collection (Array) and non fixed-size (list, set,map).
Array is a class in Kotlin
if it contains mixed types its type will be Any

we can create array with a variety of methods

// create array of values (here are of type Any as types are mixed )
val  arr = arrayOf("10", 12 , 13 , 14 )
// helper method create nulls of specified type, accept size 
val  arr1Null = arrayOfNulls<String?>(10)
// // create array of integer values
val  arr1 = intArrayOf(22 , 10 )

for(element  in arr) println("Value is $element" )
// will dislay null 10 times. 
for(element  in arr1Null) println("Value is $element" )
for(element  in arr1) println("Value is $element" )

arr1.sort()
for (item in arr1) println(item) // 10 22  
arr1.sortedArrayDescending()
for (item in arr1) println(item) // 22 10

Note :- sort() change arr content, but sortedArrayDescending() return a new obj.

List, Set, Map comes with two version Mutable, Immutable.
List is same as Array but with facilty of adding and removing items.
Sets areun-ordered unique elements.
Map is a key-value data structure which store data chained with a key.
Example:-

    // this is Immutable list so can not add/remove from it
    val list = listOf("Ahmed" , "Mahmoud")
    // this is mutable list
    val mulList = mutableListOf("Ahmed" , "Mahmoud")
    mulList.add("Hafez")
    mulList.add(0 , "Hassan")
    mulList.remove("Ahmed")
    println(mulList) // [Hassan, Mahmoud, Hafez]

    // this is Immutable Set so can not add/remove from it
    val set = setOf(1,2,3,2,4,5)
    // this is mutable Set
    val mulset = mutableSetOf<Int>(1,2,3,2,4,5)
    println(mulset) // [1, 2, 3, 4, 5] NOTE 2 is displayed only one time

    // this is mutable Map
    val map = mutableMapOf(Pair("Ahmed" , 22) , Pair("Mahmoud" , 23))
    // put is used to add Pairs(Key , Value)
    map.put("Hassan" , 21 )
    // display values is by calling get(key) or use this trick
    for ((name , age) in map) println(" name : $name and Age is $age")

Note listOf<>() in angle brackets we can write type or let Kotlin to determine it.

Inheritance

its a semi analogy to human nature there are Parent and Child.
class must be open to be inherited (by default classes are not open).
base class is Any is like Object at Java (all classes inherit from it).
Example:-

open class Animal (val color: String) {
    fun walk(){
        println("I am Walking")
    }

    override fun  toString(): String {
        return "Animal with ${color}"
    }
}

class Dog(color: String) : Animal(color ){

    override fun  toString(): String {
        return super.toString() + this::class.simpleName
    }
}

Interface

It is a contract.
It is same as Java.
concrete class must implement functions, member of interface.
class can implement multiple interfaces but if two or more interface contain same function a conflict occurs.

Code:-

fun main(args: Array<String>) {

    val lol = Retriever()
    val moly = Sealer()

    makeSpeak(lol)
    makeSpeak(moly)
    // make an anonymous object 
    makeSpeak(object : Cat {
        override fun speak() {
            println("Anonymous")
            super.speak()
        }
    })


}

fun makeSpeak(cat : Cat){
    cat.speak()
}

interface Cat {
    fun speak(){
        println("Cat")
    }
}

interface Lion {
    fun speak(){
        println("Lion")
    }
}

class Retriever : Cat , Lion {
    override fun speak() {
    //  super.speak() // error, conflict there several implementation
        super<Cat>.speak()
        println("Retriever ")
    }
}

class Sealer : Cat , Lion {
    override fun speak() {
        super<Lion>.speak()
        println("Sealer ")
    }
}

/*
Output:-
Cat
Retriever 
Lion
Sealer 
Anonymous
Cat
*/

Notes

class can implement several interface but can face conflict when two or more interface have same method like speak and try to call super.speak which will raise error so Solution with super<Cat>.speak()
Kotlin interfaces can have default implementation
makeSpeak is example of using polymorphism as it accept any obj from type of Cat as it run with sealer, retriever which are if type Cat
we use Anonymous object which in it we do not need to a named variable to hold object just implement it at function and function will call object functions
- to understand it more we write object : Cat {} it seems as we create a concreate class that implements Cat and make object from it.
Anonymous object can be decalred with a concise syntax using lambda expression

Lambda Expression

we can replace functions or anonymous object with lambda.

with a concise syntax for example

    val sayHallo = {
    name : String, age : Int ->  println("hello $name and age $age")
    }

    sayHallo("Ahmed" , 21 )
    sayHallo.invoke("Ahmed" , 21 )

    println(sayHallo::class.simpleName)
    
    val arr = arrayOf("Ahmed" , "Mohamed" , "Ali")
    // item represent a element from array is sent as parameter to sorted by
    val sorted = arr.sortedBy { item : String -> item.length }
    println(sorted)
    // use it as we expect only one paramter
    val filtered =   arr.filter { it.startsWith("A")}
    println(filtered)

    /*
    Output:- 
    hello Ahmed and age 21
    hello Ahmed and age 21
    sayHallo$1
    [Ali, Ahmed, Mohamed]
    [Ahmed, Ali]
    */

Note

sayHallo is treated as object.
with sayHallo::class.simpleName it prints sayHallo$1 indicates its of type sayHallo
sortedBy expect a Predicat that accept a string and return a value to sort based on it.
if we expect only one paramter we can use it as in arr.filter { it.startsWith("A")} filter used to select items based on selection criteria passed as lambda.

data class

It works as POJO (Plain Old Java Object) class used as model class.
just use data keyword before class and provide properties as primary constructor.
it generates setter, getter, toString, hashCode methods by default.

Example:-

data class Item (var name : String ,
                var price : Float  )

abstract & sealed class

sealed class used as abstract class in Java to provide a hierrachy a common class.
sealed class and its sub must be in same code file

Code:-

fun main(args: Array<String>) {

    val item1 = Shirt( "XL",21.4 )
    val item2 = Paints( "XX",25.4 )

    val mostexpensive = if (item1.price > item2.price) item1 else item2

    val instriction = when(mostexpensive){
        is Shirt -> "Button it!"
        is Paints -> "Buckle it!"
    }

    println(instriction) // Buckle it! 
}

sealed class ClothingItem (val type:String){
    abstract val size:String
    abstract val price:Double
}

data class Shirt(override val size: String,
                override val price: Double) : ClothingItem("Shirt")

data class Paints(override val size: String,
                override val price: Double) : ClothingItem("Paints")

Note: in when statement if you not write all cases of sealed class or provide else so compiler will raise an error as compiler all types of sealed class.

Thanks to Allah, last update 23/9/2019