From Java to Kotlin: A Java Developer's Guide to Kotlin Basics

Introduction

As a Java Developer, you may have heard of Kotlin, a modern language created by Jet Brains that's gaining popularity for its conciseness and safety. Kotlin is fully interoperable with java, making it easy to adopt without a complete rewrite.

In this guide, we'll cover Kotlin basics, highlighting the key differences and improvements over Java. Whether you're starting a new project or enhancing an existing one, this article will help you quickly get up to speed with Kotlin's syntax, null safety, and powerful features.

Kotlin Syntax Overview:

With an emphasis on minimizing boilerplate code, Kotlin's syntax is intended to be clear and expressive. Many of the principles will seem familiar to Java developers, but Kotlin makes them easier to understand and better.

Variables and Types:

Kotlin uses val for immutable variables and var for mutable ones. Unlike Java, you don’t always need to specify the type because Kotlin can infer it.

val name: String = "Kotlin"   // Immutable
var age: Int = 25             // Mutable

Nullable:

Kotlin also supports nullable types, marked with a ?.

var name: String? = null   // Nullable type

Type Inference:

Kotlin often infers the type of a variable, making the code cleaner and easier to read.

val name = "Kotlin"   // Inferred as String
var age = 25           // Inferred as Int

Null Safety:

Kotlin eliminates the risk of NullPointerException with built-in null safety. You can define nullable types using ?, and safely access them with ?.

val length = name?.length   // Returns null if 'name' is null

The Elvis operator ?: provides a default value when a nullable variable is null.

val length = name?.length ?: 0  // Returns 0 if 'name' is null

Functions:

In Kotlin, functions can be written in a simplified and more flexible way using features like single-expression functions, default parameters, named arguments, higher-order functions, and extension functions. Here's how you can make your functions cleaner and more concise:

Single-Expression Functions:

Instead of using { return ... }, you can use = for simple functions.

// Traditional function
fun square(x: Int): Int {
    return x * x
}

// Simplified version
fun square(x: Int) = x * x

println(square(5)) // Output: 25

Default parameters:

You can provide default values to avoid overloading functions.

fun greet(name: String = "Guest") = "Hello, $name!"

println(greet())       // Output: Hello, Guest!
println(greet("John")) // Output: Hello, John!

Named Arguments (Flexible):

Named arguments allow calling functions in any order.

fun createUser(name: String, age: Int, country: String) = "$name, $age years old from $country."

println(createUser(age = 25, name = "Alice", country = "USA"))
// Output: Alice, 25 years old from USA.

Lambda & Higher-Order Functions:

Kotlin supports passing functions as arguments.

fun operate(x: Int, y: Int, op: (Int, Int) -> Int): Int {
    return op(x, y)
}

// Using lambda functions
println(operate(5, 3) { a, b -> a + b }) // Output: 8
println(operate(5, 3) { a, b -> a * b }) // Output: 15

Extension Functions (Adding Functions to Existing Classes):

You can add functions to existing classes without modifying them.

fun String.firstChar(): Char = this[0]

println("Kotlin".firstChar()) // Output: K

Inline Functions:

In-lining reduces function call overhead.

inline fun repeatMessage(times: Int, action: () -> Unit) {
    for (i in 1..times) action()
}

repeatMessage(3) { println("Hello") }
// Output:
// Hello
// Hello
// Hello

Classes and Inheritance:

In Kotlin, classes are simpler to work with compared to Java. Highlight how classes are declared and the differences with Java’s inheritance model.

• Class Definition: Primary constructors are part of the class declaration.
• Inheritance: Kotlin classes are final by default. To inherit from a class, use open.

open class Animal(val name: String)

class Dog(name: String) : Animal(name) {
    fun bark() {
        println("Woof!")
    }
}

Data Classes: Automatically Implemented Methods

One of Kotlin's most loved features is the data class, which automatically provides toString(), equals(), and other methods.

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

Control Flow: When and If Expressions

Kotlin’s when expression is more powerful than Java’s switch, and if is an expression that can return a value.

• If Expression:

val max = if (a > b) a else b

• When Expression:

when (x) {
    1 -> println("One")
    2 -> println("Two")
    else -> println("Unknown")
}

Collections: Immutable and Mutable List Operations

Kotlin’s standard library includes powerful features for working with collections.

• Immutable Collections: Use listOf().
• Mutable Collections: Use mutableListOf() and modify them as needed.

val immutableList = listOf(1, 2, 3)   // Immutable
val mutableList = mutableListOf(1, 2, 3)   // Mutable
mutableList.add(4)

Lambda Expressions: Simplifying Code with Function Literals

Kotlin makes working with functional programming easy with lambda expressions. Java developers will find lambdas in Kotlin very similar to Java 8's lambda expressions.

val add = { x: Int, y: Int -> x + y }
println(add(2, 3))  // Outputs 5

Call to Action

Invite readers to share their experience with Kotlin or ask any questions in the comments. You could also suggest they try out Kotlin in their Java projects or explore resources like the official Kotlin documentation.