Kotlin Constructors
Kotlin constructors are special member functions that initialize class instances when objects are created. Unlike Java, Kotlin provides two distinct types of constructors: primary constructors and secondary constructors. The primary constructor is declared in the class header, while secondary constructors are defined within the class body using the constructor keyword.
Every Kotlin class can have one primary constructor and multiple secondary constructors. The primary constructor cannot contain executable code, but you can use init blocks to execute initialization logic. This design makes Kotlin constructors more structured and predictable than their Java counterparts.
Kotlin Primary Constructor
The Kotlin primary constructor is the most concise way to initialize class properties. It’s declared immediately after the class name and becomes part of the class header. Here’s the basic syntax for a primary constructor:
class ClassName constructor(parameter1: Type, parameter2: Type) {
// class body
}
You can omit the constructor keyword when there are no annotations or visibility modifiers:
class Person(val name: String, var age: Int) {
// class body
}
Primary Constructor Properties
When you declare parameters in a primary constructor, you can simultaneously declare class properties by using val or var keywords:
valcreates a read-only property (immutable)varcreates a mutable property
class Student(val studentId: String, var grade: Double) {
// studentId is read-only, grade is mutable
}
Primary Constructor with Default Parameters
Kotlin constructors support default parameters, eliminating the need for multiple constructor overloads:
class GameCharacter(
val name: String = "Anonymous",
var level: Int = 1,
var health: Double = 100.0
) {
// Properties with default values
}
This allows flexible object creation:
val character1 = GameCharacter() // Uses all defaults
val character2 = GameCharacter("Warrior") // Custom name, default level and health
val character3 = GameCharacter("Mage", 5) // Custom name and level
val character4 = GameCharacter("Archer", 3, 85.5) // All custom values
Kotlin Init Blocks
Since primary constructors cannot contain executable code, Kotlin provides init blocks for initialization logic. Init blocks are executed when the class instance is created and have access to primary constructor parameters:
class Vehicle(val brand: String, val model: String) {
val vehicleInfo: String
init {
println("Creating vehicle: $brand $model")
vehicleInfo = "$brand $model".uppercase()
// Validation logic
require(brand.isNotEmpty()) { "Brand cannot be empty" }
require(model.isNotEmpty()) { "Model cannot be empty" }
}
}
Multiple Init Blocks
A class can have multiple init blocks, and they execute in the order they appear:
class DatabaseConnection(val host: String, val port: Int) {
val connectionString: String
var isConnected: Boolean = false
init {
println("Initializing database connection...")
connectionString = "jdbc:postgresql://$host:$port/database"
}
init {
println("Validating connection parameters...")
require(port in 1..65535) { "Invalid port number: $port" }
}
init {
println("Establishing connection...")
isConnected = true
println("Connection established successfully!")
}
}
Kotlin Secondary Constructors
Secondary constructors provide alternative ways to initialize objects when the primary constructor isn’t sufficient. They’re declared using the constructor keyword and must delegate to the primary constructor using the this keyword:
class Rectangle(val width: Double, val height: Double) {
val area: Double = width * height
// Secondary constructor for square
constructor(side: Double) : this(side, side) {
println("Creating square with side: $side")
}
// Secondary constructor with default dimensions
constructor() : this(1.0, 1.0) {
println("Creating unit rectangle")
}
}
Secondary Constructor Delegation Rules
Every secondary constructor must directly or indirectly delegate to the primary constructor:
class BankAccount(val accountNumber: String, var balance: Double) {
val accountType: String
init {
accountType = if (balance >= 10000) "Premium" else "Standard"
println("Account created: $accountNumber, Type: $accountType")
}
// Secondary constructor with default balance
constructor(accountNumber: String) : this(accountNumber, 0.0) {
println("Account opened with zero balance")
}
// Secondary constructor delegating to another secondary constructor
constructor() : this("AUTO-${System.currentTimeMillis()}") {
println("Auto-generated account number")
}
}
Advanced Kotlin Constructor Features
Constructor Visibility Modifiers
You can control constructor visibility using access modifiers:
class SecureData private constructor(val data: String) {
companion object {
fun createSecureData(input: String): SecureData? {
return if (input.length >= 8) {
SecureData(input.reversed())
} else {
null
}
}
}
}
Constructor with Annotations
When using annotations or visibility modifiers, the constructor keyword becomes mandatory:
class ApiClient @Inject constructor(
private val httpClient: HttpClient,
private val apiKey: String
) {
// class implementation
}
Property Initialization in Constructor Body
You can initialize properties that aren’t declared in the primary constructor:
class MusicPlayer(val brand: String) {
val supportedFormats: List<String>
var volume: Int
var isPlaying: Boolean
init {
supportedFormats = listOf("MP3", "FLAC", "WAV", "AAC")
volume = 50
isPlaying = false
println("$brand music player initialized")
}
}
Full Example: E-commerce Product Class
Here’s a comprehensive example demonstrating all Kotlin constructor concepts:
// Import statements (if needed)
import java.time.LocalDateTime
import java.util.*
class Product(
val id: String,
val name: String,
var price: Double,
val category: String = "General"
) {
val productCode: String
var stock: Int = 0
var isAvailable: Boolean = false
val createdAt: LocalDateTime
val tags: MutableList<String> = mutableListOf()
init {
// Generate product code
productCode = "${category.uppercase()}-${id}"
createdAt = LocalDateTime.now()
// Validate price
require(price >= 0) { "Price cannot be negative: $price" }
require(name.isNotBlank()) { "Product name cannot be blank" }
println("Product created: $productCode - $name")
}
init {
// Set default availability based on category
isAvailable = category != "Restricted"
println("Product availability set to: $isAvailable")
}
// Secondary constructor for discounted products
constructor(
id: String,
name: String,
originalPrice: Double,
discountPercent: Double,
category: String
) : this(id, name, originalPrice * (1 - discountPercent / 100), category) {
tags.add("Discounted")
println("Discounted product created with ${discountPercent}% off")
}
// Secondary constructor for limited edition products
constructor(
id: String,
name: String,
price: Double,
category: String,
limitedStock: Int
) : this(id, name, price, category) {
stock = limitedStock
tags.addAll(listOf("Limited Edition", "Exclusive"))
println("Limited edition product created with stock: $limitedStock")
}
// Method to display product information
fun displayInfo() {
println("""
Product Information:
Code: $productCode
Name: $name
Price: $${String.format("%.2f", price)}
Category: $category
Stock: $stock
Available: $isAvailable
Tags: ${tags.joinToString(", ")}
Created: $createdAt
""".trimIndent())
}
// Method to update stock
fun updateStock(newStock: Int) {
require(newStock >= 0) { "Stock cannot be negative" }
stock = newStock
isAvailable = stock > 0
println("Stock updated to: $stock, Available: $isAvailable")
}
// Method to add tags
fun addTag(tag: String) {
if (!tags.contains(tag)) {
tags.add(tag)
println("Tag added: $tag")
}
}
}
// Demonstration function
fun main() {
println("=== Kotlin Constructors Demo ===\n")
// Using primary constructor with default parameter
val laptop = Product("LAP001", "Gaming Laptop", 1299.99)
laptop.updateStock(15)
laptop.addTag("Gaming")
laptop.displayInfo()
println("\n" + "=".repeat(50) + "\n")
// Using secondary constructor for discounted product
val smartphone = Product("PHN001", "Flagship Phone", 999.99, 15.0, "Electronics")
smartphone.updateStock(25)
smartphone.displayInfo()
println("\n" + "=".repeat(50) + "\n")
// Using secondary constructor for limited edition
val collectible = Product("COL001", "Vintage Watch", 2499.99, "Luxury", 5)
collectible.displayInfo()
println("\n" + "=".repeat(50) + "\n")
// Creating products with different parameter combinations
val basicProduct = Product("BAS001", "Office Chair", 199.99, "Furniture")
basicProduct.updateStock(50)
val premiumProduct = Product("PRE001", "Executive Desk", 899.99, "Premium")
premiumProduct.updateStock(10)
premiumProduct.addTag("Premium Quality")
println("Basic Product: ${basicProduct.name} - ${basicProduct.productCode}")
println("Premium Product: ${premiumProduct.name} - ${premiumProduct.productCode}")
}
Expected Output:
=== Kotlin Constructors Demo ===
Product created: GENERAL-LAP001 - Gaming Laptop
Product availability set to: true
Stock updated to: 15, Available: true
Tag added: Gaming
Product Information:
Code: GENERAL-LAP001
Name: Gaming Laptop
Price: $1299.99
Category: General
Stock: 15
Available: true
Tags: Gaming
Created: 2025-06-20T10:30:45.123
==================================================
Product created: ELECTRONICS-PHN001 - Flagship Phone
Product availability set to: true
Discounted product created with 15.0% off
Stock updated to: 25, Available: true
Product Information:
Code: ELECTRONICS-PHN001
Name: Flagship Phone
Price: $849.99
Category: Electronics
Stock: 25
Available: true
Tags: Discounted
Created: 2025-06-20T10:30:45.156
==================================================
Product created: LUXURY-COL001 - Vintage Watch
Product availability set to: true
Limited edition product created with stock: 5
Product Information:
Code: LUXURY-COL001
Name: Vintage Watch
Price: $2499.99
Category: Luxury
Stock: 5
Available: true
Tags: Limited Edition, Exclusive
Created: 2025-06-20T10:30:45.189
==================================================
Product created: FURNITURE-BAS001 - Office Chair
Product availability set to: true
Stock updated to: 50, Available: true
Product created: PREMIUM-PRE001 - Executive Desk
Product availability set to: true
Stock updated to: 10, Available: true
Tag added: Premium Quality
Basic Product: Office Chair - FURNITURE-BAS001
Premium Product: Executive Desk - PREMIUM-PRE001