Kotlin is a modern, statically-typed programming language that runs on the Java Virtual Machine (JVM). Developed by JetBrains, Kotlin is the preferred language for Android development and offers seamless interoperability with Java.
What is Kotlin?
Kotlin is a modern, statically-typed programming language developed by JetBrains that runs on the Java Virtual Machine (JVM). Introduced in 2011 and officially supported by Google for Android development since 2017, Kotlin combines the best features of Java with modern programming concepts to create a more concise, safe, and expressive language.
Key Features
Null Safety
Kotlin's type system distinguishes between nullable and non-nullable types, preventing null pointer exceptions at compile time.
// Non-nullable type (cannot be null)
var name: String = "Alice"
// name = null // This would cause a compile error
// Nullable type (can be null)
var middleName: String? = null
middleName = "Jane"
// Safe call operator
val length = middleName?.length // Returns null if middleName is null
// Elvis operator for default values
val displayName = middleName ?: "No middle name"Type Inference
Kotlin can automatically infer types, reducing boilerplate code while maintaining type safety.
// Type inference
val name = "Alice" // String
val age = 25 // Int
val height = 5.6 // Double
val isStudent = true // Boolean
// Collections with type inference
val numbers = listOf(1, 2, 3, 4, 5) // List<Int>
val names = setOf("Alice", "Bob") // Set<String>
val scores = mapOf("Alice" to 95, "Bob" to 87) // Map<String, Int>Extension Functions
Kotlin allows you to add new functions to existing classes without inheritance.
// Extension function for String
fun String.addExclamation(): String {
return this + "!"
}
// Usage
val greeting = "Hello"
println(greeting.addExclamation()) // Output: Hello!
// Extension function for collections
fun List<Int>.sum(): Int {
return this.reduce { acc, num -> acc + num }
}
val numbers = listOf(1, 2, 3, 4, 5)
println(numbers.sum()) // Output: 15Android Development
Android with Kotlin
Kotlin is the preferred language for Android development, offering better syntax and safety than Java.
// Android Activity example
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val button = findViewById<Button>(R.id.button)
button.setOnClickListener {
Toast.makeText(this, "Button clicked!", Toast.LENGTH_SHORT).show()
}
}
}Kotlin Android Extensions
Kotlin provides convenient extensions for Android development.
// View binding with synthetic imports
import kotlinx.android.synthetic.main.activity_main.*
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
// Direct access to views by ID
button.setOnClickListener {
textView.text = "Hello from Kotlin!"
}
}
}Coroutines
Kotlin's coroutines provide a way to write asynchronous, non-blocking code in a sequential manner.
import kotlinx.coroutines.*
// Coroutine function
suspend fun fetchUserData(): String {
delay(1000) // Simulate network delay
return "User data"
}
// Using coroutines
fun main() = runBlocking {
println("Starting...")
val result = async { fetchUserData() }
println("Fetching data...")
val data = result.await()
println("Received: $data")
}
// Coroutines in Android
class MainActivity : AppCompatActivity() {
private val scope = CoroutineScope(Dispatchers.Main + Job())
fun loadData() {
scope.launch {
val data = withContext(Dispatchers.IO) {
// Perform network request
fetchUserData()
}
updateUI(data)
}
}
}Data Classes
Kotlin's data classes automatically generate useful methods like equals(), hashCode(), toString(), and copy().
// Data class
data class User(
val id: Int,
val name: String,
val email: String,
val age: Int = 0
)
// Usage
val user1 = User(1, "Alice", "alice@example.com", 25)
val user2 = user1.copy(name = "Alice Smith")
println(user1) // User(id=1, name=Alice, email=alice@example.com, age=25)
println(user1 == user2) // false
println(user1.copy(name = "Alice") == user1) // trueSmart Casts
Kotlin's smart cast feature automatically casts types when it's safe to do so.
fun demo(x: Any) {
if (x is String) {
// x is automatically cast to String
println(x.length) // No explicit cast needed
}
}
// Smart cast with when expression
fun describe(obj: Any): String = when (obj) {
is String -> "String with length ${obj.length}"
is Int -> "Integer: $obj"
is Boolean -> "Boolean: $obj"
else -> "Unknown type"
}Higher-Order Functions
Kotlin supports higher-order functions and lambda expressions for functional programming.
// Higher-order function
fun <T> List<T>.filter(predicate: (T) -> Boolean): List<T> {
val result = mutableListOf<T>()
for (item in this) {
if (predicate(item)) {
result.add(item)
}
}
return result
}
// Usage with lambda
val numbers = listOf(1, 2, 3, 4, 5, 6)
val evens = numbers.filter { it % 2 == 0 }
val greaterThan3 = numbers.filter { it > 3 }
// Built-in higher-order functions
val doubled = numbers.map { it * 2 }
val sum = numbers.reduce { acc, num -> acc + num }
val hasEven = numbers.any { it % 2 == 0 }Java Interoperability
Kotlin is fully interoperable with Java, allowing gradual migration and mixed codebases.
// Kotlin class that can be used from Java
class UserService {
fun getUser(id: Int): User? {
return User(id, "User $id", "user$id@example.com")
}
@JvmOverloads // Generates multiple overloaded methods for Java
fun createUser(name: String, email: String, age: Int = 0): User {
return User(0, name, email, age)
}
}
// Using Java classes in Kotlin
val javaList = ArrayList<String>()
javaList.add("Kotlin")
javaList.add("Java")
// Kotlin extensions work with Java classes
val size = javaList.size
val first = javaList.firstOrNull()Getting Started
Installation
Kotlin can be used with various build tools:
# Using Gradle
plugins {
kotlin("jvm") version "1.8.0"
}
# Using Maven
<plugin>
<groupId>org.jetbrains.kotlin</groupId>
<artifactId>kotlin-maven-plugin</artifactId>
<version>1.8.0</version>
</plugin>First Kotlin Program
// hello.kt
fun main() {
println("Hello, Kotlin World!")
}
// Run with: kotlin hello.ktAndroid Studio Setup
1. Open Android Studio
2. Create new project
3. Select "Kotlin" as the language
4. Start coding in Kotlin!
Best Practices
Code Style
Null Safety
Performance
Kotlin has become the standard for modern Android development and is increasingly popular for server-side development, offering a more productive and safer alternative to Java while maintaining full interoperability.