科特林代表团如何有用？

Question

我真的很困惑kotlin代表团。让我来描述这里的规则多态性方法，它看起来像kotlin delgation一样。

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 
} 

我可以通过任何实现类Base接口来b变量来调用指定的类的对象的方法。那么kotlin的代表团有什么好处？其中描述了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 
} 

我知道这是两个代码工作正常的简单场景。这应该是委托的好处，这就是科特林介绍它的原因。有什么不同？科特林代表团如何有用？请给我一个工作示例，以便与多态性方法进行比较。

Answer 1

还记得，你不再仅仅限于一个代表。 Kotlin实现授权的方式类似于Groovy等语言中的traits实现。您可以通过代表编写不同的功能。科特林的方式也可以被认为更强大，因为你可以“插入”不同的实现。

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() 
} 

输出：

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

你不能继承做到这一点。

Answer 2

这很有用，因为Delegation Pattern其中大部分行为可以与委派的目标相同（b），但您只是想重写方法的子集以采取不同的行为。

一个示例是InputStream实现，该实现将所有工作委托给另一个InputStream，但覆盖close()方法以不关闭底层流。这可以实现为：

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

Answer 3

这对于创建装饰器和对象组合非常有用。 Joshua Bloch在Effective Java中的第2版第16项'Favor Composition Over Inheritance'显示了一个很好的例子：继承很容易破解，而装饰器不是。

继承：

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. 
    } 

} 

代表团：

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 
    } 

}