How to gracefully encapsulate anonymous inner classes (DSL, high-order functions) in kotlin

Anonymous inner classes in Java Is a feature often used in , For example, in Android Various in development Listener, It's also easy to use , such as ：

//lambda
button.setOnClickListener(v -> {
    
  //do some thing
});
// Anonymous inner class 
button.setOnClickListener(new View.OnClickListener() {
    
    @Override
    public void onClick(View v) {
    
        //do some thing
    }
});

There is only one function interface in Java and Kotlin Can be very convenient to use lambda Expression to abbreviate , But if the interface contains multiple functions , It's easy to use ” Not elegant “ 了 , for example ：

etString.addTextChangedListener(object :TextWatcher{
    
    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
    
        TODO("Not yet implemented")
    }
    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
    
        TODO("Not yet implemented")
    }
    override fun afterTextChanged(s: Editable?) {
    
        TODO("Not yet implemented")
    }
})

Use with Java Almost , adopt object Keyword implements an anonymous inner class , There's no big problem with this method , In the example above , The three callback functions are not used every time , Many scenarios may only use one or several of them , The rest are empty implementations , It's just not elegant to write such an anonymous inner class every time .

stay Kotlin There are two ways to achieve elegant use of anonymous inner classes ：

• DSL
• Higher order function

DSL

DSL The implementation of encapsulation can be divided into the following steps ：

1. Create the interface implementation class ：XxxxInterfaceDslImpl

And on top of it TextWatcher As an example ：

class TextWatcherDslImpl : TextWatcher {
    

    // Corresponding to the original interface kotlin Function object 
    private var afterTextChanged: ((Editable?) -> Unit)? = null

    private var beforeTextChanged: ((CharSequence?, Int, Int, Int) -> Unit)? = null

    private var onTextChanged: ((CharSequence?, Int, Int, Int) -> Unit)? = null

    /** * DSL Functions used in , Generally, you can keep the same name  */
    fun afterTextChanged(method: (Editable?) -> Unit) {
    
        afterTextChanged = method
    }

    fun beforeTextChanged(method: (CharSequence?, Int, Int, Int) -> Unit) {
    
        beforeTextChanged = method
    }

    fun onTextChanged(method: (CharSequence?, Int, Int, Int) -> Unit) {
    
        onTextChanged = method
    }

    /** *  Functions that implement the original interface  */
    override fun afterTextChanged(s: Editable?) {
    
        afterTextChanged?.invoke(s)
    }

    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
    
        beforeTextChanged?.invoke(s, start, count, after)
    }

    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
    
        onTextChanged?.invoke(s, start, before, count)
    }
}

This implementation class consists of three parts ：

1. Corresponding to the original interface method Kotlin Function object , The signature of the function object is consistent with the corresponding method signature
2. DSL function , The name of the function 、 All signatures correspond to the methods of the original interface one by one , Used to receive lambda Assign a value to Kotlin Function object
3. Implementation of the original interface method , Implementation of each interface method , It's all about implementing Kotlin Function object call

2. Create an extension function with the same name as the original function , The function parameter is the implementation class extension function

fun TextView.addTextChangedListenerDsl(init: TextWatcherDslImpl.() -> Unit) {
    
    val listener = TextWatcherDslImpl()
    listener.init()
    this.addTextChangedListener(listener)
}

The extension function has the same name as the original function, which is convenient for users to call , There is no need to remember other function names , If you're worried about confusion , You can add... After the function name Dsl To distinguish . The parameter of this function is the extension function of the implementation class we created in the first step , This is to achieve DSL grammar .

3. Use

etString.addTextChangedListenerDsl {
    
    afterTextChanged {
    
        if (it.toString().length >= 4) {
    
            KeyboardUtils.toggleSoftInput()
        }
    }
}

When using this method , It can be said to be quite elegant , We just need to call the interface method we need to implement , Interface methods that do not need to be used are null by default .

Higher order function

Higher order function mode is better than DSL The way is simpler ：

inline fun TextView.addTextChangedListenerClosure(
    crossinline afterTextChanged: (Editable?) -> Unit = {
    },
    crossinline beforeTextChanged: (CharSequence?, Int, Int, Int) -> Unit = {
     charSequence, start, count, after -> },
    crossinline onTextChanged: (CharSequence?, Int, Int, Int) -> Unit = {
     charSequence, start, after, count -> }
) {
    
    val listener = object : TextWatcher {
    
        override fun afterTextChanged(s: Editable?) {
    
            afterTextChanged.invoke(s)
        }

        override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
    
            beforeTextChanged.invoke(s, start, count, after)
        }

        override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
    
            onTextChanged.invoke(s, start, before, count)
        }
    }
    this.addTextChangedListener(listener)
}

We create an extension function with the same name , Use Closure Tail affix as a distinction , The parameters of this function are one-to-one corresponding to the interface method Kotlin Function object , And assign its default value to {} Namely empty implementation , In the body of the function, pass object Keyword to build an anonymous inner class implementation object , In the implementation of its interface method, it calls one to one. Kotlin Function object .

It is used in the same way as ordinary Kotlin Higher order functions are used in the same way ：

etString.addTextChangedListenerClosure(
    afterTextChanged = {
    
        if (it.toString().length >= 4) {
    
            KeyboardUtils.toggleSoftInput()
        }
    },
)

tips：

In the extension function of the above example , We used inline And crossinline Two keywords , This is a Koltin Peculiar .inline Keywords are often used to decorate higher-order functions , Used to improve performance .crossinline Declarative lambda Partial return is not allowed , Used to avoid the wrong use of the caller return Cause the function to interrupt .

Provide a sample code , Try it yourself, maybe you can understand it better ：

@Test
fun testInline() {
    
    testClosure {
    
        return
    }
}
private inline fun testClosure(test: (String) -> String ) {
    
    println("step 1")
    println(test("step test"))
    println("step 2")
}