An abstract class is a class that cannot be instantiated. We create abstract classes to provide a common template for other classes to extend and use.
Declaring an Abstract Class
You can declare an abstract class using the abstract
keyword –
abstract class Vehicle
An abstract class may contain both abstract and non-abstract properties and functions. You need to explicitly use the abstract
keyword to declare a property or function as abstract –
abstract class Vehicle(val name: String,
val color: String,
val weight: Double) { // Concrete (Non Abstract) Properties
// Abstract Property (Must be overridden by Subclasses)
abstract var maxSpeed: Double
// Abstract Methods (Must be implemented by Subclasses)
abstract fun start()
abstract fun stop()
// Concrete (Non Abstract) Method
fun displayDetails() {
println("Name: $name, Color: $color, Weight: $weight, Max Speed: $maxSpeed")
}
}
Any subclass that extends the abstract class must implement all of its abstract methods and properties, or the subclass should also be declared as abstract.
If you recall from the Kotlin Inheritance tutorial, you need to annotate a class as open
to allow other classes to inherit from it. But, you don’t need to do that with abstract classes. Abstract classes are open
for extension by default.
Similarly, abstract methods and properties are open
for overriding by default.
But, If you need to override a non-abstract method or property, then you must mark it with the open
modifier.
Extending from an Abstract class
Following are two concrete classes that extend the Vehicle
abstract class and override its abstract methods and properties –
class Car(name: String,
color: String,
weight: Double,
override var maxSpeed: Double): Vehicle(name, color, weight) {
override fun start() {
// Code to start a Car
println("Car Started")
}
override fun stop() {
// Code to stop a Car
println("Car Stopped")
}
}
class Motorcycle(name: String,
color: String,
weight: Double,
override var maxSpeed: Double): Vehicle(name, color, weight) {
override fun start() {
// Code to Start the Motorcycle
println("Bike Started")
}
override fun stop() {
// Code to Stop the Motorcycle
println("Bike Stopped")
}
}
Let’s now write some code to test our abstract and concrete classes in the main method –
fun main(args: Array<String>) {
val car = Car("Ferrari 812 Superfast", "red", 1525.0, 339.60)
val motorCycle = Motorcycle("Ducati 1098s", "red", 173.0, 271.0)
car.displayDetails()
motorCycle.displayDetails()
car.start()
motorCycle.start()
}
Here is the output of the above main()
method –
# Output
Name: Ferrari 812 Superfast, Color: red, Weight: 1525.0, Max Speed: 339.6
Name: Ducati 1098s, Color: red, Weight: 173.0, Max Speed: 271.0
Car Started
Bike Started
Conclusion
Abstract classes help you abstract out common functionality into a base class. It may contain both abstract and non-abstract properties and methods. An abstract class is useless on its own because you cannot create objects from it. But, other concrete (non-abstract) classes can extend it and build upon it to provide the desired functionality.