Skip to main content

Delegation based Kotlin interview questions and answers

What is Kotlin delegation?

Kotlin supports the “delegation” design pattern by introducing a new keyword “by”. Using the keyword or delegation methodology. Kotlin allows the derived class to access all of the implemented public methods of an interface through a specific object.

Example

  1. Live Demo
  2. interface Base {
  3. fun printMe() //abstract method
  4. }
  5. class BaseImpl(val x: Int) : Base {
  6. override fun printMe() { println(x) } //implementation of the method
  7. }
  8. class Derived(b: Base) : Base by b // delegating the public method on the object b
  10. fun main(args: Array<String>) {
  11. val b = BaseImpl(10)
  12. Derived(b).printMe() // prints 10 :: accessing the printMe() method
  13. }

Output
10

Comments

Post a Comment

Popular posts from this blog

Kotlin Some important unsorted interview questions and answers

Image
  What is inline class in Kotlin and when do we need one? Provide an example.  What is inline class in Kotlin and when do we need one? Provide an example. Senior Answer Sometimes it is necessary for business logic to create a wrapper around some type. However, it introduces runtime overhead due to additional heap allocations. Moreover, if the wrapped type is primitive, the performance hit is terrible, because primitive types are usually heavily optimized by the runtime. Inline classes  provide us with a way to wrap a type, thus adding functionality and creating a new type by itself. As opposed to regular (non-inlined) wrappers, they will benefit from improved performance. This happens because the data is inlined into its usages, and object instantiation is skipped in the resulting compiled code. inline class Name ( val s : String ) { val length : Int get ( ) = s . length fun greet ( ) { println ( "Hello, $s " ) } } fun ma...
Read more

Most Developers Build Offline-First Apps Wrong — Here's What They Miss with Room

Image
  When you say your app works offline… does it really? A surprising number of Android developers proudly add “offline-first” to their app descriptions. And sure, the app opens without internet. Maybe it even loads a few screens. But dig a little deeper and it becomes clear: most offline-first implementations fall apart fast. Why? Because building an offline-first experience isn’t about just storing data locally. It’s about doing it intentionally , with the right structure, cleanup, and flow. And the culprit behind most of the silent issues? Room Database. Not because Room is bad — but because it's misunderstood. Let’s walk through some of the most common mistakes developers make when using Room in offline-first apps — and what to do instead. Mistake 1: Saving the Entire API Response into Room Many devs take the raw JSON response from their API and store it directly into Room entities — every field, every nested object, even things the app never uses. Why it’s a probl...
Read more

Build Bigger Android Apps, Faster: Why Git LFS Is a Game-Changer for Large Assets

Image
  Tame large files and streamline your development workflow with Git Large File Storage (LFS) If you're an Android developer building feature-rich apps with stunning graphics, on-device machine learning, or immersive media — chances are you've bumped into Git’s limitations. From high-res images and videos to .tflite models and APKs, large files can seriously slow down your Git repo, mess with version control, and frustrate your team. That’s where Git Large File Storage (LFS) comes in. In this post, you'll learn how Git LFS helps Android developers manage large assets more efficiently, avoid Git pitfalls, and deliver faster, cleaner projects. Why Android Projects Need Git LFS Modern Android apps aren’t just about code — they’re rich experiences powered by assets: Images and animations for splash screens, UI elements, and AR Audio and video files for e-learning, podcasts, or games Machine learning models for features like face detection or text translatio...
Read more