Classes are “final” by default in Kotlin

In Kotlin, classes and methods are final by default, meaning they cannot be inherited or overridden. This design choice emphasizes safety and prevents accidental modification of classes or methods, which could lead to unexpected behaviors.

To allow a class to be extended (inherited), you need to explicitly mark it with the open keyword. Similarly, methods and properties that you want to override in a subclass must also be marked with open.

---

Why Use open for Classes?

1. Explicit Inheritance Control:
   • Kotlin enforces explicit design choices. By default, making classes final prevents unintended extension, ensuring that your class behaves as expected without being altered.
   • By using open, you signal that the class is designed to be extended.
2. Improved Code Safety:
   • It prevents accidental or unauthorized inheritance of classes, which could compromise encapsulation or lead to subtle bugs.
3. Better Code Design:
   • You clearly indicate which classes are meant to be used as base classes, making your design intentions more readable.

---

Example Without open

class Parent {
    fun greet() {
        println("Hello from Parent")
    }
}

class Child : Parent() // Error: 'Parent' is final and cannot be inherited

This results in a compilation error because Parent is final by default.

---

Example With open

open class Parent {
    open fun greet() {
        println("Hello from Parent")
    }
}

class Child : Parent() {
    override fun greet() {
        println("Hello from Child")
    }
}

fun main() {
    val child = Child()
    child.greet() // Output: Hello from Child
}

• Parent is marked open, allowing it to be extended by Child.
• The greet method is also marked open, so it can be overridden.

---

Why Not Use open by Default?

1. Avoiding Unintended Changes:
   • If all classes were open by default, any developer could subclass or override a class or method, leading to unexpected behaviors in code.
2. Encapsulation and Modularity:
   • Making classes and methods final by default helps maintain strong boundaries between components, encouraging better encapsulation.
3. Easier Maintenance:
   • Final classes are easier to maintain because their behavior is fixed and predictable.

---

When to Use open?

• Use open only when you intend a class to serve as a base class.
• Mark methods and properties open only if they are designed to be overridden in subclasses.
• If a class or method should not be changed, leave it as final (default behavior).

---

Final vs. Open vs. Abstract

Keyword	Purpose
final	Default behavior; classes and methods cannot be inherited or overridden.
open	Allows classes to be inherited and methods/properties to be overridden.
abstract	Used for classes or methods that must be overridden in subclasses (cannot be instantiated directly).

Example with Abstract and Open:

abstract class Shape {
    abstract fun area(): Double
    open fun description() = "This is a shape"
}

class Circle(private val radius: Double) : Shape() {
    override fun area() = Math.PI * radius * radius
    override fun description() = "This is a circle"
}

• Shape is abstract, meaning it cannot be instantiated.
• The area method is abstract, so it must be overridden.
• The description method is open, so it can be overridden but is not mandatory.

---

Summary

• open explicitly indicates that a class or method is intended to be extended or overridden.
• This approach ensures better code safety, readability, and maintainability compared to the default behavior in other languages where all classes are extendable by default.