kotlinの委任はどのように便利ですか？

Question

私はコットンの代表団について本当に混乱しています。ここでは、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 
} 

私は指定されたクラスのオブジェクトのメソッドを呼び出すためにb変数にBaseインタフェースの実装クラスを渡すことができます。それでは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 
} 

これは、両方のコードが正常に動作している単純なシナリオです。代表団の利益があるはずだからこそ、kotlinはそれを導入したのです。違いはなんですか？コトリンの代表団がどのように役立つのでしょうか？多型アプローチと比較するための実例を私にお願いします。

Answer 1

はまた、あなただけの1デリゲートに限定されていないことを覚えておいてください。 Kotlinが委譲を実装する方法は、Groovyのような言語でtraitsの実装と似ています。代理人を介して異なる機能を構成することができます。 Kotlinのやり方は、異なる実装を「プラグイン」することもできるので、より強力と考えることができます。

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

ほとんどの動作が委任先（b）のターゲットと同じになることがありますが、異なる方法で動作するメソッドのサブセットをオーバーライドしたい場合は、Delegation Patternが役に立ちます。

例はInputStreamの実装であり、すべての作業を別のInputStreamに委任しますが、close()のメソッドをオーバーライドして基本ストリームを閉じません。

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

Answer 3

デコレータの作成やオブジェクトの作成に非常に便利です。 Joshua Bloch、Effective Java、第2版、アイテム16 '継承を優先して合成する'は良い例です。継承は簡単にできますし、デコレータもそうではありません。

継承：

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 
    } 

}