Understanding Basic Types and Expressions in Kotlin

March 2025
M	T	W	T	F	S	S
	1	2
3	4	5	6	7	8	9
10	11	12	13	14	15	16
17	18	19	20	21	22	23
24	25	26	27	28	29	30
31

Kotlin is a modern, statically-typed programming language that is built on the JVM. It combines the best features from languages like Java, Ruby, and JavaScript while introducing its own unique elements. One of the first things any programmer needs to grasp when learning a new language is how data types work. In Kotlin, basic types include integers, floating-point numbers, booleans, strings, and characters.

Everything is an Object

One of Kotlin’s unique features is that everything is an object. This stands in contrast to languages like Java, where primitive types like int and char are not objects but can be wrapped in their corresponding wrapper classes (e.g., Integer, Character). In Kotlin, even numbers like 1 are objects. This simplifies the language by doing away with the distinction between primitives and objects.

Numeric Types in Kotlin

Kotlin supports four integral types:

Byte: 8-bit
Short: 16-bit
Int: 32-bit
Long: 64-bit

Additionally, Kotlin supports two floating-point types:

Float: 32-bit
Double: 64-bit

You can define numeric literals directly, and Kotlin will infer the type. However, you can also specify types explicitly:

1234 is an Int
1234L is a Long
3.14159 is a Double
3.14159f is a Float

Number Literals and Formatting

Kotlin supports various number literals. For better readability, you can use underscores (_) to separate groups of digits in large numbers, such as:

val number = 1_234_567

1 2	val number = 1_234_567

This makes it easier to read numbers without affecting their value. You can also define numbers in different bases:

Hexadecimal: 0xFFA4C639
Binary: 0b10110100

Mathematical Operations

Kotlin provides standard mathematical operations like addition (+), subtraction (-), multiplication (*), division (/), and modulus (



		
		
			
			

			
			println(1 + 2 * 3)   // Output: 7
println((1 + 2) * 3) // Output: 9

			
				
					
				
					1
2
3
				
						println(1 + 2 * 3)   // Output: 7
println((1 + 2) * 3) // Output: 9
 
					
				
			
		


Working with Booleans
Kotlin has a Boolean type with two values: true and false. It also provides the standard Boolean operators:

&&: Logical AND
||: Logical OR
!: Logical NOT

Strings in Kotlin
Strings are a staple in most programming languages, and Kotlin provides several ways to define strings:

Double-quoted strings: These are similar to strings in Java and can contain escape sequences like \n for newlines or \t for tabs.
Triple-quoted strings: These are used for raw strings, where newlines and special characters are preserved without needing escape sequences:



		
		
			
			

			
			val rawString = """Hello,
world!"""

			
				
					
				
					1
2
3
				
						val rawString = """Hello,
world!"""
 
					
				
			
		

This results in:


		
		
			
			

			
			Hello,
world!

			
				
					
				
					1
2
3
				
						Hello,
world!
 
					
				
			
		

You can also remove unwanted indentation from raw strings using the trimMargin() function:


		
		
			
			

			
			val formattedString = """Hello,
&gt;world!""".trimMargin("&gt;")

			
				
					
				
					1
2
3
				
						val formattedString = """Hello,
&gt;world!""".trimMargin("&gt;")
 
					
				
			
		

This will remove the leading whitespace, making the string more readable.
String Concatenation and Interpolation
Kotlin allows string concatenation with the + operator:


		
		
			
			

			
			println("Hello, " + "world!")

			
				
					
				
					1
2
				
						println("Hello, " + "world!")
 
					
				
			
		

However, Kotlin also supports string interpolation, which makes string concatenation cleaner and more intuitive. You can directly embed expressions in string literals using $:


		
		
			
			

			
			val name = "world"
println("Hello, $name!")  // Output: Hello, world!

			
				
					
				
					1
2
3
				
						val name = "world"
println("Hello, $name!")  // Output: Hello, world!
 
					
				
			
		


Characters in Kotlin
A character in Kotlin is represented by a single-quoted literal, just like in Java:


		
		
			
			

			
			val char = 'a'

			
				
					
				
					1
2
				
						val char = 'a'
 
					
				
			
		

Characters can also use escape sequences like \n for newlines or \t for tabs.
Equality Checks
In most languages, the == operator checks for equality. In Kotlin, == is used for content equality, while === checks for instance equality (whether two references point to the same object).


		
		
			
			

			
			val value = "something"
println(value.toUpperCase().toLowerCase() == value)  // Output: true
println(value.toUpperCase().toLowerCase() === value) // Output: false in Kotlin/JVM, true in Kotlin/JS

			
				
					
				
					1
2
3
4
				
						val value = "something"
println(value.toUpperCase().toLowerCase() == value)  // Output: true
println(value.toUpperCase().toLowerCase() === value) // Output: false in Kotlin/JVM, true in Kotlin/JS
 
					
				
			
		


Conclusion
Kotlin simplifies a lot of the complexities present in other languages, making it easier to work with basic types and expressions. With powerful features like string interpolation, raw strings, and the lack of distinction between primitive types and objects, Kotlin becomes an excellent choice for modern software development. Whether you’re working on Android apps or server-side code, understanding these basic types and expressions is key to getting started with Kotlin.