Kotlin is a statically typed programming language for the JVM, Android, and the browser.
Why use Kotlin for Android Development?
- Concise: Drastically reduce the amount of boilerplate code you need to write.
- Safe: Avoid entire classes of errors such as null pointer exceptions.
- Versatile: Build server-side applications, Android apps or front-end code running in the browser.
- Interoperable: Leverage existing frameworks and libraries of the JVM with 100% Java Interoperability.
Let’s see the things in more detail ( Kotlin vs Java ):
- InteroperablewithJava: When it comes to giving a try to a new language, Interoperability is a great thing which can help Interoperable means you can reuse any Java class ever written, all Java code can work with Kotlin and vice versa. Learning Kotlin for a Java developer shouldn’t be too hard. Everything you can do with Java, you can do in Kotlin. If you do not know how to do it in Kotlin, then just do it in Java and let the Kotlin plugin convert it to Kotlin. Make sure that you see what happened to your code so that the next time you can do it yourself.
- Null Safety: Kotlin’s type system is aimed at eliminating the danger of null references from code, also known as The Billion Dollar Mistake.
One of the most common pitfalls in many programming languages, including Java is that of accessing a member of null references, resulting in null reference exceptions. In Java, this would be the equivalent of a NullPointerException or NPE for short.
In Kotlin, the type system distinguishes between references that can hold null (nullable references) and those that can not (non-null references). For example, a regular variable of type String can’t hold null:
To allow nulls, you can declare a variable as a nullable string, written String?:
Now, if you call a method or access a property on a, it’s guaranteed not to cause an NPE, so you can safely say
But if you want to access the same property on b, that would not be safe, and the compiler reports an error:
But you still need to access that property, right? There are a few ways of doing that.
- Checking for null in conditions:
First, you can explicitly check if b is null, and handle the two options separately:
- Safe Calls:
Your second option is the safe call operator (?.) :
This returns the length of b if b is not null, and null otherwise.
- Smart Casting:
Kotlin uses lazy evaluation just like in Java. So if the document were not a Payable, the second part would not be evaluated in the first place. Hence, if evaluated, Kotlin knows that document is a Payable and uses a smart cast.
- Default Arguments: Default arguments are a feature you are missing in Java because it’s just so convenient, makes your code more concise, more expressive, more maintainable and more readable.
- Named Arguments: When it comes to readability, Named arguments make Kotlin awesome.
- Functional Programming: While Java evolved to incorporate several functional programming concepts since Java 8, Kotlin has functional programming baked right in. This includes higher-order functions, lambda expressions, operator overloading, lazy evaluation and lots of useful methods to work with collections. The combination of lambda expressions and the Kotlin library really makes your coding easier.
- Concise Code: When you use Kotlin instead of Java, there is a huge reduction of code in your project.
See it in the example:
Some code snippets ( Java to Kotlin )