Erste Schritte mit Kotlin: Objektorientierte Programmierung – 04

1. Klassen und Objekte:

• In Kotlin classwerden Schlüsselwörter zum Definieren von Klassen und objectSchlüsselwörter zum Definieren von Objekten verwendet.
• Eine Klasse ist ein Bauplan für ein Objekt, der dessen Eigenschaften und Verhalten beschreibt, während ein Objekt eine Instanz einer Klasse ist.
• Klassen können Eigenschaften (Mitgliedsvariablen) und Methoden (Mitgliedsfunktionen) enthalten.

Code-Demo: 

// 定义一个简单的类
class Person(val name: String, var age: Int) {
    // 成员函数
    fun speak() {
        println("My name is $name, I'm $age years old.")
    }
}

fun main() {
    // 创建对象并调用成员函数
    val person = Person("Alice", 25)
    person.speak()
}

Operationsergebnis: 

My name is Alice, I'm 25 years old.

2. Vererbung:

• Kotlin unterstützt die Einzelvererbung und eine Unterklasse kann nur von einer übergeordneten Klasse erben.
• Verwenden Sie :Symbole, um Vererbungsbeziehungen anzugeben, z. B. class SubClass : SuperClass.
• Unterklassen können die Methoden und Eigenschaften der übergeordneten Klasse überschreiben und overrideSchlüsselwörter verwenden, um sie zu kennzeichnen.

 Code-Demo:

// 继承
open class Animal(val name: String) {
    open fun makeSound() {
        println("$name makes a sound.")
    }
}

class Dog(name: String) : Animal(name) {
    override fun makeSound() {
        println("Dog $name barks.")
    }
}

fun main() {
    // 创建Animal对象并调用makeSound方法
    val animal = Animal("Lion")
    animal.makeSound()

    // 创建Dog对象并调用makeSound方法
    val dog = Dog("Bobby")
    dog.makeSound()
}

Operationsergebnis: 

Lion makes a sound.
Dog Bobby barks.

3. Schnittstelle:

• Kotlin unterstützt die Definition und Implementierung von Schnittstellen, die abstrakte Methoden und Eigenschaften enthalten können.
• Verwenden Sie interfaceSchlüsselwörter zum Definieren von Schnittstellen und implementSchlüsselwörter zum Implementieren von Schnittstellen.
• Eine Klasse kann mehrere durch Kommas getrennte Schnittstellen implementieren.

 Code-Demo:

// 接口
interface Shape {
    fun calculateArea(): Double
}

class Rectangle(private val width: Double, private val height: Double) : Shape {
    override fun calculateArea(): Double {
        return width * height
    }
}
fun main() {
 
    // 接口示例
    val rectangle = Rectangle(5.0, 3.0)
    val area = rectangle.calculateArea()
    println("The area of the rectangle is $area")

  }

Operationsergebnis: 

The area of the rectangle is 15

 4. Kapselung und Zugriffskontrolle:

• Kotlin bietet vier Zugriffskontrollmodifikatoren : private, und .protectedinternalpublic
• Standardmäßig sind Mitglieder publicsichtbar.
• Verwenden Sie privateModifikatoren, um den Mitgliedszugriff nur innerhalb der Klasse einzuschränken, und verwenden Sie protectedModifikatoren, um den Zugriff durch Unterklassen zu ermöglichen.

Vergleich zwischen Java und Kotlin:

• 

 

Code-Demo: 

class Person(private val name: String, protected var age: Int) {
    fun introduce() {
        println("My name is $name.")
    }
    
    fun updateAge(newAge: Int) {
        age = newAge
    }
}

class Employee(name: String, age: Int, private val company: String) : Person(name, age) {
    fun work() {
        println("$name works at $company.")
    }
}

