Kotlin Nested Class and Inner Class

Understanding Kotlin Nested Class

A Kotlin nested class is a class defined inside another class without using the inner keyword. By default, nested classes in Kotlin are static in nature, similar to static nested classes in Java. This means a nested class cannot access the members of its outer class directly and doesn’t hold a reference to the outer class instance.

Basic Syntax of Nested Class

class OuterClass {
    private val outerProperty = "I'm from outer class"
    
    class NestedClass {
        fun displayMessage() {
            println("This is a nested class")
            // Cannot access outerProperty here
        }
    }
}

Key Properties of Nested Class

Kotlin nested class has several important characteristics that distinguish it from inner classes:

1. No access to outer class members: A nested class cannot directly access properties or methods of the outer class
2. Independent instantiation: You can create objects of nested classes without creating an instance of the outer class
3. Static behavior: Nested classes in Kotlin behave like static nested classes in Java
4. Memory efficient: Since they don’t hold a reference to the outer class, they consume less memory

Creating Objects of Nested Class

To create an instance of a Kotlin nested class, you use the outer class name followed by a dot and the nested class name:

fun main() {
    // Creating nested class object directly
    val nestedObject = OuterClass.NestedClass()
    nestedObject.displayMessage()
}

Understanding Kotlin Inner Class

A Kotlin inner class is declared using the inner keyword and can access all members of its outer class, including private members. Inner classes in Kotlin maintain a reference to the outer class instance, making them closely coupled with their containing class.

Basic Syntax of Inner Class

class OuterClass {
    private val outerProperty = "I'm from outer class"
    
    inner class InnerClass {
        fun displayMessage() {
            println("This is an inner class")
            println("Accessing: $outerProperty") // Can access outer class members
        }
    }
}

Key Properties of Inner Class

Kotlin inner class provides several powerful features:

1. Access to outer class members: Can access all properties and methods of the outer class, including private ones
2. Reference to outer instance: Holds an implicit reference to the outer class instance
3. Requires outer instance: Cannot be instantiated without first creating an outer class instance
4. Qualified this expressions: Can use this@OuterClass to refer to the outer class instance

Creating Objects of Inner Class

To create an instance of a Kotlin inner class, you must first create an instance of the outer class:

fun main() {
    val outerObject = OuterClass()
    val innerObject = outerObject.InnerClass()
    innerObject.displayMessage()
}

Nested Class vs Inner Class: Key Differences

Understanding when to use nested class versus inner class in Kotlin is essential for writing efficient code:

Working with Qualified This Expressions

When working with Kotlin inner class, you might encounter situations where both the inner and outer classes have members with the same name. Qualified this expressions help resolve this ambiguity:

class Vehicle {
    private val type = "Vehicle"
    
    inner class Car {
        private val type = "Car"
        
        fun showTypes() {
            println("Inner class type: $type")
            println("Inner class type (explicit): ${this.type}")
            println("Outer class type: ${this@Vehicle.type}")
        }
    }
}

Practical Examples

Example 1: File Manager System

Here’s a practical example showing how to use nested classes in Kotlin for organizing related functionality:

class FileManager {
    private val files = mutableListOf<String>()
    
    // Nested class for file operations that don't need access to instance data
    class FileValidator {
        fun isValidFileName(name: String): Boolean {
            return name.isNotEmpty() && !name.contains("/") && !name.contains("\\")
        }
        
        fun getFileExtension(fileName: String): String {
            return fileName.substringAfterLast(".", "")
        }
    }
    
    // Inner class for operations that need access to the file list
    inner class FileProcessor {
        fun addFile(fileName: String) {
            if (FileValidator().isValidFileName(fileName)) {
                files.add(fileName) // Can access outer class property
                println("File '$fileName' added successfully")
            } else {
                println("Invalid file name: $fileName")
            }
        }
        
        fun listFiles() {
            println("Files in manager: ${files.joinToString(", ")}")
        }
        
        fun getFileCount(): Int {
            return files.size // Accessing outer class property
        }
    }
}

Example 2: Android RecyclerView Adapter Pattern

This example demonstrates a common Android development pattern using Kotlin inner class:

class ProductAdapter(private val products: List<Product>) : RecyclerView.Adapter<ProductAdapter.ViewHolder>() {
    
