kotlin_tips_part1.md

kotlin_tips.md

Which is a new programming language that is a pragmatic, safe,concise, and interoperable alternative to Java.With Kotlin, you can implement your projects with less code, a higher level of abstraction, and fewer annoyances

Kotlin is concise, safe, pragmatic, and focused on interoperability with Java code. It can be used almost everywhere Java is used today - for server-side development,Android apps, and much more. Kotlin works great with all existing Java libraries and frameworks and runs with the same level of performance as Java.

This allows for shorter code and greater flexibility in creating data structures.But the downside is that problems like misspelled names can’t be detected during compilation and lead to runtime errors.

The ability of the compiler to determine types from context is called type inference.

Performance - Calling methods is faster because there’s no need to figure out at runtime which method needs to be called.

Maintainability-Working with unfamiliar code is easier because you can see what kind of objects the code is working with.

The most important of those is Kotlin’s support for nullable types.Which lets you write more reliable programs by detecting possible null pointer exceptions at compile time.

Kotline is functional programming language.

First-class function: You work with functions as values. You can store them in variables,pass them as parameters, or return them from other function.

Immutability: You work with the immutbale objects, which guarantees that there state can't change after their creation.

No side effects: You use pure functions that return the same result given the same inputs and don't modify the state of other object or interact with outside world.

What benefits can you gain from writing the code in the function style?

1.Conciessness: Working with functions as value gives you much more power of abstraction, which lets you avoid duplication in your code. Imagine that you have two similar code fragment that implement similar task but different in details. You can easily extract the common part of logic into a function and pass the differing parts as parameters. Those parameters are themselves functions but you can express them using a concise syntax for functions called lambda expressions:

fun findAlice() = findPerson{ it.name= 'Alice' }

fun findBob() = findperson{ it.name='Bob'}

2.Safe Multithreading:One of biggest sources of errors in multithreaded programs is modification of same data from multiple threads without proper synchronization. If you use pure function and immutable data structure, you can sure that such unsafe modifications won't happen.

3.Easier Testing: Code without side effects is usually easer to test. Functions can be tested in isolation without requiring a lot of setup cpde

Default Name and Parameters.

This is something new and that is not present in java.

fun main(args: Array<String>){
    var finalAmt = calAmount(1000);
    println(finalAmt)
}

