Code News

AI Experts Want to End 'Black Box' Algorithms in Government

Review: Amazon Fire 7 (2017)

This More Powerful Version of AlphaGo Learns On Its Own

What It's Like to Rappel 1,000 Feet Down Into a Volcano

Kotlin From Scratch: Abstract Classes, Interfaces, Inheritance, and Type Alias

  • Kotlin is a modern programming language that compiles to Java bytecode. It is free and open source, and promises to make coding for Android even more fun.  

    In the previous article, you learned more about Kotlin properties such as late-initialization, extension, and inline properties. Not only that, you also learned about advanced classes such as data, enum, nested, and sealed classes in Kotlin. 

    In this post, you'll continue to learn about object-oriented programming in Kotlin by learning about abstract classes, interfaces, and inheritance. For a bonus, you'll also learn about type aliases. 

    1. Abstract Classes

    Kotlin supports abstract classes—just like Java, these are classes which you never intend to create objects from. An abstract class is incomplete or useless without some concrete (non-abstract) subclasses, from which you can instantiate objects. A concrete subclass of an abstract class implements all the methods and properties defined in the abstract class—otherwise that subclass is also an abstract class!

    We create an abstract class with the abstract modifier (similar to in Java). 

    abstract class Employee (val firstName: String, val lastName: String) { abstract fun earnings(): Double }

    Note that not all members have to be abstract. In other words, we can have method default implementation in an abstract class. 

    abstract class Employee (val firstName: String, val lastName: String) { // ... fun fullName(): String { return lastName + " " + firstName; } }

    Here we created the non-abstract function fullName() in an abstract class Employee. Concrete classes (subclasses of the abstract class) can override an abstract method's default implementation—but only if the method has the open modifier specified (you will learn more about this shortly). 

    We can also store state in abstract classes. 

    abstract class Employee (val firstName: String, val lastName: String) { // ... val propFoo: String = "bla bla" }

    Even if the abstract class doesn't define any methods, we need to create a subclass before we can instantiate it, as in the example below.

    class Programmer(firstName: String, lastName: String) : Employee(firstName, lastName) { override fun earnings(): Double { // calculate earnings } }

    Our Programmer class extends the Employee abstract class. In Kotlin we use a single colon character (:) instead of the Java extends keyword to extend a class or implement an interface. 

    We can then create an object of type Programmer and call methods on it—either in its own class or the superclass (base class).  

    val programmer = Programmer("Chike", "Mgbemena") println(programmer.fullName()) // "Mgbemena Chike"

    One thing that might surprise you is that we have the ability to override a val (immutable) property with var (mutable). 

    open class BaseA (open val baseProp: String) { } class DerivedA : BaseA("") { private var derivedProp: String = "" override var baseProp: String get() = derivedProp set(value) { derivedProp = value } }

    Make sure you use this functionality wisely! Be aware that we can't do the reverse—override a var property with val. 

    2. Interfaces

    An interface is simply a collection of related methods that typically enable you to tell objects what to do and also how to do it by default. (Default methods in interfaces are a new feature added to Java 8.) In other words, an interface is a contract that implementing classes must abide by. 

    An interface is defined using the interface keyword in Kotlin (similar to Java). 

    class Result class Student interface StudentRepository { fun getById(id: Long): Student fun getResultsById(id: Long): List<Result> }

    In the code above, we've declared a StudentRepository interface. This interface contains two abstract methods: getById() and getResultsById(). Note that including the abstract keyword is redundant in an interface method because they are already abstract implicitly. 

    An interface is useless without one or more implementers—so let's create a class that will implement this interface. 

    class StudentLocalDataSource : StudentRepository { override fun getResults(id: Long): List<Result> { // do implementation } override fun getById(id: Long): Student { // do implementation } }

    Here we created a class StudentLocalDataSource that implements the StudentRepository interface.

    We use the override modifier to label the methods and properties we want to redefine from the interface or superclass—this is similar to the @Override annotation in Java.

    Note the following additional rules of interfaces in Kotlin:

    • A class can implement as many interfaces as you want, but it can only extend a single class (similar to Java).
    • The override modifier is compulsory in Kotlin—unlike in Java. 
    • Along with methods, we can also declare properties in a Kotlin interface. 
    • A Kotlin interface method can have a default implementation (similar to Java 8). 

    Let's see an example of an interface method with a default implementation.

    interface StudentRepository { // ... fun delete(student: Student) { // do implementation } }

    In the preceding code, we added a new method delete() with a default implementation (though I did not add the actual implementation code for demonstration purposes). 

    We also have the freedom to override the default implementation if we want.

    class StudentLocalDataSource : StudentRepository { // ... override fun delete(student: Student) { // do implementation } }

    As stated, a Kotlin interface can have properties—but note that it can't maintain state. (However, remember abstract classes can maintain state.) So the following interface definition with a property declaration will work.

    interface StudentRepository { val propFoo: Boolean // will work // ... }

    But if we try to add some state to the interface by assigning a value to the property, it will not work.

    interface StudentRepository { val propFoo: Boolean = true // Error: Property initializers are not allowed in interfaces // .. }

    However, an interface property in Kotlin can have getter and setter methods (though only the latter if the property is mutable). Note also that property in an interface cannot have a backing field. 

    interface StudentRepository { var propFoo: Boolean get() = true set(value) { if (value) { // do something } } // ... }

    We can also override an interface property if you want, so as to redefine it. 

    class StudentLocalDataSource : StudentRepository { // ... override var propFoo: Boolean get() = false set(value) { if (value) { } } }

    Let's look at a case where we have a class implementing multiple interfaces with the same method signature. How does the class decide which interface method to call?

    interface InterfaceA { fun funD() {} } interface InterfaceB { fun funD() {} }

    Here we have two interfaces that have a method with the same signature funD(). Let's create a class that implements these two interfaces and overrides the funD() method. 

    class classA : InterfaceA, InterfaceB { override fun funD() { super.funD() // Error: Many supertypes available, please specify the one you mean in angle brackets, e.g. 'super<Foo>' } }

    The compiler is confused about calling the super.funD() method because the two interfaces that the class implements have the same method signature. 

    To solve this problem, we wrap the interface name for which we want to call the method in angle brackets <InterfaceName>. (IntelliJ IDEA or Android Studio will give you a hint about solving this issue when it crops up.)

    class classA : InterfaceA, InterfaceB { override fun funD() { super<InterfaceA>.funD() } }

    Here we are going to call the funD()  method of InterfaceA. Problem solved! 

    3. Inheritance

    A new class (subclass) is created by acquiring an existing class's (superclass) members and perhaps redefining their default implementation. This mechanism is known as inheritance in object-oriented programming (OOP). One of the things that make Kotlin so awesome is that it encompasses both the OOP and functional programming paradigms—all in one language.

    The base class for all classes in Kotlin is Any. 

    class Person : Any { }

    The Any type is equivalent to the Object type we have in Java. 

    public open class Any { public open operator fun equals(other: Any?): Boolean public open fun hashCode(): Int public open fun toString(): String }

    The Any type contains the following members: equals(), hashcode(), and also toString() methods (similar to Java). 

    Our classes don't need to explicitly extend this type. If you don't explicitly specify which class a new class extends, the class extends Any implicitly. For this reason, you typically don't need to include : Any in your code—we do so in the code above for demonstration purposes. 

     Let's now look into creating classes in Kotlin with inheritance in mind. 

    class Student { } class GraduateStudent : Student() { }

    In the code above, the GraduateStudent class extends the superclass Student. But this code won't compile. Why? Because classes and methods are final by default in Kotlin. In other words, they cannot be extended by default—unlike in Java where classes and methods are open by default. 

    Software engineering best practice recommends that you to begin making your classes and methods final by default—i.e. if they aren't specifically intended to be redefined or overridden in subclasses. The Kotlin team (JetBrains) applied this coding philosophy and many more development best practices in developing this modern language. 

    For us to allow subclasses to be created from a superclass, we have to explicitly mark the superclass with the open modifier. This modifier also applies to any superclass property or method that should be overridden by subclasses.

    open class Student { }

    We simply put the open modifier before the class keyword. We have now instructed the compiler to allow our Student class to be open for extension. 

    As stated earlier, members of a Kotlin class are also final by default. 

    open class Student { open fun schoolFees(): BigDecimal { // do implementation } }

    In the preceding code, we marked the schoolFees function as open—so that subclasses can override it. 

    open class GraduateStudent : Student() { override fun schoolFees(): BigDecimal { return super.schoolFees() + calculateSchoolFees() } private fun calculateSchoolFees(): BigDecimal { // calculate and return school fees } }

    Here, the open schoolFees function from the superclass Student is overridden by the GraduateStudent class—by adding the override modifier before the fun keyword. Note that if you override a member of a superclass or interface, the overriding member will also be open by default, as in the example below:

    class ComputerScienceStudent : GraduateStudent() { override fun schoolFees(): BigDecimal { return super.schoolFees() + calculateSchoolFess() } private fun calculateSchoolFess(): BigDecimal { // calculate and return school fees } }

    Even though we didn't mark the schoolFees() method in the GraduateStudent class with the open modifier, we can still override it—as we did in the ComputerScienceStudent class. For us to prevent this, we have to mark the overriding member as final. 

    Remember that we can add new functionality to a class—even if it's final—by the use of extension functions in Kotlin. For a refresher on extension functions, check out my Advanced Functions in Kotlin post. Also, if you need a refresher on how to give even a final class new properties without inheriting from it, read the section on extension Properties in my Advanced Properties and Classes post. 

    If our superclass has a primary constructor like this:

    open class Student(val firstName: String, val lastName: String) { // ... }

    Then any subclass has to call the primary constructor of the superclass. 

    open class GraduateStudent(firstName: String, lastName: String) : Student(firstName, lastName) { // ... }

    We can simply create an object of the GraduateStudent class as usual:

    val graduateStudent = GraduateStudent("Jon", "Snow") println(graduateStudent.firstName) // Jon

    If the subclass wants to call the superclass constructor from its secondary constructor, we use the super keyword (similar to how superclass constructors are invoked in Java). 

    open class GraduateStudent : Student { // ... private var thesis: String = "" constructor(firstName: String, lastName: String, thesis: String) : super(firstName, lastName) { this.thesis = thesis } }

    If you need a refresher on class constructors in Kotlin, kindly visit my Classes and Objects post. 

    4. Bonus: Type Alias

    Another awesome thing we can do in Kotlin is to give a type an alias. 

    Let's see an example.

    data class Person(val firstName: String, val lastName: String, val age: Int)

    In the class above, we can assign the String and Int types for the Person properties aliases using the typealias modifier in Kotlin. This modifier is used to create an alias of any type in Kotlin—including the ones you have created. 

    typealias Name = String typealias Age = Int data class Person(val firstName: Name, val lastName: Name, val age: Age)

    As you can see, we have created an alias Name and Age for both the String and Int types respectively. We have now replaced the firstName and lastName property type to our alias Name—and also Int type to Age alias. Note that we didn't create any new types—we instead created an alias for the types. 

    These can be handy when you want to provide a better meaning or semantic to types in your Kotlin codebase. So use them wisely! 

    Conclusion

    In this tutorial, you learned more about object-oriented programming in Kotlin. We covered the following:

    • abstract classes
    • interfaces 
    • inheritance
    • type alias

    If you have been learning Kotlin through our Kotlin From Scratch series, make sure you have been typing the code you see and running it on your IDE. One great tip to really grasp a new programming language (or any programming concept) you're learning is to make sure you don't just only read the learning resource or guide, but also type the actual code and run it!

    In the next tutorial in the Kotlin From Scratch series, you'll be introduced to exception handling in Kotlin. See you soon!

    To learn more about the Kotlin language, I recommend visiting the Kotlin documentation. Or check out some of our other Android app development posts here on Envato Tuts!


    5 days 8 hours ago

Russians Posing as Black Activists on Facebook Is More Than Fake News

Breville Precision Brewer Thermal Review: Excellent Control for Dialing in Your Ideal Drip

The $95,000 Fake Corpse Training a Generation of Doctors

Pages