Working with Data Types and Type Inference in Kotlin

Course: Android App Development

Topic: Working with Data Types and Type Inference

Course Link: Android App Development Course

Demo Link: Register for Course Demo

Website: JustAcademy

1. Introduction to Data Types in Kotlin

Data types are an essential part of Kotlin programming for Android development. They define what kind of value a variable can store, such as a number, text, Boolean value, or collection of items. Understanding data types helps developers write reliable, readable, and efficient applications.

Kotlin is a statically typed programming language. This means that every expression has a type determined by the compiler, either explicitly through a declaration or automatically through type inference. Kotlin also provides strong type safety, helping developers identify many programming errors before running an application.

For example, an Android application may use integers to store a user's age, strings to display a username, Boolean values to manage login status, and floating-point numbers to represent prices or measurements.

Example

fun main() {
    val userName: String = "Rahul"
    val age: Int = 22
    val isLoggedIn: Boolean = true

    println(userName)
    println(age)
    println(isLoggedIn)
}

In this example, userName stores text, age stores a whole number, and isLoggedIn stores a Boolean value.

2. Learning Objectives

After completing this topic, learners should be able to:

• Understand the purpose of data types in Kotlin.
• Identify Kotlin's basic numeric, character, string, and Boolean types.
• Declare variables using explicit type annotations.
• Understand how Kotlin's type inference works.
• Differentiate between val and var.
• Work with nullable and non-nullable types.
• Perform type conversions safely.
• Apply data types and type inference to Android application development.
• Recognize common type-related compilation errors.

3. Understanding Variables in Kotlin

A variable is a named reference used to hold a value that can be accessed within a program. In Kotlin, variables are commonly declared using the keywords val and var.

3.1 The val Keyword

The val keyword declares a read-only variable. Once its value has been initialized, the variable cannot be reassigned. However, if the value refers to a mutable object, the object's contents may still be changeable.

val appName = "My Android App"
val maxUsers = 100

println(appName)
println(maxUsers)

Trying to assign another value to appName after initialization causes a compilation error.

3.2 The var Keyword

The var keyword declares a variable that can be reassigned. It is useful when a value must change while the application is running.

var counter = 0

counter = 1
counter = 2

println(counter)

The output is 2 because the variable is reassigned twice.

3.3 Difference Between val and var

4. Basic Data Types in Kotlin

Kotlin provides several fundamental types for representing different kinds of information. The compiler checks how these types are used and prevents incompatible operations.

4.1 Integer Types

Integer types represent whole numbers without fractional parts. Kotlin provides several integer types with different storage sizes and value ranges.

Important: Kotlin usually infers an integer literal as Int when it fits in that type's range. Use the L suffix to explicitly create a Long literal.

val productCount = 120
val totalViews = 5000000000L

println(productCount)
println(totalViews)

4.2 Floating-Point Types

Floating-point types represent numbers with fractional parts. Kotlin supports Float and Double.

Decimal literals are inferred as Double by default. A Float literal generally uses the f or F suffix.

val temperature = 36.6
val progress = 75.5f

println(temperature)
println(progress)

Floating-point arithmetic can introduce rounding errors. For financial calculations, consider using BigDecimal where appropriate rather than relying on Float or Double for exact decimal arithmetic.

4.3 Boolean Type

The Boolean type represents one of two logical values: true or false. It is frequently used in conditions, validation, and application state.

val isInternetAvailable = true
val isPaymentComplete = false

if (isInternetAvailable) {
    println("Internet is available")
}

In an Android application, Boolean values can control whether a button is enabled, whether a user is authenticated, or whether a form has passed validation.

4.4 Character Type

The Char type represents a single character. Character literals are enclosed in single quotation marks.

val grade: Char = 'A'
val initial: Char = 'R'

println(grade)
println(initial)

A character literal such as 'A' is different from the string literal "A". The former is a Char, while the latter is a String.

4.5 String Type

