Abstract classes in Kotlin Tutorial

      No Comments on Abstract classes in Kotlin Tutorial

In this Kotlin Tutorial we will describe the Abstract Classes in Kotlin. Adding the abstract keyword in front of the class definition will mark the class as abstract. An abstract class is a partially defined class; properties and methods that have no implementation must be implemented in a derived class, unless the derived class is meant to be an abstract class as well. Here is how you would define an abstract class in Kotlin:

    abstract class A {
      abstract fun doSomething()
    }

Unlike interfaces, you have to mark the function abstract if you don’t provide a body definition. You cannot create an instance of an abstract class. The role of such a class is to provide a common set of methods that multiple derived classes share. The best example of such a case is the InputStream class. This will be very familiar to a developer who has already worked with Java. The JDK documentation says: “This abstract class is the superclass of all classes representing an input stream of bytes. Applications that need to define a subclass of InputStream must always provide a method that returns the next byte of input”. If you look at the java.io package, you will find a few implementations for it: AudioInputStream,ByteArrayInputStream,fileInputStream and many more. You could also provide an implementation of it.You can inherit a class A with a function flagged as opened for being redefined (overridable,
as we will see shortly) and marked it abstract in the derived class. This way the derived class will become abstract. Any class that inherits from the derived class will need to provide an implementation, and it won’t be able to access the implementation defined in class A:

    open class AParent protected constructor() {
      open fun someMethod(): Int = Random().nextInt()
    }
    abstract class DDerived : AParent() {
      abstract override fun someMethod(): Int
    }
    class AlwaysOne : DDerived() {
      override fun someMethod(): Int {
        return 1
      }
    }

The example is pretty straightforward. We have a parent class that defines someMethod, returning a random integer. A
Derived class inherits this class (please note we have to invoke the empty constructor on the parent class) and marks the method abstract. Then, our AlwaysOne class will have to provide a function body for our method that always returns 1.

It's only fair to share...Share on FacebookShare on Google+Tweet about this on TwitterShare on LinkedIn