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

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