The String type represents text. Strings are enclosed in double quotation marks and can contain names, messages, labels, and other textual information.

val userName = "Priya"
val message = "Welcome to Android Development"

println(userName)
println(message)

Kotlin strings support string templates, which allow variables and expressions to be inserted into text using the dollar sign.

val name = "Priya"
val age = 21

println("My name is $name")
println("Next year I will be ${age + 1}")

String templates are useful for creating dynamic messages, displaying user information, and preparing text for Android user interfaces.

5. Understanding Type Inference

Type inference is a Kotlin language feature that allows the compiler to determine the type of a variable or expression from the available context. It reduces the need to write explicit type annotations everywhere.

Instead of specifying a type manually, developers can initialize a variable with a value and allow Kotlin to infer the type.

5.1 Example of Type Inference

val name = "Aarav"
val age = 24
val price = 199.99
val isActive = true

println(name)
println(age)
println(price)
println(isActive)

Kotlin infers the types as follows:

Even though the types are not explicitly written, Kotlin still checks them during compilation. Type inference does not make Kotlin a dynamically typed language.

5.2 Explicit Type Declaration

An explicit type declaration specifies the variable's type using a colon followed by the type name.

val name: String = "Aarav"
val age: Int = 24
val price: Double = 199.99
val isActive: Boolean = true

Explicit declarations are helpful when they improve readability, document the intended type, or are required because the compiler cannot infer the type from an initializer.

5.3 Type Inference Without an Initial Value

When a local variable is declared without an initializer, Kotlin generally needs an explicit type so that the variable's type is known.

var userAge: Int
userAge = 25

println(userAge)

Here, the type is explicitly declared because no initial value is available for inference at the declaration point.

For a local variable, Kotlin also supports definite assignment analysis. The compiler must be able to determine that the variable has been initialized before it is read.

6. How Kotlin Determines Types

Kotlin determines types by examining initial values, expressions, function return types, and the expected type supplied by the surrounding context.

6.1 Inference from Literals

val count = 10
val amount = 25.75
val letter = 'K'
val title = "Android"

println(count)
println(amount)
println(letter)
println(title)

The compiler uses the literal forms to infer Int, Double, Char, and String respectively.

6.2 Inference from Expressions

val firstNumber = 10
val secondNumber = 20
val total = firstNumber + secondNumber

println(total)

Both operands are integers, so the addition expression produces an Int in this example. The compiler infers the type of total from the expression.

6.3 Inference from Function Return Types

fun getUserName() = "Ananya"
fun getUserAge() = 28

fun main() {
    val name = getUserName()
    val age = getUserAge()

    println(name)
    println(age)
}

Kotlin infers the return type of getUserName() as String and the return type of getUserAge() as Int. The variables that receive these return values can also have their types inferred.

6.4 Inference from Context

In some situations, Kotlin uses an expected type to determine how an expression should be interpreted.

val numbers: List<Int> = listOf(1, 2, 3)
val names: List<String> = listOf("Asha", "Ravi")

println(numbers)
println(names)

The declared types provide context for the generic element types. Kotlin's type inference can use this context to check that the values are compatible with the expected types.

7. Type Safety in Kotlin

Type safety means that Kotlin checks whether values and operations are compatible with their declared or inferred types. This helps prevent invalid operations and catches many mistakes before the program runs.

7.1 Invalid Type Assignment

val age: Int = 25

// Compilation error:
// val userAge: Int = "Twenty Five"

The string "Twenty Five" cannot be assigned directly to an Int variable. The compiler reports a type mismatch.

7.2 Incompatible Operations

val number = 10
val text = "Hello"

// Compilation error:
// println(number + text)

Kotlin does not automatically treat every value as a string or number. Convert values explicitly when an operation requires a different type.

7.3 Benefits of Type Safety

• Detects many errors at compile time.
• Improves code readability and maintainability.
• Reduces unexpected behavior caused by incompatible values.
• Makes refactoring easier by exposing type mismatches.
• Helps developers design clearer interfaces between application components.