fun main() {
    val person = Person("Alice", 25)
    // 访问private属性，只能在类内部访问
    // person.name   // 编译错误：Unresolved reference: name
    person.introduce()
    
    val employee = Employee("Bob", 30, "ABC Company")
    // 访问protected属性，子类可以访问
    // employee.age   // 编译错误：Unresolved reference: age
    employee.work()
    
    // 修改age属性
    employee.updateAge(32)
    employee.work()
}

        Im obigen Code haben wir eine Person-Klasse und eine Employee-Klasse definiert. Die Person-Klasse verfügt über eine private Namenseigenschaft und eine geschützte Alterseigenschaft. Die Employee-Klasse erbt von der Person-Klasse und verfügt über alle von der übergeordneten Klasse geerbten Eigenschaften und Methoden sowie über eine private Unternehmenseigenschaft.

        In der Hauptfunktion erstellen wir ein Person-Objekt und ein Employee-Objekt. Wir können nicht direkt auf den Namen der privaten Eigenschaft des Objekts „Person“ oder auf das Alter der geschützten Eigenschaft des Objekts „Employee“ zugreifen, da die Sichtbarkeit dieser Eigenschaften eingeschränkt ist. Wir können jedoch indirekt auf diese Eigenschaften zugreifen, indem wir öffentliche Mitgliedsfunktionen aufrufen.

        Durch den Aufruf der updateAge-Methode der übergeordneten Klasse Person in der Employee-Klasse haben wir den Wert des Altersattributs erfolgreich geändert.

Operationsergebnis:

My name is Alice.
Bob works at ABC Company.
Bob works at ABC Company.

5. Eigenschaften und Felder:

• Eigenschaften in Kotlin können automatisch Getter- und Setter-Methoden für Felder generieren.
• Sie können valSchlüsselwörter verwenden , um schreibgeschützte Eigenschaften ( nur Getter ) zu definieren, und varSchlüsselwörter , um veränderliche Eigenschaften ( einschließlich Getter und Setter ) zu definieren.
• Sie können auch die Getter- und Setter-Methoden von Eigenschaften anpassen.

 Code-Demo:

package com.example.kotlin
class Person {
    var height: Double = 170.0  // 初始化属性

    var isTall: Boolean
        get() {
            return height >= 180  // 自定义getter方法
        }
        set(value) {
            height = if (value) {
                185.0  // 自定义setter方法
            } else {
                170.0
            }
        }
}

fun main() {
    val person = Person()
    println(person.isTall)  // 调用自定义的getter方法判断是否高个子
    println(person.height)
    person.isTall = true  // 调用自定义的setter方法将身高设置为185
    println(person.height)
}

 Operationsergebnis:

 6. Datentyp:

•  Datenklassen sind eine spezielle Art von Klasse, die von Kotlin zum Speichern und Bearbeiten von Daten bereitgestellt wird.
•  In Datenklassen generiert der Compiler automatisch equal(), hashCode(), toString() und andere Methoden.
• Verwenden Sie das Schlüsselwort „Datenklasse“, um eine Datenklasse zu definieren.

 Code-Demo:

data class Person(val name: String, val age: Int)

fun main() {
    val person1 = Person("John", 25)
    val person2 = Person("John", 25)
    
    println(person1)  // 调用自动生成的toString()方法
    println(person1 == person2)  // 调用自动生成的equals()方法
    
    val person3 = person1.copy(age = 30)  // 使用copy()方法复制对象并修改其中的属性
    
    println(person3)
}

 Operationsergebnis: 

7. Erweiterte Funktionen und erweiterte Attribute:

• Kotlin ermöglicht das Hinzufügen neuer Funktionen und Eigenschaften zu bestehenden Klassen, sogenannte Erweiterungsfunktionen und Erweiterungseigenschaften.
• fun ClassName.methodName()Zum Definieren von Erweiterungsfunktionen verwenden .
• val ClassName.propertyNameZum Definieren erweiterter Eigenschaften  verwenden .

Code-Demo:

// 定义一个String类型的扩展函数
fun String.addWelcomeMessage(): String {
    return "Welcome, $this!"  // 在字符串前面添加欢迎消息
}

// 定义一个Int类型的扩展属性
val Int.isEven: Boolean
    get() = this % 2 == 0  // 判断整数是否为偶数

fun main() {
    val name = "John"
    println(name.addWelcomeMessage())  // 调用扩展函数为字符串添加欢迎消息

    val number = 6
    println(number.isEven)  // 调用扩展属性判断整数是否为偶数
}

 Operationsergebnis: