【移動應(yīng)用開發(fā)技術(shù)】Kotlin如何創(chuàng)建接口或者抽象類

【移動應(yīng)用開發(fā)技術(shù)】Kotlin如何創(chuàng)建接口或者抽象類

這篇文章給大家分享的是有關(guān)Kotlin如何創(chuàng)建接口或者抽象類的內(nèi)容。在下覺得挺實用的，因此分享給大家做個參考，一起跟隨在下過來看看吧。一，定義接口和抽象類interface

IPerson{

//獲取名字

fun

getName():String

//獲取身份證ID

fun

getID():String

}

abstract

class

BaseAnimal{

abstract

fun

getVoice():String

}二，創(chuàng)建對應(yīng)的匿名對象

object

:

IPerson

{

override

fun

getName():

String

=

"jason"

override

fun

getID():

String

=

"00000123"

}

object

:

BaseAnimal()

{

override

fun

getVoice()

=

"旺旺叫"

}補(bǔ)充知識：androidKotlin繼承、派生、接口、構(gòu)造方式，方法、屬性重寫前言kotlin作為google官方android開發(fā)語言，大勢所趨，據(jù)傳到2018底kotlin要全面替代java在android中的地位，其實這個也不擔(dān)心畢竟kotin和java可以100%互操作。兩種語言進(jìn)行編寫也是可以的。Kotlin繼承1.使用open關(guān)鍵字進(jìn)行修飾2.主構(gòu)造函數(shù)緊跟著在類后面聲明的函數(shù)open

class

Person(var

name

:

String,

var

age

:

Int){//

基類

}

class

Student(name

:

String,

age

:

Int,

var

no

:

String,

var

score

:

Int)

:

Person(name,

age)

{

}

//

二級構(gòu)造函數(shù)

calss

Student

:

Person

{

constructor(ctx:

Context)

:

super(ctx)

{

}

constructor(ctx:

Context,

attrs:

AttributeSet)

:

super(ctx,attrs)

{

}

}另一種寫法，基類構(gòu)造函數(shù)，次級構(gòu)造函數(shù)/**用戶基類**/

open

class

Person(name:String){

/**次級構(gòu)造函數(shù)**/

constructor(name:String,age:Int):this(name){

//初始化

println("基類次級構(gòu)造函數(shù)")

}

}

/**子類繼承

Person

類**/

class

Student:Person{

/**次級構(gòu)造函數(shù)**/

constructor(name:String,age:Int,no:String,score:Int):super(name,age){

println("繼承類次級構(gòu)造函數(shù)")

println("學(xué)生名：

${name}")

println("年齡：

${age}")

println("學(xué)生號：

${no}")

println("成績：

${score}")

}

}

fun

main(args:

Array<String>)

{

var

s

=

Student("Runoob",

18,

"S12345",

89)

}方法重寫基類fun函數(shù)默認(rèn)final修飾符，無法在子類進(jìn)行重寫需要加上open修飾符號方法獲得，同名方法獲得一個類從其他類或者接口（繼承實現(xiàn)來的方法），同名方法，在子類中必須顯示進(jìn)行調(diào)用

open

class

A

{

open

fun

f

()

{

print("A")

}

fun

a()

{

print("a")

}

}

interface

B

{

fun

f()

{

print("B")

}

//接口的成員變量默認(rèn)是

open

的

fun

b()

{

print("b")

}

}

class

C()

:

A()

,

B{

override

fun

f()

{

super<A>.f()//調(diào)用

A.f()

super<B>.f()//調(diào)用

B.f()

}

}

fun

main(args:

Array<String>)

{

val

c

=

C()

c.f();

}

open

class

A

{

open

fun

f

()

{

print("A")

}

fun

a()

{

print("a")

}

}

interface

B

{

fun

f()

{

print("B")

}

//接口的成員變量默認(rèn)是

open

的

fun

b()

{

print("b")

}

}

class

C()

:

A()

,

B{

override

fun

f()

{

super<A>.f()//調(diào)用

A.f()

super<B>.f()//調(diào)用

B.f()

}

}

fun

main(args:

Array<String>)

{

val

c

=

C()

c.f();

}屬性重寫屬性重寫使用override關(guān)鍵字，屬性必須具有兼容類型，每一個聲明的屬性都可以通過初始化程序或者getter方法被重寫：open

class

Foo

{

open

val

x:

Int

get

{

……

}

}

class

Bar1

:

Foo()

{

override

val

x:

Int

=

……

}你可以用一個var屬性重寫一個val屬性，但是反過來不行。因為val屬性本身定義了getter方法，重寫為var屬性會在衍生類中額外聲明一個setter方法你可以在主構(gòu)造函數(shù)中使用override關(guān)鍵字作為屬性聲明的一部分:interface

Foo

{

val

count:

Int

}

class

Bar1(override

val

count:

Int)

:

Foo

class

Bar2

:

Foo

{

override

var

count:

Int

=

0

}Kotlin接口Kotlin接口與Java8類似，使用interface關(guān)鍵字定義接口，允許方法有默認(rèn)實現(xiàn)：interface

MyInterface

{

fun

bar()

//

未實現(xiàn)

fun

foo()

{

//已實現(xiàn)

//

可選的方法體

println("foo")

}

}接口中的屬性接口中的屬性只能是抽象的，不允許初始化值，接口不會保存屬性值，實現(xiàn)接口時，必須重寫屬性：interface

MyInterface{

var

name:String

//name

屬性,

抽象的

}

class

MyImpl:MyInterface{

override

var

name:

String

=

"runoob"

//重載屬性

}函數(shù)重寫實現(xiàn)多個接口時，可能會遇到同一方法繼承多個實現(xiàn)的問題。例如:實例interface

A

{

fun

foo()

{

print("A")

}

//

已實現(xiàn)

fun

bar()

//

未實現(xiàn)，沒有方法體，是抽象的

}

interface

B

{

fun

foo()

{

print("B")

}

//

已實現(xiàn)

fun

bar()

{

print("bar")

}

//

已實現(xiàn)

}

class

C

:

A

{

override

fun

bar()

{

print("bar")

}

//

重寫

}

class

D

:

A,

B

{

override

fun

foo()

{

super<A>.foo()

super<B>.foo()

}

override

fun

bar()

{

super<B>.bar()

}

}

fun

main(args:

Array<String>)

{

val

d

=

D()

d.foo();

d.bar();

}輸出結(jié)果為：ABbar實例中接口A和B都定義了方法foo()和bar()，兩者都實現(xiàn)了foo(),B實現(xiàn)了bar()。因為C是一個實現(xiàn)了A的具體類，所以必須要重寫bar()并實現(xiàn)這個抽象方法。然而，如果我們從A和