8. Type Conversion in Kotlin

Kotlin does not automatically convert numeric types in the same way some other languages do. When a conversion is required, developers use explicit conversion functions.

8.1 Converting Int to Double

val number: Int = 25
val decimalNumber: Double = number.toDouble()

println(decimalNumber)

The toDouble() function converts the integer value to a Double representation.

8.2 Converting Double to Int

val price: Double = 99.95
val roundedDownPrice: Int = price.toInt()

println(roundedDownPrice)

The output is 99. Converting a Double to Int removes the fractional part toward zero; it does not perform mathematical rounding.

8.3 Common Numeric Conversion Functions

Conversions to narrower numeric types can lose information or produce values that do not represent the original number exactly. Choose conversions carefully.

9. Nullable and Non-Nullable Types

Kotlin distinguishes between types that can hold null and types that cannot. This feature is a central part of Kotlin's null safety system.

9.1 Non-Nullable Variables

By default, a variable declared with a regular type cannot contain null.

var userName: String = "Rohan"

// Compilation error:
// userName = null

9.2 Nullable Variables

To allow a variable to hold null, add a question mark after the type name.

var userName: String? = "Rohan"

userName = null

println(userName)

This distinction is useful when a value may be missing, such as an optional profile description or a search field that has not been filled in.

9.3 Safe Call Operator

The safe call operator ?. accesses a property or method only when the receiver is not null. Otherwise, the result is null.

val userName: String? = null
val nameLength = userName?.length

println(nameLength)

The output is null. No null-pointer exception is caused by this safe call.

9.4 Elvis Operator

The Elvis operator ?: provides a fallback value when an expression on the left is null.

val userName: String? = null
val displayName = userName ?: "Guest"

println(displayName)

The output is Guest. This is useful when displaying default values in Android interfaces.

9.5 Non-Null Assertion Operator

The !! operator asserts that a value is not null. If the value is null, the expression throws a NullPointerException.

val userName: String? = "Rohan"
val length = userName!!.length

println(length)

Although this example works because the value is not null, avoid using !! unnecessarily. Prefer safe calls, null checks, or fallback values whenever possible.

10. Type Inference with Collections

Kotlin can infer collection types from their elements. Collections are commonly used to store lists of products, user records, categories, and other application data.

10.1 Lists

val fruits = listOf("Apple", "Banana", "Mango")
val scores = listOf(80, 90, 95)

println(fruits)
println(scores)

The compiler infers List<String> for fruits and List<Int> for scores.

10.2 Mutable Lists

val tasks = mutableListOf("Learn Kotlin", "Build an App")

tasks.add("Test the App")

println(tasks)

The variable tasks cannot be reassigned because it is declared with val, but the mutable list it references can be modified.

10.3 Sets

val uniqueNumbers = setOf(1, 2, 3, 3, 4)

println(uniqueNumbers)

A Set stores unique elements, so duplicate values are not represented as separate elements.

10.4 Maps

val userDetails = mapOf(
    "name" to "Aarav",
    "city" to "Mumbai"
)

println(userDetails["name"])
println(userDetails["city"])

Kotlin infers a map with String keys and String values in this example. Map lookups can return null when a key is missing, so the result should be handled appropriately.

11. Type Inference in Android Development

Data types and type inference are used throughout Android applications, including user interfaces, event handling, application logic, and data processing.

11.1 Storing User Input

val userName: String = "Neha"
val age: Int = 23
val isRegistered: Boolean = true

println("Name: $userName")
println("Age: $age")
println("Registered: $isRegistered")

These variables can represent information collected during registration or profile creation.

11.2 Working with Button Clicks

In an Android Activity using traditional Views, a click listener can be written as follows:

button.setOnClickListener {
    val message = "Button clicked"
    textView.text = message
}

Kotlin infers message as a String. The click listener runs when the button is tapped, and the TextView displays the message. This example assumes that button and textView have already been initialized correctly.