    // Nested class - doesn't need access to adapter's products list for basic ViewHolder functionality
    class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        val titleView: TextView = itemView.findViewById(R.id.title)
        val priceView: TextView = itemView.findViewById(R.id.price)
        
        fun bindBasicLayout() {
            // Basic layout setup that doesn't require adapter data
            titleView.setTextColor(Color.BLACK)
            priceView.setTextColor(Color.GREEN)
        }
    }
    
    // Inner class for click handling that needs access to the products list
    inner class ClickHandler {
        fun onItemClick(position: Int) {
            if (position < products.size) { // Can access outer class property
                val product = products[position]
                println("Clicked on product: ${product.name}")
                // Handle navigation or other actions
            }
        }
        
        fun onItemLongClick(position: Int) {
            // Access adapter's data for long click actions
            products[position].let { product ->
                println("Long clicked on: ${product.name}")
            }
        }
    }
    
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_product, parent, false)
        return ViewHolder(view)
    }
    
    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val product = products[position]
        holder.titleView.text = product.name
        holder.priceView.text = "$${product.price}"
        
        val clickHandler = ClickHandler()
        holder.itemView.setOnClickListener { clickHandler.onItemClick(position) }
        holder.itemView.setOnLongClickListener { 
            clickHandler.onItemLongClick(position)
            true 
        }
    }
    
    override fun getItemCount(): Int = products.size
}

// Data class for the example
data class Product(val name: String, val price: Double)

Example 3: Database Connection Manager

This comprehensive example shows both nested class and inner class working together:

class DatabaseManager(private val connectionString: String) {
    private var isConnected = false
    private val queryHistory = mutableListOf<String>()
    
    // Nested class for utility functions that don't need instance access
    class QueryBuilder {
        fun buildSelectQuery(table: String, columns: List<String>): String {
            val columnStr = if (columns.isEmpty()) "*" else columns.joinToString(", ")
            return "SELECT $columnStr FROM $table"
        }
        
        fun buildInsertQuery(table: String, data: Map<String, Any>): String {
            val columns = data.keys.joinToString(", ")
            val values = data.values.joinToString(", ") { "'$it'" }
            return "INSERT INTO $table ($columns) VALUES ($values)"
        }
        
        fun buildUpdateQuery(table: String, data: Map<String, Any>, condition: String): String {
            val setClause = data.map { "${it.key} = '${it.value}'" }.joinToString(", ")
            return "UPDATE $table SET $setClause WHERE $condition"
        }
    }
    
    // Inner class that needs access to connection and query history
    inner class QueryExecutor {
        fun executeQuery(query: String): QueryResult {
            if (!isConnected) { // Accessing outer class property
                throw IllegalStateException("Database not connected. Connection: $connectionString")
            }
            
            queryHistory.add(query) // Modifying outer class property
            println("Executing query: $query")
            
            // Simulate query execution
            return QueryResult(true, "Query executed successfully")
        }
        
        fun executeWithHistory(query: String): QueryResult {
            val result = executeQuery(query)
            println("Query history count: ${queryHistory.size}")
            return result
        }
        
        fun getLastQueries(count: Int): List<String> {
            return queryHistory.takeLast(count) // Accessing outer class property
        }
        
        fun clearHistory() {
            queryHistory.clear() // Modifying outer class state
            println("Query history cleared")
        }
    }
    
    fun connect(): Boolean {
        isConnected = true
        println("Connected to database: $connectionString")
        return true
    }
    
    fun disconnect() {
        isConnected = false
        println("Disconnected from database")
    }
    
    fun getExecutor(): QueryExecutor {
        return QueryExecutor()
    }
}

// Result class for the example
data class QueryResult(val success: Boolean, val message: String)

Complete Working Example

Here’s a comprehensive example that demonstrates all concepts with proper imports and full implementation:

import java.util.*

// Main application class demonstrating nested and inner classes
class InventorySystem(private val systemName: String) {
    private val items = mutableMapOf<String, Int>()
    private val transactions = mutableListOf<String>()
    private var systemStatus = "ONLINE"
    
    // Nested class for utility functions that don't need system state access
    class ItemValidator {
        fun isValidItemCode(code: String): Boolean {
            return code.length >= 3 && code.all { it.isLetterOrDigit() }
        }
        
