Kotlin vs. Java: How They Complement Each Other for Android Development Projects?

Since the Android team announced at Google I/O that Kotlin has become an official language for Android, the app development space is abuzz with the Kotlin vs. Java debate.

Our team of Android App Developers has been toying around with Kotlin since February 2016 when Kotlin 1.0 had arrived and they have dispelled all the misconceptions.

Kotlin vs. Java: What are the popular misconceptions?

Our developers have refuted the myths that are doing rounds whether Kotlin will take over Java for Android app development projects stating that both the languages are interoperable.

Furthermore, Google has also affirmed that Kotlin is an additional official language and not a replacement for Java and C++.

Since, Kotlin got first-class support from Google, the developer community has been also wondering which one is better!

In today’s post we would take a look at the great features in Kotlin that has been newly introduced to this language in order to streamline Android development. Here is the list of some significant ones:

• No findViewBylds

• By default null safe

• Coroutines – a new feature

• Data classes – the time saver

• Extension functions

Kotlin vs. Java – the key differences; how they complement each other?

No findViewBylds

Although a Kotlin class and a Java class perform the same work, the former is much more concise and can reduce the amount of boilerplate you need to write, i.e. findViewByIds.

With Kotlin Android Extensions you can import a reference to a View into your Activity file and you will be able to work with that View as if it belongs to the Activity. As a result, you would never need to write another findViewById method again!

To use these extensions, you will need to integrate an extra plugin to your module-level build.gradle file (apply plugin: ‘kotlin-android-extensions’). Once added you can start importing Views; for instance your activity_main.xml file had a TextView with ID textView, then you would need to add the following text to your Activity:

import kotlinx.android.synthetic.main.activity_main.textView

After that you can access this TextView by just using its ID:

Kotlin:

textView.setText("Hello World")

Here’s the Java equivalent:

TextView text = (TextView) findViewById(R.id.textView); text.setText("Hello World");

You can make out now that Kotlin offers much more concise code than Java, isn’t?

By default null safe

In Kotlin, all types of variables are non-nullable by default, thus eliminating any source of null references. This implies that the compiler will not allow you to use non-initialized or non-nullable variable.

Therefore, you are saved from the frustrations of encountering NullPointerExceptions as is the case in Java. Since you can assign null to any variable in Java.

In case, you need a variable to hold a null value then you would need to declare the type as nullable and add a question mark after the type as shown in the example below:

val number: Int? = null

Moreover, the compiler will execute a null-check prior to accessing a nullable variable, thus keeping the code clean by being precise on what can be null and what cannot be; consequently the bugs are reduced and code as well as product quality are improved.

Coroutines – a new feature

While performing a long-running task or CPU-intensive work, in traditional Java development scenario, the calling thread gets blocked until the operation completes.

In Kotlin, a new feature called coroutines was added that allows you to enforce those kinds of operations without blocking a thread. It performs a suspension of coroutine which is a lighter operation.

Coroutines also allow you to create ostensibly synchronous code which in fact is asynchronous yet more clear, concise and readable.

They also have a lower memory usage as they are stackless and do not rely on virtual machine or operating system.

Data classes – the time saver

As majority of our applications are data driven, we generally need to create multiple classes with properties and fields that do nothing but hold data only.

This is usually a very tedious process in Java, as you would need to define a constructor, fields to store the data and at the same time getter and setter function for each field. Additionally, you would need to add hashCode(), equals() and toString() functions.

This is how a simplified version of class would appear in Java:

public class User {
   private String name;
   private int age;
   public User(String name, int age) {
       this.name = name;
       this.age = age;
   }
   public void setName(String name) {
       this.name = name;
   }
   public String getName() {
       return this.name;
   }
   public void setAge(int age) {
       this.age = age;
   }
   public int getAge() {
       return this.age;
   }

}

On the other hand, in Kotlin all you need to do is declare the class as well as all its properties in a single line. The beauty of this language is that the compiler will generate all the getters and setters along with the equality members, toString() and a copy() function as shown below:

data class User(var name: String, var age: Int)

It infers that what you need to manually write in Java code, the compiler will generate everything in Kotlin.

Extension functions

This is a great feature in Kotlin that allows you to extend a class with new functionality. It is currently missing in Java; however, you might have used it in other programming languages used for Android development like C#.

You can easily call a function from an object through an extension function as though it were a part of its class.

For instance, you can create an extension function by prefixing the name of the class, ‘string’ in this case to the name of the function that you are creating, i.e., ‘styleString’. By the way, how does it work?

You would need to add this function to any file as shown below:

StringExtensions.kt

fun String.styleString(): String {
// Style the string and then return it//
}

In Kotlin, you can then call this function on instances of the extended class, through the dot notation, as though it were member function of that class:

myString.styleString()

Kotlin vs. Java: Which one is your choice?

If you too are pondering on which programming language to use for a profitable Android application development – Kotlin or Java, there is welcome news for you. You would be happy to know that you can use both; yes, you heard us right!

In spite of the differences between Kotlin and Java, they are completely interoperable. That means, you can call Java code from Kotlin and vice versa. Also, you can have both Kotlin and Java classes aligned side by side within the same project and guess what, it will compile.

Have you tried Kotlin yet? Do you want to continue with Java for your Android development projects? Let’s talk! We would love to hear your views; please leave your comments below.