Cómo poner en práctica sólida en un interfaz de la segregación

StuartDTO:

Tengo una interfacecomo esta:

interface ClientRequestListener {
    fun onLoadStub(name: String)
    fun onClientNeeded(id: String, email: String)
}

Pero entonces, al ponerla en una clase sólo necesito el onClientNeeded¿hay alguna manera de evitar tener que sustituir estos dos métodos? He tratado de crear otra interfaz que se extiende esa pero todavía me pide que poner en práctica los métodos ..

Aclaración

Estoy usando una biblioteca externa, que utiliza una interfaz con estos dos métodos, y la cosa es donde yo estoy usando esto sólo necesito un método en lugar de dos, y en lugar de tener una anulación haciendo algo que sólo quería saber una manera de evitar que la anulación extra que no necesito.

EDITAR

fun doSomeMagic(name: String, clientRequestListener: ClientRequestListener? = null) =
    LibraryRequest.getClient(name)
        .withListener(object : LibraryInterface() {
            override fun onLoadStub(name: String) {
                clientRequestListener?.onLoadStub(name)
            }

            override fun onClientNeeded(id: String, email: String) {
                clientRequestListener?.onClientNeeded(id, email)
            }
        })

Así que cuando estoy usando este método hago algo como esto:

doSomeMagic("Charls", object : ClientRequestListener {
  override fun onClientNeeded(name: String) {
    //I'm not doing nothing here
  }

  override fun onClientNeeded(id: String, email: String) {
    //Do something with the id and email
  }
})

Así que lo que me gustaría hacer algo para llamar solamente onClientNeededallí en vez ambos.

Demigod:

Puede cambiar las cosas en un varias opciones aquí:

a) Se puede crear una clase abstracta que proporcionará defecto (aplicación vacío) del método que no sean necesarios, y le obligará a anular único método que estés interesado en:

abstract class AbsClientRequestListener {
    override fun onLoadStub(name: String) {
    }
    abstract fun onClientNeeded(id: String, email: String)
}

b) Si usted tiene un hierarachy de clases, puede proporcionar una implementación por defecto en su clase base y dejar onClientNeededsin aplicarse para las subclases:

interface ClientRequestListener {
    fun onLoadStub(name: String)
    fun onClientNeeded(id: String, email: String)
}

abstract class BaseClient: ClientRequestListener {
    override fun onLoadStub(name: String) {
        // Leave empty
    }
}

class Client:BaseClient() {
    override fun onClientNeeded(id: String, email: String) {
        // Put required implementation
    }
}

c) O simplemente puede utilizar esta interfaz como está y proporcionar una implementación vacía cada vez :)

EDITAR

En su caso específico se puede agregar la clase ClientRequestListenerAdapter:

abstract class ClientRequestListenerAdapter : ClientRequestListener {
    override fun onLoadStub(name: String) {
    }
}

Y utilizar de esta manera:

doSomeMagic("Charls", object : ClientRequestListenerAdapter {
  override fun onClientNeeded(id: String, email: String) {
    //Do something with the id and email
  }
})

No hay cambios en la función doMagicson necesarios.