Classes and Objects

# CHAPTER 13

Classes and Objects #

1. Chapter Introduction #

2. Learning Objectives #

• Define a class in Kotlin.

• Instantiate an Object from a class.

• Add Properties (state) to a class.

• Add Methods (behavior) to a class.

• Understand visibility modifiers (public, private).

3. What is a Class? #

// Creating the Blueprint
class Car {
    // Properties (State)
    var color: String = "Red"
    var brand: String = "Toyota"

    // Methods (Behavior)
    fun drive() {
        println("The $color $brand is driving!")
    }
}

4. What is an Object? #

In Java, you create objects using the new keyword (e.g., Car myCar = new Car()). Kotlin completely removed the new keyword! You just call the class name like a function.

fun main() {
    // Creating two Objects (Instances) of the Car class
    val myCar = Car()
    val yourCar = Car()

    // Modifying properties of a specific object
    yourCar.color = "Blue"
    yourCar.brand = "Ford"

    // Calling methods
    myCar.drive()   // Outputs: The Red Toyota is driving!
    yourCar.drive() // Outputs: The Blue Ford is driving!
}

5. Properties vs. Java Fields #

class User {
    var name: String = "Guest" // Kotlin generates getName() and setName() silently
}

fun main() {
    val user = User()
    user.name = "Alice" // Calls the invisible Setter!
    println(user.name)  // Calls the invisible Getter!
}

6. Visibility Modifiers #

• public: (Default in Kotlin). Accessible from anywhere.

• private: Accessible ONLY from inside the class itself.

• protected: Accessible inside the class and its subclasses (covered in Chapter 15).

• internal: Accessible only within the same module (e.g., the same App or Library).

class BankAccount {
    // Hidden from the outside world!
    private var balance: Double = 0.0

    // Public method to safely interact with the hidden data
    fun deposit(amount: Double) {
        if (amount > 0) {
            balance += amount
            println("Deposited $amount")
        }
    }
}

fun main() {
    val account = BankAccount()
    // account.balance = 1000000.0 // ERROR! Cannot access 'balance': it is private
    account.deposit(50.0) // Safe interaction
}

7. Mini Project: Employee Management System #

class Employee {
    var name: String = ""
    var position: String = ""
    private var salary: Double = 0.0

    fun setSalary(amount: Double) {
        if (amount >= 30000) {
            salary = amount
        } else {
            println("Salary too low for company standards.")
        }
    }

    fun printDetails() {
        println("Employee: $name, Role: $position")
    }
}

fun main() {
    val emp = Employee()
    emp.name = "John Doe"
    emp.position = "Software Engineer"
    
    emp.setSalary(85000.0)
    emp.printDetails()
}

8. Common Mistakes #

• Using the new keyword: Java developers constantly type val c = new Car(). The Kotlin compiler will throw a syntax error. Just use Car().

• Forgetting parentheses: Typing val myCar = Car instead of val myCar = Car(). The first assigns the class reference, the second actually creates the object instance in memory.

9. Best Practices #

• Hide State: Make properties private if they should not be modified directly from outside the class. Force users to use methods (like deposit()) to interact with sensitive data safely.

10. Exercises #

1. 1. Create a class Book with properties title and author.

1. 2. Add a method readBook() that prints "Reading [title] by [author]".

1. 3. In main(), create an object, set the properties, and call the method.

11. MCQs with Answers #

12. Interview Questions #

• Q: Explain why Kotlin eliminated the new keyword. (Answer: To make the language more concise and readable. Calling a constructor looks exactly like calling a regular function).

• Q: How does Kotlin handle Getters and Setters differently from Java?

13. Summary #

14. Next Chapter Recommendation #