Functions and Object-Oriented Programming in Kotlin

# CHAPTER 6

Functions and Object-Oriented Programming in Kotlin #

1. Introduction #

2. Learning Objectives #

• Pass data into functions utilizing Parameters.

• Extract calculated data out of functions utilizing Return Types.

• Understand the core principles of Object-Oriented Programming.

• Define a Class blueprint and instantiate Objects from it.

• Implement Class Inheritance.

• Utilize Kotlin Data Classes to structure complex application data.

3. Advanced Functions (Parameters) #

// 'height' is a Parameter of type Int
fun jump(height: Int) {
    println("The character jumped $height feet in the air!")
}

fun main() {
    // We 'pass an Argument' (10) into the function!
    jump(10)
    jump(50) 
}

4. Advanced Functions (Return Values) #

// This function MUST hand back an Int!
fun calculateArea(width: Int, height: Int): Int {
    val total = width * height
    return total // Handing the answer back!
}

fun main() {
    // We capture the returned answer inside a variable!
    val roomArea = calculateArea(10, 5)
    println("The room is $roomArea square feet.")
}

5. Object-Oriented Programming (Classes & Objects) #

// The Blueprint (Class)
class Car(var color: String, var topSpeed: Int) {
    
    // A function inside a Class is called a 'Method'
    fun drive() {
        println("The $color car is driving at $topSpeed mph!")
    }
}

fun main() {
    // Instantiating Objects from the Blueprint!
    val ferrari = Car("Red", 200)
    val batmobile = Car("Black", 300)
    
    // Triggering their internal methods
    ferrari.drive()
    batmobile.drive()
}

6. Inheritance #

// The 'open' keyword allows other classes to inherit this blueprint!
open class Vehicle(var wheels: Int) {
    fun startEngine() {
        println("Vroom!")
    }
}

// ElectricCar INHERITS from Vehicle using the colon ':'
class ElectricCar(wheels: Int, var batteryLevel: Int) : Vehicle(wheels) {
    fun charge() {
        println("Charging battery to 100%...")
    }
}

fun main() {
    val tesla = ElectricCar(4, 50)
    tesla.startEngine() // Inherited from Vehicle!
    tesla.charge()      // Specific to ElectricCar!
}

7. Interfaces #

// The Contract
interface Clickable {
    fun onClick()
}

// The Button class MUST implement the onClick function!
class Button : Clickable {
    override fun onClick() {
        println("Button was successfully clicked!")
    }
}

8. Data Classes #

// The 'data' keyword does all the heavy lifting!
data class User(val id: Int, val username: String, val email: String)

fun main() {
    val playerOne = User(1, "DragonSlayer", "dragon@test.com")
    
    // Data classes print beautifully automatically!
    println(playerOne) 
    // Output: User(id=1, username=DragonSlayer, email=dragon@test.com)
}

9. Common Mistakes #

• Forgetting the return Keyword: If you define a function with a return type (e.g., fun getScore(): Int), the Kotlin compiler will throw a fatal error if you forget to actually write return 100 inside the block. The contract must be fulfilled.

• Forgetting open: In Java, all classes can be inherited by default. In Kotlin, they are "final" (locked). If you try to inherit from a standard class Car, it will crash. You must explicitly declare open class Car.

10. Best Practices #

• Single Responsibility Principle: A Class should do one thing, and do it well. Do not create a User class that holds their email, calculates their taxes, downloads images from the internet, and plays a sound effect. Break those into separate classes (User, TaxCalculator, NetworkManager).

11. Exercises #

1. 1. Write a function named multiply that accepts two Int parameters, multiplies them together, and returns the Int result.

1. 2. Create a data class named Product that holds a name (String) and a price (Double).

12. Coding Challenges #

1. 1. Create a class called Player with properties name (String) and health (Int).

1. 2. Create a method inside Player called takeDamage(amount: Int). It should subtract the amount from health.

1. 3. In main(), instantiate a Player named "Arthur" with 100 health. Call takeDamage(20), then print Arthur's current health.

13. MCQ Quiz with Answers #

14. Interview Questions #

• Q: Explain the structural and functional differences between a standard Kotlin class and a data class. In what specific Android scenario is a data class the mandatory choice?

• Q: Describe the concept of Class Inheritance. Why does Kotlin require the explicit open modifier, unlike Java?

• Q: Contrast a Class with an Interface. Why can a Class implement multiple Interfaces, but only inherit from one parent Class?

15. FAQs #

16. Summary #

17. Next Chapter Recommendation #