11.3 Handling Numeric Input

val inputText = "25"
val age = inputText.toIntOrNull()

if (age != null) {
    println("Age entered: $age")
} else {
    println("Please enter a valid whole number")
}

The toIntOrNull() function safely attempts to parse the string as an integer. It returns null if the text cannot be converted, helping prevent crashes caused by invalid numeric input.

11.4 Using Types with Jetpack Compose

Jetpack Compose uses Kotlin functions and types to build declarative user interfaces. Variables can hold text, numbers, and UI state.

import androidx.compose.material3.Text
import androidx.compose.runtime.Composable

@Composable
fun WelcomeMessage() {
    val userName = "Ananya"
    Text(text = "Welcome, $userName!")
}

The compiler infers userName as a String. The Text composable receives a String through its text parameter. This example assumes a project configured with Jetpack Compose and Material 3.

12. Common Mistakes and Troubleshooting

Example: Correcting a Type Mismatch

Incorrect code:

// Compilation error
val age: Int = "25"

Correct code when the input is known to be numeric:

val ageText = "25"
val age = ageText.toIntOrNull()

if (age != null) {
    println(age + 1)
}

Using a nullable conversion makes the program safer because invalid text does not immediately cause a number-format exception.

13. Best Practices for Data Types and Type Inference

• Prefer val unless a variable genuinely needs reassignment.
• Use type inference when the initializer makes the intended type obvious.
• Add explicit type annotations when they improve clarity or are necessary for initialization.
• Choose numeric types based on the expected range and precision.
• Use nullable types only when a value may legitimately be absent.
• Avoid unnecessary use of the non-null assertion operator !!.
• Validate user input before converting it to numeric values.
• Use meaningful variable names that explain the purpose of each value.
• Understand the difference between a read-only reference and an immutable object.
• Follow consistent naming conventions, such as camelCase for variables and functions.
• Use suitable collection types for the required data and modification behavior.
• Test edge cases, including empty input, null values, and numbers outside the expected range.

14. Practical Exercises

Exercise 1: Declare Basic Variables

Create variables for a student's name, age, percentage, grade, and enrollment status. Allow Kotlin to infer the types where possible, and print every value.

Exercise 2: Explicit Types Versus Inference

Declare five variables using explicit types and five using type inference. Compare the readability and identify the type inferred by the compiler for each variable.

Exercise 3: Numeric Conversion

Create an Int variable and convert it into Long, Float, and Double. Print the converted values and explain the difference between the types.

Exercise 4: Nullable User Profile

Create a nullable String variable for a user's optional profile description. Display a default message when the description is null using the Elvis operator.

Exercise 5: Android Registration Form

Design the Kotlin logic for a registration form with a username, age, email address, and terms acceptance status. Choose suitable data types and validate numeric input safely.

Exercise 6: Product Price Calculator

Create variables for product price, quantity, and discount. Calculate the total cost and examine whether the selected numeric types are appropriate for the calculation.

15. Mini Project: Student Information Manager

Project Objective: Build a simple Kotlin program that stores and displays student information while demonstrating data types, type inference, null safety, and collections.

Requirements

• Store the student's name as a String.
• Store the student's age as an Int.
• Store the student's grade as a Char.
• Store the percentage as a Double.
• Store whether the student is enrolled as a Boolean.
• Allow an optional middle name using a nullable String.
• Use a list to store multiple subject names.
• Display a default value when optional information is missing.

Sample Implementation

fun main() {
    val studentName = "Karan"
    val age = 20
    val grade = 'A'
    val percentage = 87.5
    val isEnrolled = true

    val middleName: String? = null
    val subjects = listOf("Kotlin", "Android", "Database")

    val displayMiddleName = middleName ?: "Not provided"

    println("Student: $studentName")
    println("Middle Name: $displayMiddleName")
    println("Age: $age")
    println("Grade: $grade")
    println("Percentage: $percentage")
    println("Enrolled: $isEnrolled")
    println("Subjects: $subjects")
}

