If you are learning Kotlin for the first time, one of the first concepts you need to understand is variables and data types.
Variables are used to store information in a Kotlin program, while data types define what kind of information a variable can contain.
For example, an application may need to store:
- A user’s name
- Age
- Email address
- Product price
- Login status
- Number of products
- A list of items
Kotlin provides a simple and modern syntax for declaring variables and working with different types of data.
In this complete beginner’s guide, you’ll learn:
- What variables are in Kotlin
valvsvar- Kotlin data types
- Numbers
- Strings
- Characters
- Booleans
- Arrays
- Type inference
- Explicit type declarations
- Nullable types
- Type conversion
- Constants
- Variable naming rules
- Mutable vs immutable variables
- Common mistakes
- Practical Kotlin examples
- Frequently asked questions
What Is a Variable in Kotlin?
A variable is a named location used to store a value.
For example:
val name = "Ankit"
Here:
valis the keyword used to declare the variable.nameis the variable name."Ankit"is the value stored in the variable.
You can think of it like this:
Variable → name
Value → "Ankit"
Another example:
val age = 25
Here, age stores the value 25.
How to Declare a Variable in Kotlin
Kotlin provides two main keywords for variables:
val
var
The difference between them is very important.
val in Kotlin
val is used when a variable should not be reassigned after its initial value is assigned.
Example:
val name = "John"
You cannot later write:
name = "David"
This produces a compilation error because a val variable cannot be reassigned.
A simple way to remember it:
val → read-only reference
For example:
val country = "India"
val age = 25
val email = "user@example.com"
These values cannot be reassigned.
var in Kotlin
var is used when the value of a variable needs to change.
Example:
var age = 25
age = 26
This is valid because var allows reassignment.
Another example:
var username = "John"
username = "David"
The value changes from "John" to "David".
Remember:
val → cannot be reassigned
var → can be reassigned
val vs var
| Feature | val | var |
|---|---|---|
| Reassignment | No | Yes |
| Mutable reference | No | Yes |
| Recommended default | Yes | When required |
| Example | val name = "John" | var age = 20 |
A good Kotlin programming practice is to use val by default and use var only when the value genuinely needs to change.
Example of val and var
val firstName = "John"
var age = 20
age = 21
Here:
firstName → cannot be reassigned
age → can be reassigned
What Are Data Types in Kotlin?
A data type defines what kind of value a variable can store.
For example:
val age: Int = 25
Here:
age → variable
Int → data type
25 → value
Kotlin has several commonly used data types.
The major categories include:
Numbers
├── Byte
├── Short
├── Int
└── Long
Floating Point
├── Float
└── Double
Text
├── Char
└── String
Boolean
└── Boolean
Collections / Structures
├── Array
├── List
├── Set
└── Map
Kotlin Number Data Types
Kotlin provides several data types for representing numbers.
The most commonly used are:
ByteShortIntLongFloatDouble
Int in Kotlin
Int is commonly used for whole numbers.
Example:
val age: Int = 25
Other examples:
val count: Int = 100
val year: Int = 2026
val score: Int = 95
For most normal integer calculations, Int is usually sufficient.
Long in Kotlin
Long is used for larger whole numbers.
Example:
val population: Long = 1400000000L
The L suffix indicates a Long literal.
Another example:
val distance: Long = 500000L
Use Long when the number may exceed the range of an Int.
Byte in Kotlin
Byte is used for small integer values.
Example:
val temperature: Byte = 25
A Byte uses less memory than an Int, but it is not commonly needed in everyday application code.
It is more useful when working with:
- Binary data
- Low-level data
- Network protocols
- Memory-sensitive operations
Short in Kotlin
Short represents a small-range integer.
Example:
val number: Short = 1000
Like Byte, Short is less commonly used in typical application development.
Float in Kotlin
Float is used for decimal numbers with single-precision floating-point representation.
Example:
val temperature: Float = 36.5F
The F suffix indicates a Float.
Another example:
val rating: Float = 4.5F
Double in Kotlin
Double is used for decimal numbers with double-precision floating-point representation.
Example:
val price: Double = 99.99
You normally don’t need a suffix for a Double.
Example:
val percentage = 85.75
Kotlin generally infers this as Double.
Float vs Double
| Feature | Float | Double |
|---|---|---|
| Precision | Lower | Higher |
| Memory | Lower | Higher |
| Common usage | Specialized cases | General decimal calculations |
| Example | 10.5F | 10.5 |
For many application-level calculations, Double is more commonly used.
However, financial calculations should generally not rely on binary floating-point types for exact monetary representation. Use an appropriate decimal representation or integer smallest-unit approach when exact currency calculations are required.
Kotlin String Data Type
A String stores text.
Example:
val name: String = "Ankit"
Other examples:
val message = "Hello Kotlin"
val email = "user@example.com"
val city = "Jaipur"
Strings can contain:
- Letters
- Numbers
- Spaces
- Symbols
- Special characters
Example:
val message = "Welcome to Kotlin!"
Kotlin String Templates
Kotlin makes it easy to insert variables into strings.
Example:
val name = "John"
val age = 25
println("My name is $name and I am $age years old.")
Output:
My name is John and I am 25 years old.
You can also use expressions inside ${}.
val price = 100
val quantity = 3
println("Total: ${price * quantity}")
Output:
Total: 300
String templates are one of Kotlin’s convenient language features.
Kotlin Char Data Type
Char stores a single character.
Example:
val grade: Char = 'A'
Notice the difference:
'A' // Char
"A" // String
A Char uses single quotes, while a String uses double quotes.
More examples:
val firstLetter: Char = 'K'
val symbol: Char = '#'
val number: Char = '5'
Kotlin Boolean Data Type
Boolean represents either:
true
false
Example:
val isLoggedIn: Boolean = true
Another example:
val isVerified = false
Boolean values are commonly used in conditions.
if (isLoggedIn) {
println("Welcome!")
}
Kotlin Arrays
An Array stores multiple values of the same type.
Example:
val numbers = arrayOf(10, 20, 30, 40)
You can access an item using its index:
println(numbers[0])
Output:
10
Kotlin arrays use zero-based indexing.
That means:
Index 0 → first item
Index 1 → second item
Index 2 → third item
Creating a Typed Array
You can explicitly specify the type:
val numbers: Array<Int> = arrayOf(10, 20, 30)
You can also create arrays for other types:
val names: Array<String> =
arrayOf("John", "David", "Alex")
Kotlin Type Inference
One of Kotlin’s useful features is type inference.
You don’t always need to explicitly specify the data type.
For example:
val age = 25
Kotlin understands that age is an Int.
Similarly:
val name = "John"
Kotlin understands that name is a String.
And:
val price = 99.99
Kotlin infers Double.
Explicit Type Declaration
You can also explicitly specify the type.
val age: Int = 25
The syntax is:
variableName: DataType
For example:
val name: String = "John"
val age: Int = 25
val price: Double = 99.99
val active: Boolean = true
Type Inference vs Explicit Types
Type Inference
val age = 25
Explicit Type
val age: Int = 25
Both are valid.
Type inference often makes Kotlin code shorter and easier to read.
Explicit types can be useful when:
- The type isn’t obvious
- You want to document an API
- A declaration requires a specific type
- You’re learning Kotlin and want to understand the types
Kotlin Type Conversion
Kotlin does not automatically convert numeric types in many situations.
For example:
val number: Int = 100
val longNumber: Long = number
This does not work automatically because Int and Long are different types.
You need to convert the value:
val number: Int = 100
val longNumber: Long = number.toLong()
Common Kotlin Type Conversion Functions
Kotlin provides convenient conversion functions.
toByte()
toShort()
toInt()
toLong()
toFloat()
toDouble()
Example:
val number = 100
val doubleNumber = number.toDouble()
val longNumber = number.toLong()
String to Int Conversion
You can convert a string containing a valid number into an integer.
val text = "100"
val number = text.toInt()
Now:
text → String
number → Int
Be careful because invalid input can cause an exception.
For example:
val number = "abc".toInt()
This will fail.
For user input, a safer option is:
val number = "abc".toIntOrNull()
If conversion fails, it returns null.
Int to String Conversion
You can convert an integer to a string:
val age = 25
val text = age.toString()
Now text is a String.
Kotlin Nullable Variables
Kotlin has a powerful feature called null safety.
Normally:
var name: String = "John"
cannot contain null.
If you want a variable to allow null, use ?.
var name: String? = null
This means:
String? → String or null
Why Is Null Safety Important?
Null values can cause runtime errors in many programming languages.
Kotlin tries to make nullability explicit.
For example:
var name: String = "John"
This is non-nullable.
But:
var name: String? = null
is nullable.
Kotlin then requires you to handle the possibility of null.
Safe Call Operator
You can use ?. to safely access a nullable value.
val name: String? = null
println(name?.length)
If name is null, Kotlin doesn’t try to access length.
Elvis Operator
The Elvis operator ?: provides a fallback value.
val name: String? = null
val displayName = name ?: "Guest"
If name is null, displayName becomes:
Guest
Kotlin Constants
Kotlin also supports constants using const val.
Example:
const val API_TIMEOUT = 30
A constant is a value that is known at compile time and is not reassigned.
Constants are commonly declared at the top level or inside objects/companion objects where appropriate.
Example:
const val APP_NAME = "My App"
val Is Not the Same as const val
These two concepts are related but different.
val name = "John"
and:
const val APP_NAME = "My App"
val means the reference cannot be reassigned after initialization.
const val is specifically for compile-time constants and has additional restrictions.
For example, const val can only be used with certain primitive types and String.
Mutable vs Immutable Variables
Understanding mutability is important in Kotlin.
Immutable reference
val name = "John"
You cannot reassign:
name = "David"
Mutable reference
var name = "John"
name = "David"
The second version allows reassignment.
Prefer immutable values whenever possible.
Important: val Does Not Always Mean the Object Is Immutable
This is a common beginner mistake.
Consider:
val numbers = mutableListOf(1, 2, 3)
You cannot assign a completely different list:
numbers = mutableListOf(4, 5, 6)
But you can modify the existing mutable list:
numbers.add(4)
So:
val → reference cannot be reassigned
It does not automatically mean:
object → completely immutable
This distinction becomes important when working with collections and objects.
Kotlin Type Checking
Kotlin provides the is operator to check a value’s type.
Example:
val value: Any = "Hello"
if (value is String) {
println(value.length)
}
Kotlin can often automatically understand the more specific type after the check. This is called smart casting.
Kotlin Any Type
Any is the root type for non-nullable Kotlin types.
Example:
val value: Any = "Hello"
The variable can hold different kinds of non-null values.
For example:
val number: Any = 100
val text: Any = "Kotlin"
val active: Any = true
Kotlin Unit Type
Unit represents the absence of a meaningful return value from a function.
For example:
fun showMessage() {
println("Hello Kotlin")
}
This function effectively returns Unit.
You usually don’t need to explicitly write it.
fun showMessage(): Unit {
println("Hello Kotlin")
}
Both forms are valid.
Kotlin Nothing Type
Nothing represents a value that never exists.
It is commonly used for functions that never successfully return.
For example:
fun fail(): Nothing {
throw IllegalStateException("Something went wrong")
}
A Nothing-returning function can be useful for representing code paths that cannot complete normally.
Kotlin Variables With User Input
Variables are commonly used to store user input.
For example:
print("Enter your name: ")
val name = readln()
println("Hello, $name")
Here:
name → String
The value is read from the user and stored in the variable.
Practical Example: User Profile
Let’s combine several data types.
val name: String = "John"
val age: Int = 25
val height: Double = 5.9
val grade: Char = 'A'
val isStudent: Boolean = true
We have:
name → String
age → Int
height → Double
grade → Char
isStudent → Boolean
Practical Example: Product
Consider an e-commerce product.
val productName = "Laptop"
val price = 79999.99
val quantity = 2
val available = true
Kotlin automatically infers:
productName → String
price → Double
quantity → Int
available → Boolean
Practical Example: Mutable Product Quantity
Suppose the product quantity can change.
var quantity = 1
quantity = 2
quantity = 3
Here var is appropriate because the value changes.
Variable Naming Rules in Kotlin
Kotlin variable names should follow clear naming conventions.
Examples:
val firstName = "John"
val userAge = 25
val productPrice = 100.0
Use camelCase for variable names.
Good:
val userName = "John"
val totalPrice = 500
Avoid:
val usernamevalue = "John"
val UserName = "John"
Class names generally use PascalCase, while variables and functions generally use camelCase.
Kotlin Variable Naming Restrictions
Variable names:
- Can contain letters
- Can contain numbers
- Can contain underscores
- Cannot normally start with a number
- Are case-sensitive
- Should not conflict with language keywords unless escaped
For example:
val user1 = "John"
val user_name = "John"
are syntactically possible, although Kotlin style generally favors:
val userName = "John"
Kotlin Variables Are Case-Sensitive
These are different variables:
val name = "John"
val Name = "David"
Kotlin treats uppercase and lowercase letters as different.
However, using names that differ only by capitalization is poor practice because it can make code difficult to read.
Common Mistakes Beginners Make
Mistake 1: Using var Everywhere
Avoid:
var name = "John"
var age = 25
var city = "Jaipur"
if these values never change.
Prefer:
val name = "John"
val age = 25
val city = "Jaipur"
Mistake 2: Confusing Char and String
Wrong:
val grade: Char = "A"
Correct:
val grade: Char = 'A'
And:
val name: String = "Ankit"
Mistake 3: Assuming Numeric Types Convert Automatically
Don’t assume this will work:
val number: Int = 100
val value: Long = number
Instead:
val value: Long = number.toLong()
Mistake 4: Ignoring Nullability
This:
var name: String = null
is invalid.
If null is allowed:
var name: String? = null
Mistake 5: Using Double for Exact Money Calculations
For example:
val price = 19.99
is a Double, which uses binary floating-point representation.
For financial systems where exact decimal arithmetic matters, consider using a decimal representation or storing monetary values as integer smallest units such as cents/paise.
Kotlin Variables Cheat Sheet
| Type | Example | Purpose |
|---|---|---|
Byte | 10 | Small integer |
Short | 1000 | Small-range integer |
Int | 100 | General integer |
Long | 100000L | Large integer |
Float | 10.5F | Single-precision decimal |
Double | 10.5 | Double-precision decimal |
Char | 'A' | Single character |
String | "Hello" | Text |
Boolean | true | True/false |
Array | arrayOf(1, 2) | Fixed-size array |
Any | "Hello" | General non-nullable type |
Unit | Function return | No meaningful value |
Nothing | throw ... | Never returns normally |
Best Practices for Kotlin Variables
1. Prefer val
Use:
val name = "John"
instead of:
var name = "John"
when reassignment isn’t required.
2. Use Clear Names
Prefer:
val totalPrice = 500
instead of:
val x = 500
3. Let Kotlin Infer Simple Types
Instead of:
val age: Int = 25
you can often write:
val age = 25
4. Use Explicit Types When They Improve Clarity
For public APIs, complex declarations, or cases where the type isn’t obvious, an explicit type can improve readability.
5. Handle Null Safely
Use Kotlin’s null-safety features instead of relying on unsafe assumptions.
Frequently Asked Questions
What is a variable in Kotlin?
A variable is a named reference used to store or access a value in a Kotlin program.
What is the difference between val and var?
val cannot be reassigned after initialization, while var can be reassigned.
Which should I use, val or var?
Use val by default. Use var when the value needs to be reassigned.
What are the main data types in Kotlin?
Common Kotlin types include Int, Long, Float, Double, String, Char, Boolean, and Array.
What is type inference in Kotlin?
Type inference allows Kotlin to determine a variable’s type automatically from its assigned value.
Example:
val age = 25
Kotlin infers Int.
How do I declare a String in Kotlin?
val name: String = "John"
How do I declare a Boolean?
val isActive: Boolean = true
What is a nullable type?
A nullable type is a type that can contain null.
Example:
val name: String? = null
How do I convert an Int to Long?
Use:
val longValue = number.toLong()
What is the difference between Char and String?
Char stores one character:
val letter = 'A'
String stores text:
val name = "Ankit"
What is const val?
const val defines a compile-time constant. It can only be used with supported primitive types and String, and its value must be known at compile time.
Conclusion
Understanding variables and data types is one of the most important steps when learning Kotlin.
The two variable keywords you should remember first are:
val → cannot be reassigned
var → can be reassigned
Kotlin also provides a rich type system:
Int
Long
Float
Double
String
Char
Boolean
Array
and powerful features such as:
- Type inference
- Null safety
- Smart casts
- Type conversion
- Compile-time constants
A simple Kotlin program may look like:
val name = "Ankit"
var age = 25
val isDeveloper = true
val salary = 50000.0
age = 26
println("Name: $name")
println("Age: $age")
println("Developer: $isDeveloper")
println("Salary: $salary")
Once you understand variables and data types, you’re ready to move on to other important Kotlin concepts such as operators, conditional statements, loops, functions, classes, collections, null safety, and object-oriented programming.
The key is to practice these concepts with small programs rather than simply memorizing syntax.
