Kotlin Klassen und Objekte

Klassendefinition

Kotlin-Klassen können Folgendes enthalten: Konstruktoren und Initialisierungsblöcke, Funktionen, Eigenschaften, innere Klassen und Objektdeklarationen.

In Kotlin deklariert das Schlüsselwortclasseine Klasse, direkt gefolgt vom Klassennamen:

class Example {  // 类名为 Example
    // 大括号内是类体构成
}

Wir können auch eine leere Klasse definieren:

class Empty

Memberfunktionen können in der Klasse definiert werden:

class Example() {
    fun foo() { print("Foo") } // 成员函数
}

Klasseneigenschaften

Eigenschaftsdefinition

Klasseneigenschaften können das Schlüsselwortvarverwenden, um veränderlich zu deklarieren; andernfalls verwenden Sie das schreibgeschützte Schlüsselwortval, um unveränderlich zu deklarieren.

class Example {
    var name: String = ……
    var url: String = ……
    var city: String = ……
}

Wir können Klasseninstanzen mit Konstruktoren genau wie normale Funktionen erstellen:

val site = Example() // Kotlin 中没有 new 关键字

Um eine Eigenschaft zu verwenden, genügt es, sie mit ihrem Namen anzusprechen

site.name           // 使用 . 号来引用
site.url

Eine Klasse in Kotlin kann einen Primärkonstruktor und einen oder mehrere Sekundärkonstruktoren haben. Der Primärkonstruktor ist Teil des Klassenkopfs und befindet sich nach dem Klassennamen:

class Person constructor(firstName: String) {}

Wenn der primäre Konstruktor keine Annotationen oder Sichtbarkeitsmodifikatoren hat, kann das Schlüsselwort constructor weggelassen werden.

class Person(firstName: String) {
}

Getter und Setter

Die vollständige Syntax zum Deklarieren einer Eigenschaft ist:

var <propertyName>[: <PropertyType>] [= <property_initializer>]
    [<getter>]
    [<setter>]
 

Sowohl Getter als auch Setter sind optional.

Wenn der Typ der Eigenschaft aus dem Initialisierer oder aus den Memberfunktionen der Klasse abgeleitet werden kann, kann der Typ weggelassen werden. val erlaubt keine Setter-Funktion, da es schreibgeschützt ist.

var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法
var initialized = 1    // 类型为 Int, 默认实现了 getter 和 setter
val simple: Int?       // 类型为 Int ,默认实现 getter ,但必须在构造函数中初始化
val inferredType = 1   // 类型为 Int 类型,默认实现 getter

Beispiel

Das folgende Beispiel definiert eine Person-Klasse mit zwei veränderlichen Variablen, lastName und no. lastName überschreibt die Getter-Methode und no überschreibt die Setter-Methode.

class Person {

    var lastName: String = "zhang"
        get() = field.toUpperCase()   // 将变量赋值后转换为大写
        set

