Object Declarations क्या हैं

एक object declaration किसी चीज़ का अपने आप बिल्कुल एक single instance बनाता है, ताकि आपको इसे कभी खुद बनाने की ज़रूरत न पड़े।

In this page:

Declaring a Singleton
Object Declarations for Utility Functions
Lazy Initialization
Object Expressions for One-Off Instances

Syntax

kotlin

object ObjectName {
    val property: Type = value
    fun method() { }
}

ObjectName.property
ObjectName.method()

Declaring a Singleton

object Name { ... } एक साथ class और इसका single instance दोनों define करता है; कोई अलग constructor call नहीं होता -- आप इसे उपयोग करने के लिए बस सीधे Name को refer करते हैं।

उदाहरण: Declaring a Singleton

markup

// Define the singleton object `AppConfig`
object AppConfig {
    // Declare a read-only variable `appName`, set to `"MyApp"`
    val appName = "MyApp"
    // Declare a mutable variable `debugMode`, initialized to `false`
    var debugMode = false
}

// Entry point: execution of the program starts here
fun main() {
    // Print `AppConfig.appName` to the console, with a trailing newline
    println(AppConfig.appName)
    AppConfig.debugMode = true
    // Print "Debug: ${AppConfig.debugMode}" to the console, with a trailing newline
    println("Debug: ${AppConfig.debugMode}")
}

Object Declarations for Utility Functions

Objects stateless utility functions के लिए एक स्वाभाविक जगह हैं जो logically साथ belong करते हैं लेकिन हर call के लिए एक instance की ज़रूरत नहीं।

उदाहरण: Object Declarations for Utility Functions

markup

// Define the singleton object `MathUtils`
object MathUtils {
    fun square(x: Int) = x * x
    fun cube(x: Int) = x * x * x
}

// Entry point: execution of the program starts here
fun main() {
    // Print "Square of 5: ${MathUtils.square(5)}" to the console, with a trailing newline
    println("Square of 5: ${MathUtils.square(5)}")
    // Print "Cube of 3: ${MathUtils.cube(3)}" to the console, with a trailing newline
    println("Cube of 3: ${MathUtils.cube(3)}")
}

Lazy Initialization

किसी object का instance पहली बार access होने पर बनता है, ज़रूरी नहीं कि program शुरू होने पर, जिसे इसके अपने init block से print करके देखा जा सकता है।

उदाहरण: Lazy Initialization

markup

// Define the singleton object `Session`
object Session {
    init {
        // Print "Session object created" to the console, with a trailing newline
        println("Session object created")
    }
    // Declare a read-only variable `id`, set to `"abc123"`
    val id = "abc123"
}

// Entry point: execution of the program starts here
fun main() {
    // Print "Before accessing Session" to the console, with a trailing newline
    println("Before accessing Session")
    // Print "Session id: ${Session.id}" to the console, with a trailing newline
    println("Session id: ${Session.id}")
}

Object Expressions for One-Off Instances

एक anonymous object : Type { ... } एक interface implement करता या class extend करता single-use instance बनाता है, एक पूरी named class declare किए बिना एक तेज़, throwaway implementation के लिए उपयोगी।

उदाहरण: Object Expressions for One-Off Instances

markup

// Define an interface `ClickListener` describing required behavior
interface ClickListener {
    // Define the function `onClick` with no parameters
    fun onClick()
}

// Entry point: execution of the program starts here
fun main() {
    // Call `object : ClickListener` with a trailing lambda, storing the result in `listener`
    val listener = object : ClickListener {
        override fun onClick() {
            // Print "Clicked!" to the console, with a trailing newline
            println("Clicked!")
        }
    }
    listener.onClick()
}

Chapter Quiz — Complete all 7 topics to unlock

0/7 topics done

Complete these topics first:

← Previous Lesson Data Classes Next Lesson → Companion Objects

Object Declarations क्या हैं

Declaring a Singleton

Object Declarations for Utility Functions

Lazy Initialization

Object Expressions for One-Off Instances

Chapter Quiz — Complete all 7 topics to unlock

Login to run this code