fun calAmount(amount: Int) : Int{
    return (amount + amount * 0.4//<-- interest rate).toInt(); // kotlin to convert the double in Int.
}

OutPut: 1400

In the same example 0.40 is interest rate of amount. In case of to make it dynamic we can take it as parameter.

fun main(args: Array<String>){
    var finalAmt = calAmount(1000,0.40)

    println(finalAmt)
}

fun calAmount(amount: Int, interestRate : Double) : Int{
    return (amount + amount * interestRate).toInt();
}

Now a magic happen here you can see in below code the parameter has default value hook so incase we are not passing the value from calling place it will take as default value.

fun main(args: Array<String>){
    var finalAmt = calAmount(1000,0.30) // here we explicitly pass the dynamic rate that will override the default value.

    println(finalAmt)
}

fun calAmount(amount: Int, interestRate : Double = 0.40) : Int{ 
// Notice: Here you can see the default parameter that is directly assign.
    return (amount + amount * interestRate).toInt();
}

Output: 1300

Now the same concept in java we call it method overloading because name of function remain same but it is different by its parameter. The same logic in java we need to create a two function with single and double argument but in kotlin by default function have default value as parameter.

Now talk about the Java what happen when we call this function in java class.

public class JParameter {
    
    public static void main(String args[]){
        // You can see here we need to pass i.r because java doesn't now about the function overloading.
       int result = ParametersKt.calAmount(100,30); 
    }
}

But question is, if we want to pass only amount instead of amount and interest rate for that we need to use annotation in our kotlin file @jvmoverloads which is create a two function for us.

fun main(args: Array<String>){
    var finalAmt = calAmount(1000,0.30)

    println(finalAmt)
}

@JvmOverloads // <--------------- This is exact annotation used for create two function for java
fun calAmount(amount: Int, interestRate : Double = 0.40) : Int{
    return (amount + amount * interestRate).toInt();
}

// JParameter.java
public class JParameter {

    public static void main(String args[]){
        int result = ParametersKt.calAmount(100); // Now this would allow to use it and it will call the overloading feature.
    }
}

This is amazing feature of kotlin. Now kotlin has also provide us the named parameter. Means sometime we are using the function of class which is not design by us and when us we does't know the sequence of parameter. To simplify this kotlin allow as to write a name with parameter value.

fun calAmount(amount: Int, interestRate : Double = 0.40) : Int{ // <---- amount and interestRate is named parameter.
}

Now we got idea what is named parameter. When we call this function we can pass a parameter in any order but we can used the named parameter to pass it. This is new feature which is not there in java

 var finalAmt = calAmount(amount = 1000, interestRate = 0.30) //<---- Here is the magic you would allow to pass as named para.

//we can change the order of parameter if we use it. This will doesn't effect the kotlin automatically mapping it.
var finalAmt = calAmount( interestRate = 0.30, amount = 1000) 

String to Integer

In java we have Integer ParseInt for convert the value. we have StringValueOf for parse a string. Now what we have in kotlin for the same kind of thing.

fun main(args:Array<String>){

    var name : String = "4" //string

    var num : Int = Integer.parseInt(name) // string to integer but you know that we can call java method in kotline and kotlin in java
}

Now question is what is new in kotline regarding the same. kotlin provider method string.toInt() for return interger value

fun main(args:Array<String>){

    var name : String = "4"

    var num : Int = name.toInt() // thanks to kotlin they provide us toInt function help to convert the string to integer.

    println("${num * 10}")
}

Now you can see how kotlin push or help a java to make it better.

Try and Catch Exception How to handle the Exception in Kotlin

Below is the example of try catch block handle in the same way we did in java program. As we know we can write a java code in kotlin program.

fun main(args:Array<String>){

    var name = "Bhavdip"

    var number : Int = 0

    try{
        number = name.toInt() // this will throw exception
    }catch (e: Exception){
        println("Give proper Input")
    }
    println(number)

}
//This will throw the NumberFormatException exception.

Above is traditional approach for handle the exception. Lets we talk what is new in kotlin for handle the exception.
One is using expression. We know that expression return value. See below is the example using expression.

fun main(args:Array<String>){

    var name = "Bhavdip"

    var number : Int = try { // <------ this try catch block as expression it return the result and handle the exception.
            name.toInt()
    }catch (e: Exception){
        0
    }
    println(number)
}
Output: 0

Extension Function.

Consider an example like we have Alien class which as skills set and we print it.

//Alien.kt
class Alien {

    var skills : String? = null

    fun show(){
        println(skills)
    }
}
//FunctionExtension.kt
fun main(args:Array<String>){
    var val1 = Alien()
    val1.skills = "Java"
    val1.show()

    var val2 = Alien()
    val2.skills = "Kotlin"
    val2.show()
}

Now for example we want to add third person with having both skills. How to set/add the both/multiple skills set to new Alien person.
That can possible using extension in kotlin. See Alien.kt file it has only single method for show the skills but if you want to add multiple skill set we must have to add the new function plus/add new skills but consider like we don't have source code and still we want to it.

fun main(args:Array<String>){
    var val1 = Alien()
    val1.skills = "Java"
    val1.show()

    var val2 = Alien()
    val2.skills = "Kotlin"
    val2.show()
    
    var val3 = val1.plus(val2) // plus is not function in Alien class.
}

fun main(args:Array<String>){
    var val1 = Alien()
    val1.skills = "Java"
    val1.show()

    var val2 = Alien()
    val2.skills = "Kotlin"
    val2.show()

    var val3 = val1.plus(val2)
    val3.show()
}

fun Alien.plus(a : Alien) : Alien{ // <----This function is part of Alien but externally so it is consider as extension function.
    var newAlien : Alien = Alien() // new Alien object
    //assign new both skills here this refer val1 and a refer val2 while newAlien as newly created object
    newAlien.skills = this.skills + " " + a.skills  
    
    return newAlien
}

Output: 
Java
Kotlin
Java,Kotlin

Infix function(Using Infix Keyword) and operator overloading.

Infix function is what we previously seen its more like english language we call the function
For example. In loop section we noticed

for(index in nums){
}
Here in <-- Its infix function

 var nums = 1 until  16 //until is infix function

    for(index in nums){ //<--- In is infix function its simple english language but without bracket
        println(index)
    }

Lets consider our previous example: function as extension

var val3 = val1.plus(val2)  // we can use infix here
val3.show()

Before we remove the dot and bracket we should have to make our actual function as infix.

infix fun Alien.plus(a : Alien) : Alien{ // <----this now infix function.
    var newAlien : Alien = Alien() 
    //assign new both skills here this refer val1 and a refer val2 while newAlien as newly created object
    newAlien.skills = this.skills + " " + a.skills  
    return newAlien
}
//now we can call function in infix way
    var val3 = val1 plus val2
    val3.show()

Infix function take only one parameter . We have to define infix keyword in front of function. If you want to use operator overloading then use keyword operator overloading.

OperatorOverloading

var val3 = val1 + val2 //<--- here you can see we use sign(+) operator which is called plus function.
val3.show()

operator infix fun Alien.plus(a : Alien) : Alien{ // <----this now infix function with operator overloading
    var newAlien : Alien = Alien() 
    //assign new both skills here this refer val1 and a refer val2 while newAlien as newly created object
    newAlien.skills = this.skills + " " + a.skills  
    return newAlien
}

Recursion: function is call itself

fun main(args:Array<String>){

    var num = 7
    var factoral = 1

    for(i in 1..num){
        factoral = factoral * i
        println(factoral)
    }
}

Above is the factorial using for loops but how to get the same result using recursion function.

fun main(args:Array<String>){
    println(fact(num = 5)) //<--- we use parameter name.
}

fun fact(num : Int) : Int{
    if(num == 0)
        return 1
    else
        return num * fact(num - 1) ///<- this is the place where function is call itself.

}

Tail Recursion in Kotlin: For example in above example if we set num = 70,000 then we will get the exception of stackoverflow.
To overcome with exception we can use tail recursion.

fun main(args:Array<String>){
//    println(fact(num = 5))

    var num = BigInteger("70000")
    println(fact(num, BigInteger.ONE))
}

tailrec fun fact(num : BigInteger, result : BigInteger) : BigInteger{
    if(num == BigInteger.ZERO){
        return result
    }else{
        return fact(num - BigInteger.ONE, num*result)
    }
}

Constructor In Kotlin

In this topic we will look about constructor. In kotlin we can create a class same as java. See below example we have create a class Human with method think and we call it in main method. We got the output calling this method. Now question is how to call constructor?. In java we have constructor which is same as class name. But in kotlin we can't do like that.

class Human{
    fun think(){
        println("We think..")

    }
}
fun main(args:Array<String>){

    var humanObject = Human()
    humanObject.think()
}

In above we see we have call a method in main. Now we want to pass a parameter in constructor.

class Human(paramName : String) //<--- Constructor with parameter
{

    var name : String = paramName

    fun think(){
        println("We think..$name")

    }
}

fun main(args:Array<String>){

    var humanObject = Human("Bhavdip")
    humanObject.think()
}

Kotlin is awesome because if you don't want to use keyword constructor then it is also fine. But if you want to use modifier then a keywords become compulsory.

class Human public constructor(paramName : String) //<--- Primary Constructor with public modifier 
{

    var name : String = paramName

    fun think(){
        println("We think..$name")

    }
}

fun main(args:Array<String>){

    var humanObject = Human("Bhavdip")
    humanObject.think()
}

Below I call constructor without passing a value now in this case as we have seen previously we can set default value which is provided by kotlin. Refere in Name and Parameter chapter

class Human public constructor(paramName : String = ""Bhavdip ) //<--- Primary Constructor with public modifier 
{

    var name : String = paramName

    fun think(){
        println("We think..$name")

    }
}

fun main(args:Array<String>){

    var humanObject = Human()
    humanObject.think()
}

Can I create a constructor inside a class? First whatever we use in above example it is called primary constructor. The thing we want to create it is second constructor. Alternative you can call init which is called when a class is load see that example first.

class Human constructor(paramName : String)
{

    var name : String = ""
    
    init {                                        // see this init method which is called when class is load and we have assign a value in this block.
        name = paramName
        println("We get a parameters")
    }

    fun think(){
        println("We think..$name")

    }
}

Now this time we will see how to create a secondary constructor. Why we need a secondary constructor as we seen in case if you want to more than one parameter in constructor for that we can use it.

Note: If we call/create secondary constructor then must have expect to call primary constructor. for do that we can use it constructor chaining mechanism using this keyword.

class Human constructor(paramName : String="Kishan") //<-- we used Default name parameter value
{

    var age : Int = 0
    var name : String = paramName
//
//    init {
//        name = paramName
//        println("We get a parameters")
//    }


    constructor(age : Int, name : String) : this(name){   //<---- this is secondary constructor that called it from main method.
         this.age = age
         this.name = name
    }

    fun think(){
        println("We have create a human..$age with the name $name")

    }
}

fun main(args:Array<String>){

    var humanObject = Human(10, "Bhavdip") // this the spot it is called secondary constructor.
    humanObject.think()
}

Inheritance in Kotlin

As we seen we know how to create a class and object of it. Then we have seen how to use constructor. Lets try to do a inheritance in kotlin. As we know in java we don't have multiple inheritance the same thing is here because kotlin is better version of java.

The rules we have in java the same is applicable for kotlin.

In kotlin a class is by default as final. So if we try to extend it then its show error we can't extends final class. Final keyword would not allow us to extends it.

Note kotlin we don't have extends keyword but we can use (:) for inheritance.

For inheritance we should show our intention for to using it keyword open keyword.

open class Human{

    fun think(){
        println("Real think")
    }
}

class Alien : Human(){
    
}

fun main(args: Array<String>){
    var human = Human()
    human.think()
}

Lets try multiple inheritance as we know kotlin code is converted into java byte code and java does not support multiple inheritance.

open class Human{

    fun think(){
        println("Real think")
    }
}

open class Computer{
    
}

class Alien : Human(), Computer(){         //<-- Error here we not allow multiple inheritance.

}

fun main(args: Array<String>){
    var human = Human()
    human.think()
}

Override method using inheritance:
Now we override a method from one class to another class same as we did in java. Most important point is in kotlin everything is by default final even if use override keyword it would not allow because it is final in parent class. The solution is use open keyword as we know we have to explicitly show that we want to inherit it for use it in kotlin.

open class Human{

    open fun think(){                //<-- we make it open for inhetiance
        println("Real think")
    }
}

class Alien : Human(){

    override fun think(){                    //we make it open now we can override it.
        println("Alien real think")
    }
}
fun main(args: Array<String>){
    var human = Human() // Human class
    human.think()

    var alien = Alien()  //Alien class 
    alien.think()
}

Call By reference in Kotlin

In above example how to pass reference of parent class and call parent method.

fun main(args: Array<String>){
    var human = Human() // Human class
    human.think()

    var alien : human = Alien()  //Alien that reference to human  
    alien.think()                           // this will not call parent class method? because we make it open and to call parent method we need parent object
}

Constructor Inheritance

Whenever we inheritance class its called super class constructor.

open class Student(ttSubject : Int = 6) {

    var totalSubject : Int = ttSubject

    init {
        println("I am student init block")
    }

    open fun work(){
        println("I am student so I have total $totalSubject subject")
    }
}
class CollegeStudent(clSubject: Int): Student(clSubject){  //<-- this will call the constructor of the parent class.

    init {
        println("I am college Student init block")
    }

    /*override fun work(){
        println("I am COLLAGE student so I have total 10 subject")
    }*/

}
fun main(args: Array<String>){
    var collegeStudent = CollegeStudent(3)  //<-- this is call the constructor of collage student that will pass the value to parent.
    collegeStudent.work()
}
Output:
I am student init block
I am college Student init block
I am student so I have total 3 subject