**Course Title:** Kotlin Programming: From Basics to Advanced Techniques **Section Title:** Object-Oriented Programming in Kotlin **Topic:** Data classes and sealed classes ### Overview of Data Classes In object-oriented programming, data classes are used to represent data and encapsulate related functionality. They are typically used to hold data without adding any additional behavior. In Kotlin, data classes are marked with the `data` keyword and provide several benefits, including: * Automatic generation of `toString()`, `equals()`, and `hashCode()` methods * Simple and concise syntax for defining classes * Support for destructuring declarations ### Defining a Data Class To define a data class, use the `data` keyword followed by the `class` keyword and the name of the class. You must specify at least one primary constructor parameter. ```kotlin data class User(val name: String, val age: Int) ``` In this example, the `User` class is defined with two primary constructor parameters: `name` and `age`. The `data` keyword automatically generates the following methods: * `toString()`: Returns a string representation of the object * `equals()`: Compares two objects for equality * `hashCode()`: Returns a hash code for the object * `copy()`: Creates a copy of the object ### Using Data Classes You can use data classes in the same way as regular classes. Here's an example of how to create an instance of the `User` class and access its properties: ```kotlin val user = User("John Doe", 30) println(user.name) // Outputs: John Doe println(user.age) // Outputs: 30 ``` You can also use data classes with destructuring declarations, which allow you to decompose an object into its constituent parts. ```kotlin val (name, age) = user println(name) // Outputs: John Doe println(age) // Outputs: 30 ``` ### Sealed Classes Sealed classes are used to represent a closed set of subtypes. They are abstract by default and cannot be instantiated directly. Sealed classes are useful when you need to define a class hierarchy with a limited number of known subtypes. ```kotlin sealed class Color { class Red : Color() class Green : Color() class Blue : Color() } ``` In this example, the `Color` class is defined as a sealed class with three subtypes: `Red`, `Green`, and `Blue`. The `Color` class cannot be instantiated directly and can only be used as a base class for the specified subtypes. ### Using Sealed Classes with When Expressions Sealed classes can be used with when expressions to provide a concise and safe way to handle different subtypes. Here's an example of how to use a when expression with the `Color` class: ```kotlin fun getHexCode(color: Color): String = when (color) { is Color.Red -> "#FF0000" is Color.Green -> "#00FF00" is Color.Blue -> "#0000FF" } ``` In this example, the `getHexCode()` function uses a when expression to return the hex code for a given color. The `when` expression is exhaustive, meaning that it covers all possible subtypes of the `Color` class. ### Key Takeaways * Data classes provide a concise way to define classes that mainly hold data. * Sealed classes are used to represent a closed set of subtypes. * Both data classes and sealed classes are type-safe and provide compile-time checks to prevent errors. ### Example Use Cases Data classes can be used to define data models for API responses, while sealed classes can be used to define error types. ```kotlin data class ErrorResponse(val message: String) sealed class ErrorType { object NetworkError : ErrorType() object ServerError : ErrorType() object ClientError : ErrorType() } fun handleError(errorType: ErrorType): ErrorResponse = when (errorType) { is ErrorType.NetworkError -> ErrorResponse("Network error") is ErrorType.ServerError -> ErrorResponse("Server error") is ErrorType.ClientError -> ErrorResponse("Client error") } ``` ### Further Reading * [Kotlin Documentation: Data Classes](https://kotlinlang.org/docs/reference/data-classes.html) * [Kotlin Documentation: Sealed Classes](https://kotlinlang.org/docs/reference/sealed-classes.html) **Leave a comment or ask for help if you have any questions or need further clarification on this topic.** **What's next?** In the next topic, we will cover 'Understanding generics in Kotlin.' This topic will introduce you to the concepts of generics in Kotlin, including type parameters, type bounds, and type projection. You'll learn how to define generic classes, interfaces, and functions, and how to use generics to make your code more flexible and reusable. With this knowledge, you'll be able to create more robust and maintainable code.

data class User(val name: String, val age: Int)

val user = User("John Doe", 30)
println(user.name) // Outputs: John Doe
println(user.age)  // Outputs: 30

val (name, age) = user
println(name) // Outputs: John Doe
println(age)  // Outputs: 30

sealed class Color {
    class Red : Color()
    class Green : Color()
    class Blue : Color()
}

fun getHexCode(color: Color): String = when (color) {
    is Color.Red -> "#FF0000"
    is Color.Green -> "#00FF00"
    is Color.Blue -> "#0000FF"
}

data class ErrorResponse(val message: String)

sealed class ErrorType {
    object NetworkError : ErrorType()
    object ServerError : ErrorType()
    object ClientError : ErrorType()
}

fun handleError(errorType: ErrorType): ErrorResponse = when (errorType) {
    is ErrorType.NetworkError -> ErrorResponse("Network error")
    is ErrorType.ServerError -> ErrorResponse("Server error")
    is ErrorType.ClientError -> ErrorResponse("Client error")
}