Why Kotlin over Java for Android Development? Pros and Cons of Kotlin.

Kotlin is a general-purpose, open-source and object-oriented programming language developed by JetBrains in 2011. It is sponsored by Google, announced as official language for Android application development in 2017.

Kotlin is growingly used in Android application development as an alternate to Java because of interoperability, less run time and efficient coding features. It uses the JVM (Java Virtual Machine) for the programming implementation for application development.

Now, you must be wondering all this okay, but Why should we use Kotlin instead of Java?

So, Java is lengthy with tones of boilerplate codes, time taking and error-prone language. Where Kotlin is fast, simple, easy, and the most important thing compatible be Java code.

Key features:

1. Java Interoperability
2. Type Inference
3. Data classes
4. Null safety
5. Concise
6. Extension functions
7. Named Parameters
8. Primary Constructors

Let’s see all the feature one-by-one:

1 — Java Interoperability

Kotlin seamlessly integrates with existing Java code. You can freely mix Kotlin and Java classes, functions, and variables within your project. This is crucial for leveraging existing Java libraries and frameworks in your Kotlin-based Android apps.

Kotlin is 100% interoperable with Java. You can literally continue your work on your old Java projects using Kotlin. Your all Java frameworks are still available.

2 — Type Inference

Kotlin reduces boilerplate code by automatically inferring the data types of variables from their assigned values. This not only makes your code more concise but also improves readability.

val a = "abc"                         // type inferred to String
val b = 1                             // type inferred to Int
val c: Float = 1F                     // type inferred explicitly
val d: Double = 0.1                   // type declared explicitly

3 — Data Class

Kotlin streamlines data modeling with data classes. These classes are specifically designed to hold data and provide essential features like getters, setters, equals(), hashCode(), and toString() methods automatically. This saves you time and effort in creating common data structures.

It is not unusual to create classes whose main purpose is to hold data. In such classes, some standard functionality and some utility functions are often mechanically derivable from the data. In Kotlin, these are called data classes and are marked with data.

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

The compiler automatically derives the properties declared in the primary constructor:

1. equals() / hashCode()
2. toString()
3. componentN()
4. copy()

Data classes have to fulfill the following requirements:

1. Primary constructor needs to have at least one parameter.
2. Primary constructor parameters need to be marked as val or var.
3. Data classes cannot be abstract, open, sealed or inner.
4. Data classes may only implement interfaces.

4 — Null Safety

Most common catch in many programming languages, including Java, is that accessing a null reference variable, method or function. Kotlin aims to eliminate Null Reference from the code as Tony Hoare said NullPointerExceptions billion-dollar mistake.

NullPointerExceptions are thrown at runtime and sometimes cause application crashes.

Kotlin have two types of references, one can hold null and second can not.

var a: String = "abc"
a = null                  // compilation error

We can declare a variable as nullable string, so variable can hold null.

var a: String? = "abc"    // declared as Nullable
a = null                  // allowed 

There is two operators for NPE: Safe-Call (?) Operator and Assertion (!!) Operator. Where, Safe-Call operator allows null values and Assertion operator does not.

var a: String = "abc"
a = null                  // compile time error

// Safe-Call Operator
val b: String? = null
val length = b?.length    // returns null

// Assertion Operator
val c: String? = "abc"    // any value or null 
val length= c!!.length    // this throws null pointer exception if c is null otherwise returns actual

5 — Concise

Replace the maximum number of coding with lesser code. Scope functions are one of the feature that makes Kotlin concise.

Kotlin provides several scope functions, namely let, run, with, apply, and also, which allow you to define a temporary scope for executing code on an object. These functions help eliminate boilerplate code, reduce the need for intermediate variables and improve readability.

In Kotlin scope functions, the keyword it is a default name used to refer to the object on which the scope function is being applied. When you use a scope function and access properties or call methods on the object, you can use it instead of explicitly referencing the object's name. It makes the code more concise.

Here’s a brief overview of each Scope Function:

• let — Executes a block of code on a non-null object and returns the result. It is useful for performing null checks and performing transformations on an object.

fun main() {
    var a: String? = null
    a?.let {             
        // statement(s) will not execute as a is null
        print(it)
    }
    
    a = "abc"
    a?.let {              
        // statement(s) will execute as a is not null
        print(a)
    }
}

• apply — Applies a block of code to an object and returns the object itself. It is commonly used for configuring an object’s properties or initializing an object.

class Employee() {
    lateinit var name: String
    lateinit var department: String
    lateinit var technology: String
}

fun main(stringArray: Array<String>) {
    // initialize Employee
    Employee().apply {
        name = "Meet Patadia"
        department = "Development"
        technology = "Android"
    }
}

• run — Executes a block of code on an object and returns the result. It can be used to perform operations on an object and access its properties.

class Employee() {
    lateinit var name: String
    lateinit var department: String
    lateinit var technology: String
}

fun main(stringArray: Array<String>) {
    var emp: Employee
    
    // initialize Employee
    Employee().apply {
        name = "Meet Patadia"
        department = "Development"
        technology = "Android"
    }

    Employee().run { 
        print(name)    // OUTPUT: Meet Patadia
    }
}

• with — Similar to run, but it doesn’t return a value. It allows you to access properties and methods of an object without using its name explicitly.

class Employee() {
    lateinit var name: String
    lateinit var department: String
    lateinit var technology: String
}

