Int, Long, Float, Double number types in Kotlin - Step-by-Step Execution

Concept Flow - Int, Long, Float, Double number types

Start

↓

Declare variable with type

↓

Assign value

↓

Use variable in expression

↓

Check type limits

↓

Perform operations

↓

End

This flow shows how Kotlin variables of types Int, Long, Float, and Double are declared, assigned, and used in operations while respecting their value limits.

Execution Sample

Kotlin

val a: Int = 100
val b: Long = 10000000000L
val c: Float = 3.14F
val d: Double = 3.1415926535
println(a)
println(b)

This code declares variables of different number types and prints two of them.

Execution Table

Step	Action	Variable	Value	Type	Output
1	Declare and assign	a	100	Int
2	Declare and assign	b	10000000000	Long
3	Declare and assign	c	3.14	Float
4	Declare and assign	d	3.1415926535	Double
5	Print a	a	100	Int	100
6	Print b	b	10000000000	Long	10000000000
7	End

💡 All variables declared and printed successfully, program ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
a	undefined	100	100	100	100	100
b	undefined	undefined	10000000000	10000000000	10000000000	10000000000
c	undefined	undefined	undefined	3.14	3.14	3.14
d	undefined	undefined	undefined	undefined	3.1415926535	3.1415926535

Key Moments - 3 Insights

Why do we add 'L' after the number when declaring a Long?

In Kotlin, adding 'L' tells the compiler the number is a Long type, not an Int. See execution_table step 2 where '10000000000L' is assigned to b.

Why do we add 'F' after the number when declaring a Float?

Adding 'F' tells Kotlin the number is a Float, not a Double. Without 'F', the number is treated as Double by default. See execution_table step 3.

Can we assign a decimal number to an Int variable?

No, Int only holds whole numbers. Decimal numbers must use Float or Double. See execution_table steps 1 and 3 for difference.

Visual Quiz - 3 Questions

Look at the execution_table at step 2. What is the value and type of variable 'b'?

A 10000000000L, Int

B 10000000000, Int

C 10000000000, Long

D 10000000000F, Float

💡 Hint

Check the 'Value' and 'Type' columns at step 2 in execution_table.

At which step is the Float variable 'c' assigned a value?

A Step 3

B Step 1

C Step 4

D Step 2

💡 Hint

Look for variable 'c' and its value assignment in execution_table.

If we remove the 'F' suffix from the Float declaration, what will happen?

A It will be treated as Int.

B It will be treated as Double and cause a type mismatch error.

C It will still be Float without any issue.

D It will cause a syntax error.

💡 Hint

Refer to key_moments about Float declaration and suffix usage.

Concept Snapshot

Kotlin number types:
- Int: 32-bit whole numbers
- Long: 64-bit whole numbers (use 'L' suffix)
- Float: 32-bit decimal numbers (use 'F' suffix)
- Double: 64-bit decimal numbers (default for decimals)
Use suffixes to specify type explicitly.

Full Transcript

This visual execution shows how Kotlin handles number types Int, Long, Float, and Double. Variables are declared with explicit types and assigned values. Long numbers require an 'L' suffix to distinguish from Int. Float numbers require an 'F' suffix to distinguish from Double, which is the default for decimal numbers. The execution table traces each step: declaring variables, assigning values, and printing outputs. The variable tracker shows how each variable's value is set and remains unchanged. Key moments clarify why suffixes are needed and why decimal numbers cannot be assigned to Int. The quiz tests understanding of variable types, assignments, and suffix usage. The snapshot summarizes the key rules for Kotlin number types.

Practice

1. Which Kotlin number type should you use to store a whole number like 42?

easy

A. Float

B. Double

C. Int

D. Long

Solution

1. Step 1: Understand the number type categories

   Int is used for normal whole numbers without decimals.

2. Step 2: Match the number 42 to the type

   42 is a whole number and fits in Int range.

3. Final Answer:

   Int -> Option C

4. Quick Check:

   Whole number 42 = Int [OK]

Hint: Whole numbers without decimals use Int by default [OK]

Common Mistakes:

• Choosing Float or Double for whole numbers
• Using Long unnecessarily for small numbers

2. Which of the following is the correct way to declare a Float variable with value 3.14 in Kotlin?

easy

A. val pi: Float = 3.14

