skip to content

Abstract Classes

3 roadmaps5 questions

Abstract classes and members carry no implementation and must be overridden, and abstract implies open so you do not repeat yourself. The recurring interview question is when to choose an abstract class over an interface with defaults.

part ofKotlinoverview, primer and where to startread it →
on this pageshow

explore

questions

5

What is an abstract class in Kotlin, and how do you declare an abstract member that subclasses must implement?

level: juniorimportance: must knowfreq 80%

answer

  1. abstract = cannot instantiate
  2. abstract member = no body, must override
  3. concrete subclass overrides all or stays abstract
  4. can hold state + constructors unlike interfaces
  5. object : Abstract() {} fills it in

basics

~10 s

An abstract class is one you cannot create objects from directly. It can have members marked abstract that have no body, and any non-abstract subclass must provide their implementation.

solid answer

~30 s

An abstract class is declared with the abstract keyword and cannot be instantiated directly; you must subclass it. Inside it you can declare abstract members (functions or properties) using the abstract keyword with no body or initializer, e.g. abstract fun area(): Double. A non-abstract (concrete) subclass must override every inherited abstract member with the override keyword, or it must itself be declared abstract. Abstract classes can also contain normal concrete methods, state (backing fields), constructors, and init blocks. Trying to write val s = Shape() where Shape is abstract is a compile error.

code

kotlin · 11 lines
kotlin
abstract class Shape {
    abstract fun area(): Double
    fun printArea() = println(area())
}

class Square(val side: Double) : Shape() {
    override fun area() = side * side
}

// val s = Shape()  // ERROR: cannot create instance of abstract class
Square(2.0).printArea()  // 4.0

go deeper

for a junior

Knows abstract classes can't be instantiated and abstract members must be overridden by concrete subclasses.

for a middle

Explains mixing concrete and abstract members, constructors, and the exact compiler errors for missing overrides or instantiation.

for a senior

Contrasts abstract classes vs interfaces (state, constructors, single inheritance) and knows anonymous-object instantiation.

for a principal

Frames abstract classes as a design tool for shared invariant state and template behavior, weighing them against interfaces and composition.

## What 'abstract' means An **abstract class** is a class that is incomplete: it declares behavior but leaves some of it unimplemented, so it cannot be turned into an object by itself. You mark it with the `abstract` keyword. ```kotlin abstract class Shape { abstract val name: String // abstract property: no initializer abstract fun area(): Double // abstract function: no body fun describe(): String = // concrete method, fully implemented "$name has area $area" } ``` ## Abstract members A member marked `abstract` has **no implementation**: an abstract function has no `{ }` body, and an abstract property has no initializer and no getter body. It is a contract that says "every concrete subclass must supply this." ## Concrete subclasses must override A non-abstract subclass MUST provide a body for every inherited abstract member using `override`: ```kotlin class Circle(val r: Double) : Shape() { override val name = "circle" override fun area() = Math.PI * r * r } ``` If a subclass forgets one, the compiler reports "Class 'Circle' is not abstract and does not implement abstract member." A subclass may instead stay `abstract` and leave the member unimplemented for the next level down. ## Cannot instantiate `Shape()` is a compile error: "Cannot create an instance of an abstract class." You can only instantiate concrete subclasses, or use an `object : Shape() { ... }` anonymous object that fills in the abstract members. ## Mixing concrete and abstract Abstract classes are not all-or-nothing: they can hold normal methods, mutable/immutable state with backing fields, constructors, and `init` blocks — unlike interfaces, which have no constructor and no backing-field state.

  • Can an abstract class have a constructor?
    Yes. It can declare primary and secondary constructors with parameters and init blocks; subclasses call them via the super-constructor call in their supertype list, e.g. `: Shape(x)`.
  • Must every member of an abstract class be abstract?
    No. It can freely mix abstract members with fully implemented concrete methods, properties, and state.

An abstract class is like a blank form with some fields pre-filled and others left empty — you can't 'use' the blank form itself, only a completed copy.

saying these in an interview costs you the question

  • Saying you can instantiate an abstract class directly
  • Claiming all members of an abstract class must be abstract
  • Forgetting the override keyword when implementing an abstract member
  • Thinking an abstract class cannot hold state or a constructor
  • Confusing abstract with private — abstract is about missing implementation, not visibility

context

resolving links…

open as a page

Kotlin classes and members are final by default. How does the abstract modifier interact with this rule, and why don't you need to write 'open' on an abstract member?

level: middleimportance: must knowfreq 70%

basics

~10 s

In Kotlin everything is closed for inheritance unless you open it. Marking something abstract automatically makes it open, because an abstract member with no body only makes sense if subclasses can override it.

open as a page

Can an abstract class declare a member abstract when its superclass already provides a concrete (non-abstract) implementation of that member? When is this useful?

level: seniorimportance: should knowfreq 35%

basics

~10 s

Yes. An abstract subclass can override an inherited open method and re-declare it as abstract, removing the inherited implementation and forcing its own subclasses to supply a new one.

open as a page

When designing a type hierarchy, when would you choose an abstract class over an interface in Kotlin, given interfaces can have default method implementations?

level: seniorimportance: should knowfreq 55%

basics

~10 s

Choose an abstract class when you need shared stored state, a constructor, or want to allow only one parent. Choose an interface when you want a contract many unrelated types can implement and combine.

open as a page

What is the danger of calling an open or abstract member from the constructor (or init block / property initializer) of an abstract base class, and what does Kotlin do at that point?

level: principalimportance: nice to knowfreq 25%

basics

~20 s

When a base class is being constructed, the subclass part isn't set up yet. If the base constructor calls a method the subclass overrides, that override runs before the subclass's fields exist, so it may see uninitialized values or null.

open as a page