Interface with default implementations in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an interface with default implementations in Kotlin?

An interface in Kotlin can have methods with default implementations. This means you can define a function inside an interface with a body, so classes implementing the interface don't have to provide their own version unless they want to override it.

beginner

How do you declare a function with a default implementation inside a Kotlin interface?

Inside the interface, you write the function with its body, like this:<br>

interface MyInterface {
  fun greet() {
    println("Hello from interface")
  }
}

beginner

Can a class that implements an interface with default implementations choose to override those methods?

Yes. The class can use the default implementation or provide its own version by overriding the method.

intermediate

Why are default implementations in interfaces useful?

They let you add new functions to interfaces without breaking existing classes. Classes can use the default code or customize it, making code easier to maintain and extend.

intermediate

What happens if two interfaces with the same default method are implemented by a class?

The class must override the conflicting method and provide its own implementation to resolve the conflict.

In Kotlin, how do you provide a default implementation for a method in an interface?

A By writing the method with a body inside the interface

B By using the 'default' keyword before the method

C By implementing the method in the class only

D By declaring the method as abstract

In Kotlin, you simply write the method with its body inside the interface to provide a default implementation.

If a class implements an interface with a default method, what can it do?

A Ignore the method completely

B Override the method to provide its own implementation or use the default

C Only use the default implementation without changes

D Must always override the method

The class can choose to use the default implementation or override it with its own.

What must a class do if it implements two interfaces that have the same default method?

A Override the method to resolve the conflict

B Use the default method from the second interface

C Use the default method from the first interface

D The compiler automatically merges the methods

The class must override the conflicting method to resolve ambiguity.

Why are default implementations in interfaces helpful?

A They force all classes to implement the method

B They make interfaces slower

C They allow adding new methods without breaking existing code

D They remove the need for classes

Default implementations let you add new methods to interfaces without forcing all classes to change.

Which keyword is NOT used when defining default implementations in Kotlin interfaces?

A override

B fun

C interface

D default

Kotlin does not use the 'default' keyword for interface methods with implementations.

Explain how Kotlin interfaces support default implementations and why this feature is useful.

Think about how interfaces can have code inside them and how classes can use or change that code.

Describe what happens when a class implements two interfaces that have the same default method.

Consider how Kotlin handles multiple inheritance of behavior.