B. val pi: Float = 3.14Ff

C. val pi: Float = 3.14d

D. val pi: Float = 3.14f

Solution

1. Step 1: Recall Kotlin Float literal syntax

   Float literals require an 'f' or 'F' suffix to distinguish from Double.

2. Step 2: Check each option

   val pi: Float = 3.14f uses '3.14f' which is correct. val pi: Float = 3.14 misses the suffix. val pi: Float = 3.14Ff has invalid suffix 'Ff'. val pi: Float = 3.14d uses 'd' which is for Double.

3. Final Answer:

   val pi: Float = 3.14f -> Option D

4. Quick Check:

   Float literals end with 'f' [OK]

Hint: Add 'f' suffix to decimal for Float type [OK]

Common Mistakes:

• Omitting 'f' suffix for Float literals
• Using 'd' suffix which is for Double
• Using invalid suffixes like 'Ff'

3. What will be the output of this Kotlin code?

val a: Int = 100000
val b: Long = 10000000000L
val c: Float = 3.14f
val d: Double = 3.1415926535
println("$a $b $c $d")

medium

A. 100000 10000000000 3.1400001 3.1415926535

B. 100000 10000000000 3.14 3.1415926535

C. 100000 10000000000 3.14f 3.1415926535

D. 100000 10000000000 3.14 3.1415927

Solution

1. Step 1: Understand variable types and precision

   a is Int (100000), b is Long (10000000000L), c is Float (3.14f), d is Double (3.1415926535).

2. Step 2: Check printed values and precision

   Float prints as 3.1400001 due to precision limits, Double prints full precision (3.1415926535). So output matches 100000 10000000000 3.1400001 3.1415926535.

3. Final Answer:

   100000 10000000000 3.1400001 3.1415926535 -> Option A

4. Quick Check:

   Float prints with slight precision difference [OK]

Hint: Float prints decimals with limited precision [OK]

Common Mistakes:

• Thinking Float prints exactly 3.14
• Confusing Float and Double precision
• Misreading Long large number formatting

4. Identify the error in this Kotlin code snippet:

val bigNumber: Long = 12345678901234567890
val smallNumber: Int = 2147483648

medium

A. Both numbers are too large for their types

B. Only bigNumber is too large for Long

C. No errors, code is correct

D. Only smallNumber is too large for Int

Solution

1. Step 1: Check Long value range

   Long can hold values up to 9,223,372,036,854,775,807. The bigNumber literal exceeds this, so it causes an error.

2. Step 2: Check Int value range

   Int max is 2,147,483,647. The smallNumber is 2,147,483,648 which is 1 more than max, so it causes an error.

3. Step 3: Analyze the code

   Both literals are too large for their types, causing compile errors.

4. Final Answer:

   Both numbers are too large for their types -> Option A

5. Quick Check:

   Int max 2147483647, Long max 9223372036854775807; both exceeded [OK]

Hint: Check max values: Int max 2,147,483,647; Long max 9,223,372,036,854,775,807 [OK]

Common Mistakes:

• Ignoring suffix 'L' for Long literals
• Assuming Long can hold any big number
• Not checking Int max value

5. You want to store the population of a country which is about 1.4 billion people. Which Kotlin type is best and why?

Options:
A) Long because it can store very large whole numbers
B) Int because it stores whole numbers
C) Float because it stores decimal numbers
D) Double because it stores decimal numbers with more precision

hard

A. Int because it stores whole numbers

B. Long because it can store very large whole numbers

C. Float because it stores decimal numbers

D. Double because it stores decimal numbers with more precision

Solution

1. Step 1: Understand the population size and type limits

   Population is about 1.4 billion (1,400,000,000). Int max is 2,147,483,647, so Int can hold it.

2. Step 2: Consider best practice for large numbers

   Though Int can hold 1.4 billion, Long is safer for very large whole numbers and future growth.

3. Step 3: Decide on the best type

   Long is best because it can store very large whole numbers beyond Int range.

4. Final Answer:

   Long because it can store very large whole numbers -> Option B

5. Quick Check:

   Long preferred for large integers like population [OK]

Hint: Use Long for very large whole numbers like population [OK]

Common Mistakes:

• Choosing Int without considering future growth
• Using Float or Double for whole numbers unnecessarily
• Ignoring future growth beyond Int range