So you want to build an Android chat app?
One of the first decisions you have to make is to choose which programming language you’re going to use. Luckily, if you’re opting to build a native Android app, you only have two choices: Java or Kotlin.
Which begs the question - “Should I use Java or Kotlin for native Android app development?”
The answer? It depends.
Java vs. Kotlin isn't clear-cut. Which you should choose will depend on your app’s requirements and what you want to prioritize. This article will dig deep into the Java vs. Kotlin debate, comparing aspects such as developer experience, performance, key features, and much more. If you make it to the end of the article, you’ll know exactly what programming language will suit your needs best.
A quick note: If you’re not dead set on building a native app, check out our guide on building cross-platform hybrid apps.
Let’s get started.
Java vs. Kotlin: A Quick Overview
Before we compare Kotlin and Java, let’s go over the basics of each programming language.
What is Java?
Java is an object-oriented programming language developed by Sun Microsystems (now owned by Oracle) and first released in 1996. It has to run in a JVM (Java Virtual Machine), which is why it’s mostly used for standalone applications or back-end development. To run Java in a web browser, you need to enable the Java applets plugin. Unfortunately, the Java applets plugin is both a hassle and a security risk.
However, Java can run on virtually any operating system. That, plus the fact that the Android operating system is coded in Java, makes Java the go-to programming language for developing Android apps.
Some popular Android apps built with Java include:
What is Kotlin?
Kotlin is a newer programming language. JetBrains created it in 2010 and open-sourced it in 2012. It’s a statically-typed language that was designed to bring the best aspects of object-oriented programming and functional programming together into a single language.
Google, the creator of Android, declared Kotlin the programming language of choice for Android development in 2017.
Some popular Android apps built with Kotlin include:
Eager to learn Kotlin? Start building your chat app with our tutorial on building an Android chat app with Kotlin.
Java and Kotlin: Similarities
Before we begin comparing the differences between the two programming languages, let’s discuss how similar Kotlin is to Java.
One similarity between Java and Kotlin is that they both compile to bytecode, and that bytecode is then executed by the JVM. Both languages support object-oriented programming concepts. And while not exactly the same, Java and Kotlin have similar programming syntax. A Java developer will be able to read Kotlin code without much trouble.
Now, let’s move on from the similarities between Java and Kotlin and compare the key differences between the two.
Java vs. Kotlin: Key Feature Comparison
Each programming language has its benefits and drawbacks. Let's look at the key differences between Java and Kotlin's feature sets.
If you’ve ever used Java, then you’ll understand why we say that NullPointerExceptions are the mortal enemies of Java programmers.
A NullPointerException occurs when you try to use a reference that points to no location in memory (null) as though it were referencing an object. These exceptions can be difficult to prevent and can crash your app when they occur.
In Java, a developer must check and handle possible NullPointerExceptions because they can occur during initialization and run-time.
Kotlin, on the other hand, is considered null safe. By default, a variable in Kotlin is non-nullable because it will throw an error during compilation. If you want a null variable, you have to define it explicitly. Kotlin apps won’t crash due to a null pointer during run-time since any possible NullPointerExceptions are detected at compile-time.
In regards to null pointer safety, Kotlin takes the crown.
Inheritance is a core concept of object-oriented programming. In simplified terms, it means that a child class inherits the properties of a parent class due to a hierarchical structure of classes.
In Java, if you want to extend the functionality of an existing class, you have to create a new child class that inherits from the parent class and then add the extra functionality.
Kotlin breaks this mold. In Kotlin, you can use extension functions to achieve extending functionality without creating a new class. The benefit of these extension functions is less code and fewer classes.
While extension functions might feel strange to OOP purists, you can't argue the convenience. And that's why we believe extension functions are a plus. So, Kotlin wins this one.
Creating a class in Java requires a bunch of boilerplate code. To store data in a class, you have to define the constructors, the getter and setter methods, the hashCode and toString functions, and more. It’s a hassle and can introduce silly syntax errors.
Kotlin fixes this by incorporating data classes. If you need to store data in a class, you can define a class with the “data” keyword, which then automatically generates the typical boilerplate code at compile-time. This greatly increases readability and removes a lot of the fluff from your development codebase. Thus, Kotlin has the upper hand.
Java offers checked exceptions support. An exception is an unexpected event or error that happens during the execution of a program during run-time. When these exceptions are checked at compile-time, they're called checked exceptions.
Kotlin, unlike Java, doesn’t support checked exceptions. It doesn’t throw any errors at compile-time if there are uncaught exceptions. We're not convinced it was a good idea to remove checked exceptions. In fact, there is a large debate over this with plenty of folks on either side of the aisle.
In a Java and Kotlin comparison, we consider checked exceptions a win for Java.
Smart Casts & Type Inference
In Java, when you declare a variable, you must explicitly specify the type (int, float, String, boolean, etc.). In Kotlin, while you can declare the variable’s type, you don’t explicitly have to. If not declared, Kotlin will infer the variable type.
In Java, if you want to use a variable that's been defined as one primitive type (such as Int or String) as a different primitive type, you have to explicitly “cast” a variable to the other type. This is called typecasting.
Kotlin, on the other hand, has smart casts. With smart casting, you rarely have to typecast your variables explicitly. The “is-checks” keyword allows the compiler to check for immutable values and do implicit casting.
Kotlin's smart casting and type inference is an upgrade from manually typing and casting all your variables in Java. So, Kotlin wins this one.
One of the key differences between Java and Kotlin is that Kotlin offers functional programming concepts. Functional programming is a programming paradigm that tries to bind everything in “pure mathematical functions style.” Kotlin allows the use of functional methods such as lambdas, operator overloading, higher-order functions, and lazy evaluation.
Functional programming increases modularity, simplifies solutions to complex mathematical problems, reduces code redundancy, and increases maintainability. Since Java doesn't offer any functional programming concepts, Kotlin wins this one by default.
Plus, if you come from a functional programming background with languages such as Haskell or Python, Kotlin will feel very familiar.
Java vs. Kotlin: Performance
One of the first questions people ask in the Java vs. Kotlin debate is: which is faster?
However, as we already mentioned, both Java and Kotlin compile into very similar bytecodes. So, the performance of Kotlin and Java code in production apps will be very similar. If you want to boost performance and speed, it would be better to focus on writing clean and performant code rather than on which language to choose.
However, there is one performance aspect that differs between the two languages: build time. Why does build time matter? It affects development time. The longer it takes to do incremental builds, the longer it takes to develop your app.
So what’s the verdict? For clean builds (going from 0 to 1), Java compiles 10-15% faster. However, when developing, you’re more likely to do incremental builds. For incremental builds, the difference between the compilation speed of Kotlin and Java is very minimal.
Another aspect of performance that we need to look at is memory usage. Memory is used to load and run your app. So, memory usage is important since users will want your program to appear to load and run fast. The lower the memory usage, the faster a program can execute. Java achieved better memory usage on four out of six different benchmarks. While the median difference in memory usage never exceeded 10% in any of these benchmarks, this is still a significant result. If high memory usage is a possible roadblock to your project, consider using Java instead of Kotlin.
Next, let's look at reliability and scalability. In these aspects of performance, Java and Kotlin are very similar. They are both reliable and scalable languages to use for building Android apps. Both reliability and scalability are determined more by how the code is written than by the programming language itself. So, while Kotlin offers features such as null safety, which makes the code more reliable, with a little more effort, Java can achieve the same reliability by checking and catching null pointer exceptions. The same applies to scalability. Java & Koltin are tied.
As you can see, overall performance isn’t a great differentiator between Java and Kotlin. Overall, when it comes to performance, Kotlin and Java are tied.
Kotlin vs. Java: Developer Experience
Developer experience, or the interactions and feelings that a developer has when working with a particular technology, dictates how enjoyable it is to work with that technology (or, in this case, programming language). Factors such as readability, ease of adoption, documentation, and developer community all play a role here.
Kotlin takes the win in readability. With its data classes and null pointer safety features, Kotlin cuts down on a lot of work (and many lines of code). Not only does it make the code easier to read, but it also increases conciseness. Concise code makes it easier to understand (and find bugs in) the core logic.
Ease of Adoption
Relative to other programming languages, Java has been around for a long time. Its longevity can be attributed to one main reason: it’s a relatively simple language to learn and master. In fact, Java is often used as a tool for teaching object-oriented programming concepts in computer science courses.
Kotlin, however, is just as easy to learn. Another point towards ease of adoption for Kotlin is that it is interoperable with Java. This means if you have a pre-existing Java project, you can just start adding functionality using Kotlin without having to migrate the entire project. This also makes collaboration between Kotlin and Java programmers effortless.
Java and Kotlin are tied when it comes to ease-of-adoption.
Documentation & Developer Community
Documentation and developer community go hand-in-hand. The larger the community, the more likely it is that a resource exists that will solve your problem. Because of its age and presence in enterprise software, Java has a huge developer community. In fact, according to a survey of ~83,000 software developers, 35% of respondents say they use Java, while only 8% say they use Kotlin.
While Java currently has the upper hand, Kotlin is a beloved underdog. Since Google’s announcement that Kotlin is the preferred Android development language, adoption has soared. And it will continue to soar.
Kotlin vs. Java: The Future
A comparison of Kotlin vs. Java wouldn't be complete without taking a few educated guesses on what's to come.
Kotlin has a bright future ahead of itself. You can check out their roadmap to get an idea of where they are headed. Key priorities include a new compiler that's optimized for speed and parallelism, a faster and smoother IDE, and much more. We also expect to see much more tooling and developer resources for the Kotlin language in the future since Google endorsed Kotlin as the preferred language for Android development.
Oracle (the maintainer of Java) has no intention of ending support or updates, which is good because over 3 billion devices worldwide run on Java. It’s one of the most popular programming languages, and its popularity doesn’t seem to be waning.
Whether you end up choosing to use Java or Kotlin, there is no need to be afraid of the future.
Kotlin vs. Java: The Verdict
To summarize, here's an overview of Kotlin vs. Java:
So which is better? Kotlin or Java? How do you choose which programming language to use for your Android app?
Choose Kotlin if:
You want to use a modern language
You prefer to use functional programming concepts
Readability and conciseness are important to you
You really want to avoid any NullPointerExceptions
Choose Java if:
Easily finding proficient developers is a must
Code robustness is a priority
Support and documentation is important to you
We hope this Java vs. Kotlin comparison helps you identify which programming language is best for you. Keep in mind that at the end of the day, a successful Android app can be built with either programming language. Just because Google declared Kotlin the preferred language of choice doesn’t mean you have to use it.
Ready to jump in? Sign up to our developer dashboard and start building your chat app for free.
If you still have questions, feel free to talk to our experts and get answers before you get started.
Or, if you're interested in learning more, Check out our related tutorials, articles, and guides:
About the Author
Cosette Cressler is a passionate content marketer specializing in SaaS, technology, careers, productivity, entrepreneurship and self-development. She helps grow businesses of all sizes by creating consistent, digestible content that captures attention and drives action.