course on Kotlin Android App Development, Kotlin, Inheritance for Reusing Classes

Efficiency and code reusability are very important factors in Android app development. Kotlin is a modern programming language designed to maximize these aspects, particularly offering excellent features for code reuse through inheritance. In this article, we will take a deep dive into the concept of inheritance in Kotlin and explain how it can be utilized in actual Android app development with example code.

Overview of Inheritance

Inheritance is a feature in object-oriented programming that allows one class to inherit properties and methods from another class. This reduces code duplication and creates a more flexible structure. In Kotlin, when defining a class, it is by default declared as ‘final’, meaning it cannot be inherited. Therefore, if you want to allow inheritance, you need to use the keyword ‘open’ in front of the class declaration.

Basic Class Inheritance Example

open class Animal(val name: String) {
    fun sound() {
        println("$name makes a sound.")
    }
}

class Dog(name: String) : Animal(name) {
    fun bark() {
        println("$name barks.")
    }
}
    

In the above example, we defined a base class called Animal. This class contains a property called name and a method called sound. Then, we defined a class called Dog that inherits from the Animal class and defines an additional method called bark. The subclass Dog can use the properties and methods of the superclass Animal.

Utilizing Class Inheritance in Android Apps

In Android app development, inheritance is often used for the reuse of screens (Activity) or Views. For instance, you can create a base class for Activities that have common UI behaviors or data processing, and multiple Activities can inherit from it.

Creating a Base Activity Class

open class BaseActivity : AppCompatActivity() {
    fun showToast(message: String) {
        Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
    }
}

class MainActivity : BaseActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        showToast("Welcome to MainActivity")
    }
}

class SecondActivity : BaseActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_second)
        showToast("Welcome to SecondActivity")
    }
}
    

Here, we created a base Activity class called BaseActivity. This class features a method called showToast that displays a Toast message. The MainActivity and SecondActivity classes inherit from BaseActivity and can easily utilize this functionality in their respective screens.

Polymorphism and Inheritance

The concept of polymorphism is also important in relation to inheritance. Polymorphism is the ability to process different objects using the same interface. In Kotlin, you can handle a subclass object using a superclass type. This increases the flexibility of the code.

Polymorphism Example

fun makeSound(animal: Animal) {
    animal.sound()
}

val dog = Dog("Buddy")
makeSound(dog) // Outputs: Buddy makes a sound.
    

The makeSound function takes an object of type Animal as a parameter and calls the sound method of that object. When you pass a Dog object, it calls the sound method of Animal, but can also utilize the overridden method in the subclass, thereby leveraging polymorphism.

Overriding in Inheritance

During inheritance, a subclass can override (redefine) methods of the superclass. This allows the subclass to modify the default behavior of the superclass. Overriding is implemented using the override keyword.

Overriding Example

open class Vehicle {
    open fun start() {
        println("Vehicle is starting")
    }
}

class Car : Vehicle() {
    override fun start() {
        println("Car is starting")
    }
}
    

In the example above, we defined a method called start in a base class called Vehicle, and we overridden it in the Car class to match the behavior for cars.

Inheritance and Interfaces

In Kotlin, you can enhance code reusability through interfaces in conjunction with class inheritance. An interface provides a blueprint of methods that a class must implement and allows for multiple inheritance.

Interface Usage Example

interface Drivable {
    fun drive()
}

class Motorcycle : Drivable {
    override fun drive() {
        println("Motorcycle is driving")
    }
}
    

We defined the Drivable interface, which is implemented by the Motorcycle class. By using interfaces, multiple classes can provide the same functionality while implementing it in different ways.

Code Reusability and Maintenance

Code generated through inheritance tends to be more reusable and easier to maintain. By reducing duplicate code, the likelihood of bugs decreases, and when changes occur, only the functionality of the superclass needs to be modified. However, indiscriminate use of inheritance can reduce code readability, so it’s important to use it appropriately.

Conclusion

In this article, we explained the concept and application of inheritance for reusing classes in Android app development using Kotlin. Inheritance reduces code duplication and allows for flexible coding through polymorphism. Effectively utilizing Kotlin’s inheritance can help create more efficient and maintainable Android applications.