Cotlin継承、インターフェースと拡張

Javaでは、すべての対象はObjectをデフォルトで継承しています。中にはいくつかのデフォルトの方法があります。equals()、hashCode()、toString()などの方法があります。Kotlinでは、すべてのオブジェクトがデフォルトでAnyを継承しています。

public open class Any {
    public open operator fun equals(other: Any?): Boolean

    public open fun hashCode(): Int

    public open fun toString(): String
}

その中には3つの方法があります。書き換えることができます。Javaのクラスは、デフォルトでは継承できますが、Kotlinではデフォルトでは継承できません。openというキーワードに注意してください。修飾があれば継承できます。クラスでも方法でも、属性の値でもいいです。

open class A {
    open fun a () { print("A") }

}

class B : A(){
    override fun a() {
        print("B")
    }
}

ここで、継承使用：これを単独で見ても名場が見えません。今はちょっと調整します。

open class A1(name: String) {
    var name = name
    open fun a () { print("A") }
    constructor() : this("a1")
}

class B1 : A1{
    constructor() : super("b1")
    override fun a() {
        print("B1")
    }
}

この例では、A 1の構造方法は一つのパラメータを含む構造であり、この表記はJavaとは違って、classの後ろに直接括弧を添加する構造方法は主に構成されています。パラメータがない場合は、空いている括弧を書いたり、括弧を省略したりすることができます。このようにデフォルトでは無参構造です。A 1のconstructor（）は、主な構造方法を呼び出す必要があります。上記のように構成されています。B 1でA 1を継承した場合、柱構造の後ろにA 1の空き構造があり、サブクラスは構造方法で親類の主な構造方法を呼び出さなければならないので、B 1の中にconstructor()：super(b 1)があり、上記を簡略化して「b 1」とすることができる。

class B2 : A1("b2"){
    override fun a() {
        print("B2")
    }
}

直接B 2の主な構造の後ろにA 1の主な構造方法をフォローします。次の状況を見てみます。

class B3 : A1{
    constructor(name: String) : super(name)
    constructor(name: String, age : Int) : this(name)
    override fun a() {
        print("B3")
    }
}

B 3において、内部の補助構造方法は、最終的には親類の主な構造方法を呼び出さなければならない。B 3の2つのパラメータ構造方法のように一つのパラメータの構造を呼び出し、一つのパラメータの構造は親類の一つのパラメータの構造方法を呼び出さなければならない。もう一つの実体類は抽象類と一つのインターフェースを継承しています。抽象類とインターフェースはちょうど同じ抽象的な方法があります。 の場合、サブクラスはもう一つしか書けませんが、kotlinでは書き換え後も親タイプの呼び方ができます。

open class AA {
    open fun ss () { println("A") }
    fun a() { println("a") }
}

interface BB {
    fun ss() { println("B") }
    fun b() { println("b") }
}

class CC : AA(), BB{
    override fun ss() {
        super.ss()//   AA.ss()
        super.ss()//   BB.ss()
    }
}

fun test(){
    val c =  CC()
    c.ss()
}

運転後、印刷された値は

A
B

javaのjdk 1.8では、インターフェースはやはり抽象的な方法と変数しか定義できません。書き換えることができる非抽象的な方法は定義できません。

interface A {
    var name:String //name   ,    
    fun start() { println("start A") }   //    
    fun end()                  //    
}

interface B {
    fun start() { println("start B") }   //    
    fun end() { println("end B") } //    
}

class C : A {
    override var name: String = "C" //    
    override fun end() { println("end C") }   //   
}

class D : A, B {
    override var name: String = "D" //    
    override fun start() {
        super.start()
        super.start（）
    }
    override fun end(){
        super.end()
        printl(name)
    }
)
fun test 1(){
    val d= D()
    d.start()
    d.end()
)

印刷構造は

start A
start B
end B
D

KotlinはJavaより一つの拡張関数の概念が多くなりました。どういう意味ですか？例を見ます

class A{
    fun test(){
        println(" test  A ")
    }
}

fun A.too(){
    println(" too  A ")
}

fun function(){
    var a = A()
    a.test()
    a.too()
}

この例では、オブジェクトAを定義し、Aにはtest()の方法がある。上のA.too（）は、オブジェクトの存在を優先する静的な方法です。私たちはfunction()メソッドを呼び出して、データを印刷します。

 test  A
 too  A

拡張は静的な方法ですが、直接に呼び出したい場合は、以下の通りです。

class AA{
    fun test(){
        println(" test  AA ")
    }
    companion object
}

fun AA.too(){
    println(" too  AA ")
}

fun AA.Companion.to(){
    println(" to  AA ")
}

fun function(){
    var aa = AA()
    aa.test()
    aa.too()
    AA.to()
}

メソッドを呼び出して、データを印刷します。

 test  AA
 too  AA
 to  AA