Kotlin vs Java: 14 reasons why we chose Kotlin for Android development

Kotlin vs Java: 10 reasons why we chose Kotlin for Android development

In this article, we will give a brief intro to Kotlin programming language for Android app development. Kotlin is a modern language. Later we’ll explain with some brief code samples about Kotlin vs Java.

 

Introduction to Kotlin

Kotlin is an open-source, statically-typed programming language that runs on Java virtual machine. It was developed by JetBrains and open-source contributors. Kotlin first appeared in 2011 and a stable version (Kotlin 1.2) was release on 28, November 2017. Kotlin was created with Java and Android developers in mind. Its two main and most interesting features for Android developers are:

Learning Curve

The learning curve of Kotlin is fairly moderate. The syntax is simple and similar to most modern programming languages. The documentation is thorough and there is a lot of help and support available in the community. Most part of the language is what we already know and differences in some concepts can be learnt in no time. The syntax is not at all like Java which is popular with Android development. However, it can be compared with Swift for iOS.

Integration in Android Studio

Standard IDE for Android development means that app developers can understand, compile and run Kotlin code without any troubles or workarounds because the support for this language comes from the company that developed the IDE. There is also a code converter plugin in Android Studio that converts Java code to Kotlin.

 

Along with having full support above Android Studio 3.0, Kotlin lets its user choose whether to target Java 6 or Java 8 compatible bytecode. It is highly interoperable with Java, which means you can continue using libraries and code written in Java while working in Kotlin. Mixed projects are also possible, with both Java and Kotlin files coexisting in the same project.

Even the latest version of Android Studio i.e. 3.0.1, doesn’t support the latest version of Java i.e. Java9. It only supports Java7 and a subset of Java8 feature which also vary by platform version. With Kotlin you can use all of its functionality using Android Studio 3 and above or IDEA both development by JetBrains. It also provide following advantages over Java. There are plenty more reasons for Kotlin but we are only listing the reasons that we actively used and can discuss with development community.

 

Kotlin vs Java: Comparison

 

1. Null Safety

One of the biggest advantage of Kotlin is that it’s null safe. NullPointerException (a.k.a. The Billion Dollar Mistake) is a run time exception in Java, which was removed in Kotlin and it will save you a lot of debugging time. To access a Nullable object you have to use the null safety operator i.e. “?.”. If there’s a “?” after type of an object, it is considered to be Nullable.

fun doSomething(text:String?){
     text?.length
 }

 

2. Kotlin is more expressive

Kotlin is concise and expressive which means you can write more functionality with much less code. It has zero boilerplate delegation.

Java example

Setting a click listener on a button in Java looks a lot confusing for a beginner and is difficult to remember without the help of suggestions from Android Studio.

mButton.setOnClickListener(new View.OnClickListener() {
     @Override
     public void onClick(View view) {
 
     }
 });

Kotlin example

Setting a click listener on a button in Kotlin is a lot more expressive.