        fun formatItemCode(code: String): String {
            return code.uppercase().trim()
        }
        
        fun generateItemCode(): String {
            return "ITEM_${Random().nextInt(1000, 9999)}"
        }
    }
    
    // Another nested class for constants and configurations
    class SystemConfig {
        companion object {
            const val MAX_ITEMS = 1000
            const val MIN_QUANTITY = 0
            const val MAX_QUANTITY = 999
            const val SYSTEM_VERSION = "1.0.0"
        }
        
        fun getDefaultSettings(): Map<String, Any> {
            return mapOf(
                "maxItems" to MAX_ITEMS,
                "minQuantity" to MIN_QUANTITY,
                "maxQuantity" to MAX_QUANTITY,
                "version" to SYSTEM_VERSION
            )
        }
    }
    
    // Inner class that needs access to system state and data
    inner class InventoryManager {
        fun addItem(itemCode: String, quantity: Int): Boolean {
            val validator = ItemValidator()
            val formattedCode = validator.formatItemCode(itemCode)
            
            if (!validator.isValidItemCode(formattedCode)) {
                println("Invalid item code: $itemCode")
                return false
            }
            
            if (items.size >= SystemConfig.MAX_ITEMS) {
                println("Cannot add item: Maximum inventory limit reached")
                return false
            }
            
            if (quantity < SystemConfig.MIN_QUANTITY || quantity > SystemConfig.MAX_QUANTITY) {
                println("Invalid quantity: $quantity")
                return false
            }
            
            // Accessing and modifying outer class properties
            items[formattedCode] = items.getOrDefault(formattedCode, 0) + quantity
            val transaction = "ADDED: $formattedCode, Quantity: $quantity, Time: ${Date()}"
            transactions.add(transaction)
            
            println("Item added: $formattedCode with quantity $quantity")
            println("System: $systemName - Status: $systemStatus")
            return true
        }
        
        fun removeItem(itemCode: String, quantity: Int): Boolean {
            val formattedCode = ItemValidator().formatItemCode(itemCode)
            val currentQuantity = items[formattedCode] ?: 0
            
            if (currentQuantity < quantity) {
                println("Insufficient quantity. Available: $currentQuantity, Requested: $quantity")
                return false
            }
            
            // Modifying outer class state
            val newQuantity = currentQuantity - quantity
            if (newQuantity == 0) {
                items.remove(formattedCode)
            } else {
                items[formattedCode] = newQuantity
            }
            
            val transaction = "REMOVED: $formattedCode, Quantity: $quantity, Time: ${Date()}"
            transactions.add(transaction)
            
            println("Item removed: $formattedCode, quantity: $quantity")
            return true
        }
        
        fun getInventoryStatus(): String {
            return """
                |System: $systemName
                |Status: $systemStatus
                |Total Items: ${items.size}
                |Total Transactions: ${transactions.size}
                |Items: ${items.entries.joinToString(", ") { "${it.key}=${it.value}" }}
            """.trimMargin()
        }
        
        fun getRecentTransactions(count: Int): List<String> {
            return transactions.takeLast(count)
        }
    }
    
    // Another inner class for reporting that needs access to all system data
    inner class ReportGenerator {
        fun generateInventoryReport(): String {
            val totalItems = items.values.sum()
            val uniqueItems = items.size
            val recentTransactions = transactions.takeLast(5)
            
            return """
                |=== INVENTORY REPORT ===
                |System: $systemName
                |Status: $systemStatus
                |Report Generated: ${Date()}
                |
                |SUMMARY:
                |- Unique Items: $uniqueItems
                |- Total Quantity: $totalItems
                |- Total Transactions: ${transactions.size}
                |
                |INVENTORY DETAILS:
                |${items.entries.joinToString("\n") { "- ${it.key}: ${it.value}" }}
                |
                |RECENT TRANSACTIONS:
                |${recentTransactions.joinToString("\n")}
                |
                |=== END REPORT ===
            """.trimMargin()
        }
        
        fun generateLowStockAlert(threshold: Int = 5): String {
            val lowStockItems = items.filter { it.value <= threshold }
            
            return if (lowStockItems.isEmpty()) {
                "No low stock items found (threshold: $threshold)"
            } else {
                """
                |=== LOW STOCK ALERT ===
                |System: $systemName
                |Threshold: $threshold
                |Low Stock Items: ${lowStockItems.size}
                |
                |${lowStockItems.entries.joinToString("\n") { "- ${it.key}: ${it.value}" }}
                """.trimMargin()
            }
        }
    }
    
