Interest in Kotlin has been on the rise since Google announced it as the official language of Android in 2017. According to feedback from a large number of Android developers, Kotlin has helped them improve their productivity and application quality, and they are very satisfied with it. And data shows that more than 80% of the top 1000 Android applications in the Google Play store use Kotlin, and the Android official team is also writing the underlying source code in Kotlin. Obviously, for Android developers, Kotlin is a hurdle that cannot be bypassed.
Kotlin vs Java: Battle of the Programming Languages
Before the advent of Kotlin, most Android developers used the Java language. Java has many obvious advantages, such as easy to learn, object-oriented, and good cross-platform portability. In their minds, Java is the best programming. language. However, after the advent of Kotlin, this belief in Java was shaken, and programmers began to search for:
- Which language is better; Kotlin or Java?
- For Android development, which is better Kotlin or Java?
This article will try to answer the above two questions.
What is Java?
Java is a widely used computer programming language with
cross-platform, object-oriented, and generic programming features, and is
widely used in enterprise-level web application development and mobile
application development.
In the Android system, almost all codes in the system App layer
and Framework layer (some of which have been changed to Kotlin at present) are
implemented by the Java language.
Advantages of Java Language:
- Good Cross-Platform Portability: thanks to the existence of the Java virtual machine, write once, run anywhere (Write once, run anywhere)
- Simple and Easy to Learn: Java is an object-oriented programming language that is easy to understand, omitting hard-to-understand concepts such as multiple loading and pointers. And realizes the automatic garbage collection mechanism, which greatly simplifies the program design
- Robust: Java's strong type mechanism, exception handling, automatic garbage collection, etc. are important guarantees for the robustness of Java programs
- Safe and Secure: many of its libraries are managed by trusted companies like Google, Apache, etc.
Challenges of the Java Language:
- Slower Running Speed: Java relies on the Java virtual machine to run, so it is slower than programs written in other languages (assembly, C/C++) because it does not directly execute machine code
- Lack of Closures: The lack of closures makes for poor functional programming support in Java
- Test Driven Development: Requires more code to be written and carries a higher risk of programming errors
- Primitive Types: The existence of primitive types makes Java not a perfect object-oriented language and can cause some programming problems. There is no perfect solution to the automatic boxing feature in Java5
What is Kotlin?
Kotlin is a statically typed programming language that runs
on the Java Virtual Machine, designed, developed and open sourced by JetBrains.
Advantages of Kotlin language:
- Concise Language: Kotlin has a concise syntax and modern syntax features, and code blocks written in Kotlin are smaller compared to Java.
- Good Compatibility with Java: Kotlin compiles code to bytecode that can be executed in the JVM. So all libraries and frameworks made in Java are common in Kotlin projects
- Good Security: The null safety mechanism reduces the probability of NullPointerException occurring
- Structured Concurrency: Kotlin coroutines make asynchronous code as easy to use as blocking code
Challenges of the Kotlin language:
- Less Popular: Kotlin is not that popular compared to other mature languages like Java. So less stable libraries, frameworks and tutorials
- Matching Weak Patterns: Poor initial code readability
- Steep Learning Curve: easy to get started, hard to master
Kotlin vs Java
Even though Kotlin is the officially supported language for writing Android apps, you may still feel that there isn't enough reason to switch. The following comparison includes the advantages of Kotlin compared to Java in more detail.
| Feature | Java | Kotlin |
|---|---|---|
| Check Exception | ✅ | ❎ |
| Code Concise | Not Very Concise | Better than Java |
| Coroutine | ❎ | ✅ |
| Data Class | Requires writing a lot of boilerplate code | Just add the data keyword to the class definition |
| Extension Function | ❎ | ✅ |
| Higher-Order Functions and Lambdas | Higher-order functions are implemented using Callables. Lambda expressions were introduced in Java 8 | Prebuilt Features |
| Inline function | ❎ | ✅ |
| Native Support for Delegation | ❎ | ✅ |
| Non-Private realm | ✅ | ❎ |
| Null Pointer Exception | ✅ | ❎ |
| Basic Data Type | Variables of primitive types are not objects | Variables of primitive types are objects |
| Smart Conversion | ❎ | ✅ |
| Static Member | ✅ | ❎ |
| Ternary operator | ✅ | ❎ |
| Wildcard Type | ✅ | ❎ |
Use Grammatical Contrast
1. Null Pointer Safety
NullPointerException or NPE is one of Java's major
drawbacks, the only possible cause of NPE is an explicit call throwing
NullPointerException. Some initialization-related data inconsistencies, or
other problems caused by external Java code. And Kotlin avoids NullPointerException.
Kotlin fails at compile time whenever a NullPointerException might be thrown.
2. Data Class
To write data classes in Java, developers usually need to
define a constructor, several fields to store data, getter and setter functions
for each field, and equals(), hashCode(), and toString() functions.
class Book {
private String title;
private Author author;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public Author getAuthor() {
return author;
}
public void setAuthor(Author author) {
this.author = author;
}
}
Kotlin has a very simple way to create such a class. The developer only needs to include the data keyword in the class definition, and the compiler will handle the whole task on its own.
data class Book(var title: String, var author: Author)
3. Extension Functions
Kotlin allows us to extend the functionality of existing classes without inheriting them. Meaning, Kotlin provides the ability to develop classes with new functionality without inheriting from the class, extension functions can do this. To declare an extension function, you need to prefix its name with a receiver type, which is the type to be extended. The following adds a function for specifying subscripts to exchange values for MutableList:
fun MutableList <Int> .swap(index1: Int, index2: Int) {
val tmp = this[index1]
this[index1] = this[index2]
this[index2] = tmp
}
The "this" keyword in the extension function corresponds to the receiver object, passed before the ".". This function can now be called on any MutableList:
val list = mutableListOf(1, 2, 3)
list.swap(0, 2)
4. Smart Conversion
Kotlin's compiler can automatically do type conversions. In many cases, explicit conversion operators are not required in Kotlin, but Kotlin has "is-checks" for immutable values and automatically inserts conversions when needed
fun demo(x: Any) {
if (x is String) {
print(x.length) // x is automatically converted to a string
}
}
5. Type Inference
In Kotlin, it is not necessary to explicitly specify the type of each variable.
fun main(args: Array < String > ) {
val text = 10 //No need to display the variable type, Kotlin automatically recognizes it as an Int type
println(text)
}
6. Functional Programming
An important difference between Kotlin and Java is that Kotlin is a functional programming language. Kotlin consists of many useful methods, including higher-order functions, lambda expressions, operator overloading, lazy evaluation, and more. Functional programming makes Kotlin more convenient for collections:
fun main(args: Array < String > ) {
val numbers = arrayListOf(15, -5, 11, -39)
val nonNegativeNumbers = numbers. filter {
it >= 0
}
println(nonNegativeNumbers)
}
A higher-order function is a function whose parameter is a function, or whose return value is a function, and one of which is satisfied is a higher-order function. Consider the following code:
fun alphaNum(func: () -> Unit) {}
In the above code, "func" is the name of the parameter
and "() -> Unit" is the function type. In this case, func is a
function that takes no arguments and doesn't return any value.
The essence of Lambda expressions is actually anonymous functions, because they are implemented through anonymous functions in their underlying implementation. Lambda is the foundation of functional programming, and its syntax is quite simple. An example of a lambda expression:
val sum: (Int, Int) -> Int = {
x,
y -> x + y
}
In the above example we simply declared a variable "sum" which takes two integers and adds them together and returns the sum as an integer, then we simply use "sum(2, 2)" to call it.
Summarize
From the above comparison, we can see that for Android development, Kotlin is obviously better than Java. The reason for this is that Kotlin has good interoperability with Java, the cost of migrating from Java to Kotlin is low, and Kotlin has many better improvements on the basis of Java. It can be said that Kotlin is actually standing on the shoulders of the giant Java. The appearance of Kotlin was born to improve Java. Boldly predict that in the near future Kotlin will be the first language for enterprise applications and mobile devices.