mButton.setOnClickListener(View.OnClickListener{//code here})

 

3. Kotlin is Functional

Kotlin is basically an object-oriented language but as most of the modern programming languages, it uses some concepts of functional programming, such as lambda expressions and high order (functions that accept other functions as parameters).

mButton.setOnClickListener({//code here})

 

banner hire mobile app development services - kotlin vs java

 

4. Extension Functions

It provides the ability to extend the functionality of a class without inheriting it and even if you don’t have access to its source code. Whenever you want to access this, simply create an object of said class and call the function with “.” Operator.

Creating an extension

fun ActionBar.setTitle(context: AppCompatActivity, title: String) {
    val view: View? = context.supportActionBar?.customView
    val titleTv = view?.findViewById(R.id.title)
    titleTv?.text = title
}

Calling extension function

val actionBar:ActionBar = getSupportActionBar()
actionBar.setTitle(this, “Title”)

 

5. Smart Casts

This feature eliminates the use of explicit type casting which means if a local object passes a type check you can access it.

if (x is String){
     x.length
 }

 

6. Type Inference

Most of the times you don’t have to specify the type when you declare a variable of value, as Kotlin will do it for you. But, in case it can’t infer, you have to define the variable with the full syntax.

Java example

  • String s = “abc”;
  • char c = ‘a’;
  • int i = 123;
  • float f = 34f;

Kotlin example

  • var s = “abc”
  • var c = ‘a’
  • var i = 123
  • var f = 34f

 

7. Avoid findViewById

One of the most common and boring operation in Android development is findViewById. Although there are several alternatives like ButterKnife to improve this experience, you can simply avoid it in Kotlin using Kotlin Android Extension.

//in XML
     <button>
//and then in Java, no need to find id of the button or to create an object loginBtn.setText(“Something Else”)
//note that id of the button is used here
</button>

 

8. No Static

Kotlin dropped a well-known Java constructor: the static keyword. To have its class level functionality, companion object are introduced. The main advantage of this is that everything is an object. In Java, static members are treated very differently than object members. This means that you can’t do things like implementing an interface or putting your class ‘instance’ into a map or pass it as a parameter to a method that takes Object. Companion objects allow for these things.

 

9. Data Classes

Another great feature in Kotlin is the way it creates data classes. In Android most of the application are data driven which means we spend much time creating classes with only properties and fields to hold data. In Java this process is very tedious whereas in Kotlin this can be done in a single line.

Java example

public class UserModel {
     private int userId;
     private String firstName;
     private String lastName;
     private String address;
 
     public UserModel() {
     }
 
     public UserModel(int userId, String firstName, String lastName, String address) {
         this.userId = userId;
         this.firstName = firstName;
         this.lastName = lastName;
         this.address = address;
     }
 
     public int getUserId() {
         return userId;
     }
 
     public void setUserId(int userId) {
         this.userId = userId;
     }
 
     public String getFirstName() {
         return firstName;
     }
 
     public void setFirstName(String firstName) {
         this.firstName = firstName;
     }
 
     public String getLastName() {
         return lastName;
     }
 
     public void setLastName(String lastName) {
         this.lastName = lastName;
     }
 
     public String getAddress() {
         return address;
     }
 
     public void setAddress(String address) {
         this.address = address;
     }
 }

Kotlin example

data class UserModel(var userId:Int, var firstName: String, var lastName: String, var address: String)

 

10. No Semicolons in Kotlin

If you haven’t noticed till yet in the above code examples, there are no semicolons in Kotlin.

 

11. String Interpolation

Or you can call it smarter and more readable version of String.format() of Java.

val a = 7
 
val b = 3
 
log.d(TAG, “Sum of $a and $b = ${a+b}) //Sum of 7 and 3 = 10

12. Default Arguments

Tired of overloading a function numerous times just because of varying arguments? Well Kotlin is bundled with default arguments.

fun create (firstName:String = “user”, lastName:String = “name”, age:Int = 18){
 
regitster(firstName, lastName, age)
 
}

13. Named Arguments

With this feature you can pass the arguments in any order, or use with default arguments and there’s no need of builders.

create(“John”, “Doe”, 23)                               //equivalent
 
create(firstName = “John”, lastName = “Doe”, age=23)    //equivalent
 
create(age=23, firstName=”John”, lastName=”Doe”)        //equivalent

14. When Expression

More readable and flexible version of Java’s switch case.

when (x){
 
1 -> log.d(TAG, “x is one”)
 
2,3 -> log.d(TAG, “x is two or three)
 
in 4..10 -> log.d(TAG, “x is in range of four to ten)
 
else -> log.d(TAG, “x is out of range”)
 
}

 

Conclusion

After creating my first project in Kotlin, I find the language to be exactly as advertised. It helped to avoid some common pitfalls with Java, the null pointer exception is most dominant, which increased applications quality and reliability. The code is made more concise and readable with removed boilerplate delegations and introduction of lambda expressions.

All the points above have made it easier for us to decide if we want to use Kotlin for our next Android project. If you want to make a project or hire Android developers then contact us below.

Also, let us know what you think of Kotlin vs Java. Share your comments below.