Hello there! My name is Divyansh Jain. I am student of Mahatma Jyoti Rao Phoole University. I have been selected as the Android developer for the XWiki organization and I am working on their XWiki Android Authenticator application in GSOC19.
XWiki android Authenticator aims to integrate a wiki instance in Android accounts, mainly including the synchronization of contacts and the XWiki authenticator. By synchronizing contacts of your company on your phone, it becomes easier to communicate and collaborate with each other.
Ever since the start of my work on the XWiki Android Authenticator app, I have been constantly learning new things. In the first week, I migrated most of the XWiki Android Application code from Java to Kotlin. And on this page, I would like to share my understanding of Kotlin that I have gained so far.

Getting started with Kotlin

Kotlin is officially supported by Google for mobile development on Android. It was released in Android Studio 3.0 on October 2017. At first, I was a bit afraid to switch to Kotlin since I feared that the code might crash and not run properly, but as I read the documentation, I started understanding the nuances of the language which made the switch from Java to Kotlin an easier process. I started realizing the advantages of Kotlin over Java. Some of them being:

1. Java Interoperability: I started with migrating the whole XWiki Android Authenticator app code from Java to Kotlin. I was replacing one Java file at a time, and while migrating I saw that Kotlin worked with Java smoothly. Though it required some direct imports, but apart from that, there were no errors on running the app on the device.
2. Familiar syntax: The syntax of Kotlin is similar to Java, which is why I learned Kotlin in just a matter of days. Though there are a few differences. For instance:

   1. Changed variable declaration: In Java, we declare variables. E.g.
      String wiki, now it can be val str = “Hello”  or val str: String = “Hello”.

      Here val declares a read-only property or local variable whereas var declares a mutable property or local variable.

   2. The final keyword is default in class: In kotlin final is a default. E.g.

                   
      class Button {
      fun click() = print("Click")
      }
      class displayToast : Button() {  // Error
      override fun click() = print("Toast Displayed") // Error
      }

      In the above example, class displayToast can’t inherit Button class because it is final. Moreover, it can’t override click(), because it is final in Button.

      open class Button {
      open fun click() = print("Click")
      fun doubleClick() = print("Double Click")
      }
      
      class displayToast () : Button {           // Inheritance is now possible
      override fun click() = print("Toast Displayed") // Now it works
      override fun displayToast () = print("Toast Displayed") // Error
      }

      In order to inherit and override, we put “open” keyword that allows  inheritance and overriding.

   3. Fun keyword for defining functions: Now in Kotlin, there is a new way to define functions. E.g.
      
      fun displayToast() {
      }
      or
      fun addDigitis (a: int, b: int) : String {
      } 
      
       It is same as the Java parameterized method or empty method.
   4. The when expression: The "switch-case" is replaced with the much more readable and flexible "when" expression: e.g.
      
      int x = 3;
      when (x) {
      1 -> print("x is 1")
      2 -> print("x is 2")
      3, 4 -> print("x is 3 or 4")
      in 5..10 -> print("x is 5, 6, 7, 8, 9, or 10")
      else -> print("x is out of range")
      }
      
      It works without the argument too. 
   5. Static keywords : For declaring static methods & variables, you can put them above the class name, then you can use them by importing directly in other classes.
3. Null Safety: One of the biggest flaws in Java is the way it handles “null,” leading to the dreaded NulPointerException (NPE). Kotlin resolves this by distinguishing between non-null types and nullable types. Types are non-null by default, and can be made nullable by adding a safe call ‘?’. E.g.
   
   var a: String = "abc"**
   a = null                // compile error
   
   var b: String? = "xyz"
   b = null                // no problem