    fun startSystem() {
        systemStatus = "ONLINE"
        println("Inventory System '$systemName' started successfully")
    }
    
    fun stopSystem() {
        systemStatus = "OFFLINE"
        println("Inventory System '$systemName' stopped")
    }
    
    fun getManager(): InventoryManager = InventoryManager()
    fun getReporter(): ReportGenerator = ReportGenerator()
}

// Main function demonstrating the complete example
fun main() {
    println("=== Kotlin Nested and Inner Class Demo ===\n")
    
    // Create the main system
    val inventorySystem = InventorySystem("Warehouse Management System")
    inventorySystem.startSystem()
    
    // Using nested class - can be accessed without instance
    val validator = InventorySystem.ItemValidator()
    val config = InventorySystem.SystemConfig()
    
    println("Generated item code: ${validator.generateItemCode()}")
    println("System configuration: ${config.getDefaultSettings()}")
    println()
    
    // Using inner classes - require instance of outer class
    val manager = inventorySystem.getManager()
    val reporter = inventorySystem.getReporter()
    
    // Perform some operations
    manager.addItem("ABC123", 50)
    manager.addItem("XYZ789", 25)
    manager.addItem("DEF456", 100)
    
    manager.removeItem("ABC123", 10)
    
    println("\n" + manager.getInventoryStatus())
    println("\n" + reporter.generateInventoryReport())
    println("\n" + reporter.generateLowStockAlert(30))
    
    // Show recent transactions
    println("\nRecent Transactions:")
    manager.getRecentTransactions(3).forEach { println("- $it") }
    
    inventorySystem.stopSystem()
}

Expected Output:

=== Kotlin Nested and Inner Class Demo ===

Inventory System 'Warehouse Management System' started successfully
Generated item code: ITEM_7642
System configuration: {maxItems=1000, minQuantity=0, maxQuantity=999, version=1.0.0}

Item added: ABC123 with quantity 50
System: Warehouse Management System - Status: ONLINE
Item added: XYZ789 with quantity 25
System: Warehouse Management System - Status: ONLINE
Item added: DEF456 with quantity 100
System: Warehouse Management System - Status: ONLINE
Item removed: ABC123, quantity: 10

System: Warehouse Management System
Status: ONLINE
Total Items: 3
Total Transactions: 4
Items: ABC123=40, XYZ789=25, DEF456=100

=== INVENTORY REPORT ===
System: Warehouse Management System
Status: ONLINE
Report Generated: Wed Jun 18 10:30:45 PST 2025

SUMMARY:
- Unique Items: 3
- Total Quantity: 165
- Total Transactions: 4

INVENTORY DETAILS:
- ABC123: 40
- XYZ789: 25
- DEF456: 100

RECENT TRANSACTIONS:
ADDED: ABC123, Quantity: 50, Time: Wed Jun 18 10:30:45 PST 2025
ADDED: XYZ789, Quantity: 25, Time: Wed Jun 18 10:30:45 PST 2025
ADDED: DEF456, Quantity: 100, Time: Wed Jun 18 10:30:45 PST 2025
REMOVED: ABC123, Quantity: 10, Time: Wed Jun 18 10:30:45 PST 2025

=== END REPORT ===

=== LOW STOCK ALERT ===
System: Warehouse Management System
Threshold: 30
Low Stock Items: 1

- XYZ789: 25

Recent Transactions:
- ADDED: XYZ789, Quantity: 25, Time: Wed Jun 18 10:30:45 PST 2025
- ADDED: DEF456, Quantity: 100, Time: Wed Jun 18 10:30:45 PST 2025
- REMOVED: ABC123, Quantity: 10, Time: Wed Jun 18 10:30:45 PST 2025

Inventory System 'Warehouse Management System' stopped

This comprehensive example demonstrates how Kotlin nested class and inner class can work together effectively. The nested classes (ItemValidator and SystemConfig) provide utility functions that don’t need access to the instance state, while the inner classes (InventoryManager and ReportGenerator) can access and modify the outer class properties to perform their operations.