W jaki sposób delegacja kotlin jest przydatna?

Question

Jestem naprawdę zdezorientowany z powodu delegacji kotlin. Pozwólcie, że opiszę tutaj regularne podejście polimorfizmu, które wygląda tak samo jak delgacja kotlin.

interface Base { 
    fun print() 
} 
class BaseImpl(val x: Int) : Base { 
    override fun print() { print(x) } 
} 
fun main(args: Array<String>) { 
    val b : Base = BaseImpl(10) 
    b.print() // prints 10 
} 

mogę przekazać wszelkie wdrożone klasę Base interfejs do b zmiennej do wywołania metody obiektu określonej klasy użytkownika. Więc jaka jest korzyść z delegacji kotlin? Które jest opisane here.

interface Base { 
    fun print() 
} 
class BaseImpl(val x: Int) : Base { 
    override fun print() { print(x) } 
} 
class Derived(b: Base) : Base by b // why extra line of code? 
            // if the above example works fine without it. 
fun main(args: Array<String>) { 
    val b = BaseImpl(10) 
    Derived(b).print() // prints 10 
} 

Wiem, że jest to prosty scenariusz, w którym oba kody działają poprawnie. Powinna być korzyść z delegacji, dlatego kotlin go wprowadził. Jaka jest różnica? i w jaki sposób delegacja kotlin może być przydatna? Proszę podać przykład, który można by porównać z podejściem polimorfizmu.

Answer 1

Należy również pamiętać, że nie jesteś ograniczony do tylko jednego delegata. Sposób realizacji delegacji Kotlina jest podobny do wdrożenia traits w językach takich jak Groovy. Możesz komponować różne funkcje za pośrednictwem delegatów. Sposób Kotlin można również uznać za potężniejszy, ponieważ można też "podłączyć" różne implementacje.

interface Marks { 
    fun printMarks() 
} 

class StdMarks() : Marks { 
    override fun printMarks() { println("printed marks") } 
} 

class CsvMarks() : Marks { 
    override fun printMarks() { println("printed csv marks") } 
} 

interface Totals { 
    fun printTotals() 
} 

class StdTotals : Totals { 
    override fun printTotals() { println("calculated and printed totals") } 
} 

class CheatTotals : Totals { 
    override fun printTotals() { println("calculated and printed higher totals") } 
} 

class Student(val studentId: Int, marks: Marks, totals: Totals) 
    : Marks by marks, Totals by totals 

fun main(args:Array<String>) { 
    val student = Student(1,StdMarks(), StdTotals()) 
    student.printMarks() 
    student.printTotals() 
    val cheater = Student(1,CsvMarks(), CheatTotals()) 
    cheater.printMarks() 
    cheater.printTotals() 
} 

wyjściowa:

printed marks 
calculated and printed totals 
printed csv marks 
calculated and printed higher totals 

Nie można tego zrobić z dziedziczenia.

Answer 2

Jest to przydatne ze względu na Delegation Pattern, gdzie większość zachowań może być taka sama jak cel delegacji (b), ale chcesz tylko zastąpić podzbiór metod, aby działały inaczej.

Przykładem może być implementacja InputStream, która deleguje wszystkie prace do innego InputStream, ale przesłania metodę close(), aby nie zamykać bazowego strumienia. Można to zrealizować jako:

class CloseGuardInputStream(private val base: InputStream) 
    : InputStream by base { 
    override fun close() {} 
} 

Answer 3

Jest to niezwykle przydatne do tworzenia dekoratorów i kompozycji obiektów. Joshua Bloch w Efektywnej Java, wydanie 2, pozycja 16 "Skład faworyzowania nad dziedziczeniem" pokazuje dobry przykład: dziedziczenie jest łatwe do rozbicia, a dekoratorzy nie.

Dziedziczenie:

class LoggingList<E> : ArrayList<E>() { 

    override fun add(e: E): Boolean { 
     println("added $e") 
     return super.add(e) 
    } 

    override fun addAll(e: Collection<E>): Boolean { 
     println("added all: $e") 
     return super.addAll(e) // oops! Calls [add] internally. 
    } 

} 

Delegacja:

class LoggingList<E>(delegate: MutableList<E>) : MutableList<E> by delegate { 

    override fun add(e: E): Boolean { 
     println("added $e") 
     return delegate.add(e) 
    } 

    override fun addAll(e: Collection<E>): Boolean { 
     println("added all: $e") 
     return delegate.addAll(e) // all OK 
     // it calls [delegate]'s [add] internally, not ours 
    } 

}