fun main(stringArray: Array<String>) {
    var emp: Employee
    
    // initialize Employee
    Employee().apply {
        name = "Meet Patadia"
        department = "Development"
        technology = "Android"
    }

    with(emp) { 
        print(name)    // OUTPUT: Meet Patadia
    }
}

6 — Extension Function

Have you ever wanted to add functionality to a class in Kotlin, but modifying the original code wasn’t ideal? Well, fret no more! Kotlin’s secret weapon, extension functions, come to the rescue.

What are Extension Functions?
Imagine giving an existing class in Kotlin some extra superpowers without permanently altering it. That’s the magic of extension functions. They let you define new methods that can be called on existing classes, just like regular methods.

Why Use Them?

• Clean Code: Extension functions keep your code modular and organized by adding functionality in a separate location.
• No Class Modification: You don’t need to touch the original class definition, making maintenance easier.
• Improved Readability: Code becomes more expressive as extension functions act like natural methods of the class.

fun main() {
  val str1 = "Hello world"
  val str2 = ""

  println(str1.isBlank()) // Prints false
  println(str2.isBlank()) // Prints true
}

// Extension function to check if a string is blank (empty or only whitespace)
fun String.isBlank(): Boolean {
  return this.trim().isEmpty()
}

In above example:

1. We define an extension function named isBlank() that takes a String receiver.
2. The function checks if the trimmed version of the string is empty.
3. In the main function, we call isBlank() on two strings.
4. The call str1.isBlank() utilizes the extension function as if it were a method of the String class.

7 — Named Parameters:

Kotlin allows you to call functions with arguments in any order as long as you provide their names explicitly. This improves code readability and maintainability, especially when dealing with functions that have many parameters.

fun createUser(firstName: String, lastName: String, age: Int = 18) {
    println("User created: $firstName $lastName (age: $age)")
}

// Calling with named parameters (order doesn't matter)
createUser(lastName = "Patadia", firstName = "Meet", age = 22)

In above snippet:

• The createUser function has three parameters: firstName, lastName, and age (with a default value of 18).
• When calling the function, you can provide arguments in any order as long as you specify their names using the parameter name followed by an equal sign (=).

8 — Primary Constructors

Kotlin offers primary constructors, a concise way to initialize properties directly within the class definition. This eliminates the need for separate constructor boilerplate code.

data class Person(val name: String, val age: Int)

val john = Person("Meet Patadia", 22)

Here:

• The Person class is a data class with two properties: name and age.
• The primary constructor directly initializes these properties using the val keyword (for read-only properties).
• Creating an instance of Person is done by providing values within parentheses, assigning them to the properties defined in the constructor.

Potential Pitfalls and Limitations of Kotlin

While Kotlin offers numerous advantages over Java, it’s important to consider some potential pitfalls and limitations when deciding whether to adopt it for Android development.

1 — Learning Curve:

• Transition for Java Developers: Although Kotlin is designed to be interoperable with Java, Java developers might need some time to get accustomed to Kotlin’s syntax and features. This learning curve can initially slow down development.
• New Concepts: Kotlin introduces new programming concepts like coroutines for asynchronous programming, which can be challenging for those unfamiliar with them.

2 — Compilation Speed:

• Slower Compilation: In some cases, Kotlin’s compilation speed can be slower than Java’s, especially in large projects. While this is continually being improved, it can affect productivity.

3 — Ecosystem Maturity:

• Tooling and Libraries: While Kotlin is well-supported by Google and the Android ecosystem, some third-party libraries and tools might have better support for Java, given its longer presence in the industry. This can sometimes lead to compatibility issues or less mature Kotlin-specific documentation.
• Community Support: Although the Kotlin community is growing rapidly, it is still smaller compared to the Java community. This means there might be fewer resources, tutorials, and forums for troubleshooting specific issues.

4 — Runtime Performance:

• Performance Overheads: In some scenarios, Kotlin can introduce minor performance overheads due to features like extension functions and higher-order functions. While these are generally negligible, they might be a concern in performance-critical applications.

5 — Framework Support:

• Legacy Projects: If you are working on a legacy project with a large Java codebase, migrating to Kotlin can be a complex and time-consuming process. Ensuring compatibility and avoiding regressions might require significant effort.
• Interoperability Issues: Although Kotlin is designed to be fully interoperable with Java, subtle issues can arise, especially when dealing with advanced Java features or specific Android framework nuances.

6 — Long-term Stability:

• Language Evolution: Kotlin is a newer language compared to Java, and while it is backed by JetBrains and Google, its evolution and changes could pose long-term stability concerns. Rapid language changes can introduce breaking changes or deprecations that require ongoing codebase maintenance.

Conclusion

Kotlin has become a popular choice for Android development due to its numerous advantages over Java. It reduces boilerplate code with features like type inference and data classes, ensures null safety, and offers concise syntax. Kotlin also integrates seamlessly with Java, allowing for easy adoption in existing projects.

However, developers should be aware of potential drawbacks, such as a learning curve, slower compilation speeds, and some compatibility issues with Java libraries. Despite these challenges, Kotlin’s strong support from Google and JetBrains, along with its growing community, makes it a compelling option for modern Android development.

By leveraging Kotlin’s strengths and addressing its limitations, developers can create cleaner, safer, and more efficient Android applications.

I hope this article has provided valuable insights. Your support means a lot to me, so if you found this content helpful, please start following me and don’t hesitate to show some love with a hearty round of applause!👏

Your feedback fuels my passion for creating quality content. For any queries or just to connect, reach out on LinkedIn and Twitter.

Thanks for reading — looking forward to staying in touch!

Happy Learning!!