    var no: Int = 100
        get() = field                // 后端变量
        set(value) {
            if (value < 10) {       // 如果传入的值小于 10 返回该值
                field = value
            } else {
                field = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }

    var heiht: Float = 145.4f
        private set
}

// 测试
fun main(args: Array<String>) {
    var person: Person = Person()

    person.lastName = "wang"

    println("lastName:${person.lastName}")

    person.no = 9
    println("no:${person.no}")

    person.no = 20
    println("no:${person.no}")

}

Die Ausgabe ist:

lastName:WANG
no:9
no:-1

Klassen in Kotlin können keine Felder haben. Manchmal ist jedoch ein Backing-Field erforderlich, wenn benutzerdefinierte Zugriffsmethoden verwendet werden. Zu diesem Zweck stellt Kotlin ein automatisches Backing-Field bereit, auf das über den field-Bezeichner zugegriffen werden kann.

Ein Backing-Field ist ein Konzept in Kotlin. Es ist ein automatisch generiertes Feld, das zum Speichern des Werts einer Eigenschaft verwendet wird. Es kann nur innerhalb von Zugriffsmethoden (Getter oder Setter) verwendet werden, und es existiert nur, wenn mindestens eine Zugriffsmethode die Standardimplementierung verwendet oder wenn eine benutzerdefinierte Zugriffsmethode über den field-Bezeichner darauf verweist. Das bedeutet, dass Kotlin automatisch eines bereitstellt, wenn eine Eigenschaft ein Backing-Field benötigt. Sie können den field-Bezeichner verwenden, um innerhalb einer Zugriffsmethode auf das Backing-Field zu verweisen.

var no: Int = 100
        get() = field                // 后端变量
        set(value) {
            if (value < 10) {       // 如果传入的值小于 10 返回该值
                field = value
            } else {
                field = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }

Natürlich, hier ist ein Beispiel für ein Backing-Field:

class Person {
    var name: String = "initial value"
        set(value) {
            if (value.isNotEmpty()) {
                field = value
            }
        }
}

In diesem Beispiel hat die Eigenschaft name einen benutzerdefinierten Setter, der prüft, ob der eingehende Wert leer ist. Wenn er nicht leer ist, verwendet er den field-Bezeichner, um den Wert dem Backing-Field zuzuweisen. Wenn wir also versuchen, der Eigenschaft name eine leere Zeichenfolge zuzuweisen, ändert sich ihr Wert nicht.

val person = Person()
println(person.name) // 输出 "initial value"
person.name = ""
println(person.name) // 仍然输出 "initial value"
person.name = "John"
println(person.name) // 输出 "John"

Im obigen Code haben wir eine Instanz der Klasse Person erstellt und versucht, den Wert ihrer Eigenschaft name zu ändern. Als wir versuchten, ihr eine leere Zeichenfolge zuzuweisen, blieb der Wert der Eigenschaft name aufgrund der Prüfung des benutzerdefinierten Setters unverändert. Als wir ihr eine nicht leere Zeichenfolge zuwiesen, wurde ihr Wert erfolgreich auf den neuen Wert geändert.

Nicht-Null-Eigenschaften müssen zum Zeitpunkt der Definition initialisiert werden. Kotlin bietet eine Möglichkeit, die Initialisierung zu verzögern, indem daslateinitSchlüsselwort verwendet wird, um die Eigenschaft zu annotieren:

public class MyTest {
    lateinit var subject: TestSubject

    @SetUp fun setup() {
        subject = TestSubject()
    }

    @Test fun test() {
        subject.method()  // dereference directly
    }
}

Primärer Konstruktor

Der primäre Konstruktor kann keinen Code enthalten. Initialisierungscode kann in einen Initialisierungsblock gesetzt werden, dem das Schlüsselwort init vorangestellt wird.

class Person constructor(firstName: String) {
    init {
        println("FirstName is $firstName")
    }
}

Hinweis: Parameter des primären Konstruktors können in Initialisierungsblöcken und auch in Eigenschaftsinitialisierern verwendet werden, die im Klassenkörper definiert sind. Eine prägnante Syntax ermöglicht es Ihnen, Eigenschaften zu definieren und ihre Werte über den primären Konstruktor zu initialisieren (kann var oder val sein):

class People(val firstName: String, val lastName: String) {
    //...
}

Wenn der Konstruktor Annotationen oder Sichtbarkeitsmodifizierer hat, ist das Schlüsselwort constructor erforderlich, und die Annotationen und Modifizierer müssen davor platziert werden.

Beispiel

Erstellen Sie eine Klasse Example und übergeben Sie den Website-Namen über den Konstruktor:

class Example  constructor(name: String) {  // 类名为 Example
    // 大括号内是类体构成
    var url: String = "http://www.example.com"
    var country: String = "CN"
    var siteName = name

    init {
        println("初始化网站名: ${name}")
    }

    fun printTest() {
        println("我是类的函数")
    }
}

fun main(args: Array<String>) {
    val example =  Example("Example")
    println(example.siteName)
    println(example.url)
    println(example.country)
    example.printTest()
}

Die Ausgabe ist:

初始化网站名: Example
Example
http://www.example.com
CN
我是类的函数

Sekundäre Konstruktoren

Eine Klasse kann auch sekundäre Konstruktoren haben, die das Präfix constructor benötigen:

class Person { 
    constructor(parent: Person) {
        parent.children.add(this) 
    }
}

Wenn die Klasse einen primären Konstruktor hat, muss jeder sekundäre Konstruktor an den primären Konstruktor delegieren, entweder direkt oder indirekt über einen anderen sekundären Konstruktor. Verwenden Sie das Schlüsselwort this, um an einen anderen Konstruktor derselben Klasse zu delegieren:

class Person(val name: String) {
    constructor (name: String, age:Int) : this(name) {
        // 初始化...
    }
}

Wenn eine nicht abstrakte Klasse keine Konstruktoren deklariert (primär oder sekundär), wird ein Konstruktor ohne Parameter generiert. Der Konstruktor ist öffentlich. Wenn Sie nicht möchten, dass Ihre Klasse einen öffentlichen Konstruktor hat, müssen Sie einen leeren primären Konstruktor deklarieren:

class DontCreateMe private constructor () {
}

Hinweis: Auf der JVM generiert der Compiler, wenn alle Parameter des primären Konstruktors Standardwerte haben, einen zusätzlichen Konstruktor ohne Argumente, der direkt die Standardwerte verwendet. Dies erleichtert Kotlin die Zusammenarbeit mit Bibliotheken wie Jackson oder JPA, die Klasseninstanzen mithilfe von Konstruktoren ohne Argumente erstellen.

class Customer(val customerName: String = "")

Beispiel

class Example  constructor(name: String) {  // 类名为 Example
    // 大括号内是类体构成
    var url: String = "http://www.example.com"
    var country: String = "CN"
    var siteName = name

    init {
        println("初始化网站名: ${name}")
    }
    // 次构造函数
    constructor (name: String, alexa: Int) : this(name) {
        println("Alexa 排名 $alexa")
    }

    fun printTest() {
        println("我是类的函数")
    }
}

fun main(args: Array<String>) {
    val example =  Example("Example", 10000)
    println(example.siteName)
    println(example.url)
    println(example.country)
    example.printTest()
}

Die Ausgabe ist:

初始化网站名: Example
Alexa 排名 10000
Example
http://www.example.com
CN
我是类的函数

Abstrakte Klassen

Abstraktion ist eines der Merkmale der objektorientierten Programmierung. Eine Klasse selbst oder einige Member einer Klasse können als abstrakt deklariert werden. Abstrakte Member haben keine konkreten Implementierungen in der Klasse.

Hinweis: Abstrakte Klassen oder abstrakte Member müssen nicht mit der Annotation open versehen werden.

open class Base {
    open fun f() {}
}

abstract class Derived : Base() {
    override abstract fun f()
}

Verschachtelte Klassen

Wir können Klassen in andere Klassen verschachteln. Siehe folgendes Beispiel:

class Outer {                  // 外部类
    private val bar: Int = 1
    class Nested {             // 嵌套类
        fun foo() = 2
    }
}

fun main(args: Array<String>) {
    val demo = Outer.Nested().foo() // 调用格式:外部类.嵌套类.嵌套类方法/属性
    println(demo)    // == 2
}

Innere Klassen

Innere Klassen werden mit dem Schlüsselwort inner gekennzeichnet.

Eine innere Klasse trägt eine Referenz auf ein Objekt der äußeren Klasse, daher kann die innere Klasse auf die Member-Eigenschaften und Member-Funktionen der äußeren Klasse zugreifen.

class Outer {
    private val bar: Int = 1
    var v = "成员属性"
    /**嵌套内部类**/
    inner class Inner {
        fun foo() = bar  // 访问外部类成员
        fun innerTest() {
            var o = this@Outer //获取外部类的成员变量
            println("内部类可以引用外部类的成员,例如:" + o.v)
        }
    }
}

fun main(args: Array<String>) {
    val demo = Outer().Inner().foo()
    println(demo) //   1
    val demo2 = Outer().Inner().innerTest()   
    println(demo2)   // 内部类可以引用外部类的成员,例如:成员属性
}

Um Mehrdeutigkeiten zu vermeiden, verwenden wir beim Zugriff auf this aus dem äußeren Gültigkeitsbereich this@label, wobei @label ein Label ist, das auf die Quelle von this verweist.


Anonyme innere Klassen

Verwenden Sie Objektausdrücke, um anonyme innere Klassen zu erstellen:

class Test {
    var v = "成员属性"

    fun setInterFace(test: TestInterFace) {
        test.test()
    }
}

/**
 * 定义接口
 */
interface TestInterFace {
    fun test()
}

fun main(args: Array<String>) {
    var test = Test()

    /**
     * 采用对象表达式来创建接口对象,即匿名内部类的实例。
     */
    test.setInterFace(object : TestInterFace {
        override fun test() {
            println("对象表达式创建匿名内部类的实例")
        }
    })
}

Klassenmodifikatoren

Klassenmodifikatoren umfassen classModifier und _accessModifier_:

  • classModifier: Modifikator für Klasseneigenschaften, der die eigenen Merkmale der Klasse angibt.

    abstract    // 抽象类  
    final       // 类不可继承,默认属性
    enum        // 枚举类
    open        // 类可继承,类默认是final的
    annotation  // 注解类
    
  • accessModifier: Zugriffsberechtigungsmodifizierer

    private    // 仅在同一个文件中可见
    protected  // 同一个文件中或子类可见
    public     // 所有调用的地方都可见
    internal   // 同一个模块中可见
    

Beispiel

// 文件名:example.kt
package foo

private fun foo() {} // 在 example.kt 内可见

public var bar: Int = 5 // 该属性随处可见

internal val baz = 6    // 相同模块内可见
Andere Erweiterungen