**Course Title:** Kotlin Programming: From Basics to Advanced Techniques **Section Title:** Object-Oriented Programming in Kotlin **Topic:** Constructors, properties, and methods **Introduction** In the previous topic, we covered the basics of classes and objects in Kotlin. This topic will dive deeper into the essentials of object-oriented programming by exploring constructors, properties, and methods. Understanding these concepts is crucial for creating robust and maintainable Kotlin applications. **Constructors** In Kotlin, a constructor is a special member function used to initialize objects when they are created. There are two types of constructors in Kotlin: * **Primary Constructor**: A primary constructor is defined in the class header and is used to initialize objects. It is called when an object is created. * **Secondary Constructor**: A secondary constructor is defined inside the class body and is used to provide multiple ways of initializing objects. Here's an example of a class with a primary constructor: ```kotlin class Person(val name: String, val age: Int) ``` In this example, the primary constructor takes two parameters, `name` and `age`, which are used to initialize the object. You can also define a secondary constructor using the `constructor` keyword: ```kotlin class Person(val name: String) { constructor(name: String, age: Int) : this(name) { println("Secondary constructor called with name and age") } } ``` In this example, the secondary constructor takes an additional parameter `age` and calls the primary constructor using the `this` keyword. **Properties** Properties in Kotlin are used to store and retrieve data in classes. A property is a combination of a private field and getter/setter methods. Here's an example: ```kotlin class Person(val name: String) { var age: Int = 0 get() = field set(value) { if (value >= 0) { field = value } } } ``` In this example, the `age` property has a private field and a getter/setter method. The getter method simply returns the value of the private field, while the setter method checks if the value is non-negative before assigning it to the private field. **Methods** Methods in Kotlin are used to perform actions on objects. A method is a function that belongs to a class. Here's an example: ```kotlin class Person(val name: String) { fun greet() { println("Hello, my name is $name") } } ``` In this example, the `greet` method is a function that belongs to the `Person` class and prints a greeting message to the console. You can also define methods with parameters, return types, and modifiers: ```kotlin class Person(val name: String) { fun calculateAge(birthYear: Int): Int { val currentYear = 2024 return currentYear - birthYear } } ``` In this example, the `calculateAge` method takes a `birthYear` parameter, calculates the age based on the current year (2024), and returns the result. **Key Concepts** * Constructors are used to initialize objects when they are created. * Primary constructors are defined in the class header, while secondary constructors are defined inside the class body. * Properties are used to store and retrieve data in classes and consist of a private field and getter/setter methods. * Methods are used to perform actions on objects and belong to a class. * Methods can have parameters, return types, and modifiers. **Practical Takeaways** * Use constructors to initialize objects with default values. * Use properties to encapsulate data and provide getter/setter methods for access control. * Use methods to perform actions on objects and improve code reusability. * Use Kotlin's concise syntax to define constructors, properties, and methods. **Additional Resources** For more information on constructors, properties, and methods in Kotlin, refer to the official Kotlin documentation: * [Constructors and Initialization](https://kotlinlang.org/docs/classes.html#constructors) * [Properties and Fields](https://kotlinlang.org/docs/properties.html) * [Functions](https://kotlinlang.org/docs/functions.html) **Practice and Feedback** * Create a Kotlin class with a primary constructor, properties, and methods. * Experiment with different constructor parameter types and property access modifiers. * Implement a simple program that uses methods to perform actions on objects. * Ask for help or report any issues with this topic in the comments below. **What's Next?** In the next topic, we will cover inheritance, interfaces, and polymorphism in Kotlin.

class Person(val name: String, val age: Int)

class Person(val name: String) {
    constructor(name: String, age: Int) : this(name) {
        println("Secondary constructor called with name and age")
    }
}

class Person(val name: String) {
    var age: Int = 0
        get() = field
        set(value) {
            if (value >= 0) {
                field = value
            }
        }
}

class Person(val name: String) {
    fun greet() {
        println("Hello, my name is $name")
    }
}

class Person(val name: String) {
    fun calculateAge(birthYear: Int): Int {
        val currentYear = 2024
        return currentYear - birthYear
    }
}