Expected Learning Outcomes

• Recognize how Kotlin infers common variable types.
• Understand when explicit type declarations are useful.
• Work with nullable and non-nullable variables.
• Represent related information using collections.
• Apply Kotlin fundamentals to small Android application features.

16. Interview Questions and Answers

Q1. What is a data type in Kotlin?

A data type determines the kind of value an expression can represent and the operations that can be performed on it. Examples include Int, Double, String, Char, and Boolean.

Q2. What is type inference?

Type inference is the compiler's ability to determine a variable's or expression's type from its initializer and surrounding context without requiring an explicit type annotation in every case.

Q3. Is Kotlin statically typed?

Yes. Kotlin is statically typed because types are checked during compilation, even when the developer does not explicitly write every type.

Q4. What is the difference between val and var?

val declares a read-only reference that cannot be reassigned after initialization, whereas var declares a variable that can be reassigned.

Q5. What is the default inferred type of an integer literal?

An integer literal is normally inferred as Int when its value fits within the Int range. Use the L suffix to explicitly indicate a Long literal.

Q6. What is the difference between Float and Double?

Float uses 32-bit floating-point representation, while Double uses 64-bit representation and generally offers greater precision. Decimal literals are inferred as Double by default.

Q7. How does Kotlin handle null values?

Kotlin distinguishes nullable types, declared with a question mark, from non-nullable types. It provides safe calls, null checks, and the Elvis operator to help developers handle missing values.

Q8. What does the safe call operator do?

The ?. operator accesses a property or calls a function only when the receiver is not null. Otherwise, the expression evaluates to null.

Q9. What is the Elvis operator?

The ?: operator returns the left-hand expression when it is not null and otherwise returns a fallback expression on the right.

Q10. Does Kotlin automatically convert Int to Double?

Kotlin does not provide implicit numeric widening conversions in ordinary assignments. Use explicit conversion functions such as toDouble().

Q11. What happens when Double is converted to Int?

The fractional portion is discarded toward zero. For example, 12.9.toInt() produces 12 rather than 13.

Q12. Can a val reference point to a mutable list?

Yes. The reference cannot be reassigned, but the referenced object may still allow changes if it is mutable.

Q13. What happens when Kotlin cannot infer a variable's type?

The compiler may report that the type cannot be inferred. Providing an explicit type annotation or a suitable initializer can resolve the issue.

Q14. Why is toIntOrNull() useful?

It attempts to parse a String as an Int and returns null if parsing fails, allowing the program to handle invalid input without a number-format exception.

Q15. Why are data types important in Android development?

They help represent application data correctly, improve compile-time checking, support reliable calculations, and make code easier to maintain.

17. Quick Revision Checklist

• Understand the difference between val and var.
• Recognize Byte, Short, Int, Long, Float, Double, Char, String, and Boolean.
• Explain how Kotlin infers types from initial values.
• Know when to specify a type explicitly.
• Use numeric conversion functions correctly.
• Distinguish nullable and non-nullable types.
• Apply safe calls and the Elvis operator.
• Understand type inference in expressions, functions, and collections.
• Validate user input before parsing it.
• Apply data types to Android Activities and Jetpack Compose interfaces.

18. Conclusion

Data types and type inference are foundational concepts in Kotlin and Android development. Data types describe the values that a program works with, while type inference allows Kotlin to determine types automatically from initializers and context. Together, they support concise, readable, and type-safe code.

Developers should understand numeric types, strings, Boolean values, characters, collections, explicit conversions, and null safety before building more advanced Android features. Practicing these concepts through small programs and Android projects helps build a strong foundation for application development.

Learn Android App Development with JustAcademy

Explore the Android App Development course to strengthen your Kotlin programming skills and learn how to build Android applications.

Course Details: View Android App Development Course

Book a Demo: Register for Course Demo

Visit JustAcademy: https://www.justacademy.co/