In diesem Tutorial werden wir die Konzepte der objektorientierten Programmierung in Kotlin diskutieren. Wir werden die Kotlin-Klasse im Detail besprechen. Wir werden uns auch Kotlin-Konstruktoren, Zugriffsmodifizierer und abstrakte Klasse ansehen.
Kotlin-Klasse
Eine Klasse ist eine definierte Blaupause, die Funktionen und Eigenschaften gruppiert. Klassen in Kotlin werden mit dem Schlüsselwort class gefolgt vom Klassennamen definiert. Der Körper der Klasse befindet sich in geschweiften Klammern.
class FirstClass {
}
Eine Instanz der Klasse wird auf folgende Weise instanziiert:
val firstClass = FirstClass()
var new = FirstClass() //here new is the name of the var.
Im Gegensatz zu Java ist new kein Schlüsselwort in Kotlin. Klassen sind standardmäßig final in Kotlin. Daher würde die entsprechende Definition in Java ungefähr so aussehen:
public final class FirstClass {
}
Daher sind Klassen in Kotlin standardmäßig nicht vererbbar. Um eine Klasse nicht-final zu machen, müssen wir das Schlüsselwort open hinzufügen.
open class Me{
}
Die Annotation open ermöglicht es anderen, von dieser Klasse zu erben.
Beispiel für eine Kotlin-Klasse
Lassen Sie uns eine Klasse mit einigen Funktionen und einer Eigenschaft erstellen. Wir werden sehen, wie auf die Funktionen und Eigenschaften dieser Klasse zugegriffen wird. Darüber hinaus werden wir sehen, wie die Member-Eigenschaften gesetzt werden können.
class User {
var loggedIn: Boolean = false
val cantChangeValue = "Hi"
fun logOn() {
loggedIn = true
}
fun logOff() {
loggedIn = false
}
}
fun main(args: Array<String>) {
val user = User()
println(user.loggedIn) //false
user.logOn()
println(user.loggedIn) //true
user.logOff()
println(user.loggedIn) //false
user.cantChangeValue = "Hey" //won't compile. Can't modify a final variable.
}
Die Funktion main gehört zur Klasse Test.kt. Um auf Mitglieder und Funktionen zuzugreifen, müssen wir den Punktoperator verwenden. Eine val-Eigenschaft kann nicht erneut mit einem Punktoperator gesetzt werden.
Kotlin init
Der Kotlin-Init-Block ist wie folgt definiert.
class User {
init{
print("Class instance is initialised.")
}
var loggedIn: Boolean = false
val cantChangeValue = "Hi"
fun logOn() {
loggedIn = true
}
fun logOff() {
loggedIn = false
}
}
Der Code innerhalb des init-Blocks wird als Erstes ausgeführt, wenn die Klasse instanziiert wird. Der init-Block wird jedes Mal ausgeführt, wenn die Klasse instanziiert wird, unabhängig vom verwendeten Konstruktor, wie wir als Nächstes sehen werden. Mehrere Initialisierungsblöcke können in einer Klasse geschrieben werden. Sie werden wie unten gezeigt sequentiell ausgeführt.
class MultiInit(name: String) {
init {
println("First initializer block that prints ${name}")
}
init {
println("Second initializer block that prints ${name.length}")
}
}
fun main(args: Array) {
var multiInit = MultiInit("Kotlin")
}
//Das folgende wird im Log-Konsole gedruckt.
//Erster Initialisierungsblock, der Kotlin druckt
//Zweiter Initialisierungsblock, der 6 druckt
In Kotlin-Klassen können Eigenschaften bereits in der Deklaration gedruckt werden, indem die Funktion also wie unten gezeigt verwendet wird.
class MultiInit(name: String) {
val firstProperty = "First property: $name".also(::println)
init {
println("First initializer block that prints ${name}")
}
val secondProperty = "Second property: ${name.length}".also(::println)
init {
println("Second initializer block that prints ${name.length}")
}
}
fun main(args: Array) {
var multiInit = MultiInit("Kotlin")
}
//Das folgende wird gedruckt.
//Erste Eigenschaft: Kotlin
//Erster Initialisierungsblock, der Kotlin druckt
//Zweite Eigenschaft: 6
//Zweiter Initialisierungsblock, der 6 druckt
Kotlin Konstruktor
Kotlin Konstruktoren sind spezielle Member-Funktionen, die verwendet werden, um Eigenschaften zu initialisieren. Konstruktoren in Kotlin werden im Vergleich zu Java anders geschrieben und strukturiert. Standardmäßig hat eine Klasse einen leeren Konstruktor wie unten gezeigt:
class Student {
var name: String
val age : Int
init {
name = "Anupam"
age = 24
}
init {
name = "Anupam Chugh"
//age = 26
}
}
fun main(args: Array) {
val student = Student()
println("${student.name} age is ${student.age}")
student.name = "Your"
//student.age = 26 //wird nicht kompilieren. age ist val
println("${student.name} age is ${student.age}")
}
//Folgendes wird auf der Konsole ausgegeben:
//Anupam Chugh Alter ist 24
//Dein Alter ist 24
Primärkonstruktoren
Primärkonstruktoren in Kotlin werden direkt im Klassenheader definiert, wie unten gezeigt.
class User(var name: String, var isAdmin: Boolean) {
init {
name = name + " @ JournalDev.com"
println("Author Name is $name. Is Admin? $isAdmin")
}
}
Die Definition des Primärkonstruktors erfolgt im Klassenheader. Wir haben die Eigenschaftstypen (val/var) im Konstruktor selbst definiert. Hinweis: Sofern nicht als var angegeben, sind Konstruktorargumente standardmäßig val.
class User(name: String, isAdmin: Boolean)
In dem obigen Code können sowohl name als auch isAdmin nicht neu zugewiesen werden. Alternativ können wir die Konstruktorargumente auch den Member-Eigenschaften in der Klasse zuweisen, wie unten gezeigt.
class User(name: String, val isAdmin: Boolean) {
var username = name
val _isAdmin = isAdmin
init {
username= username + " @ JournalDev.com"
println("Author Name is $name. Is Admin? $_isAdmin")
}
}
fun main(args: Array) {
var user = User("Anupam",false)
user.isAdmin = true //won't compile since isAdmin is val
user._isAdmin = true //won't compile. Same reason.
user = User("Pankaj",true)
}
//Folgendes wird im Log-Konsolenfenster ausgegeben.
//Autorname ist Anupam. Ist Administrator? falsch
//Autorname ist Pankaj. Ist Administrator? wahr
Kotlin Konstruktor Standardwerte
Kotlin ermöglicht es uns, Standardwerte im Konstruktor selbst anzugeben, wie unten gezeigt.
class User(name: String, var website: String = "JournalDev") {
init {
println("Author $name writes at $website")
}
init {
website = website + ".com"
println("Author $name writes at $website")
}
}
fun main(args: Array) {
var user = User("Anupam","JournalDev")
user = User("Pankaj","JournalDev")
}
//Folgendes wird auf der Konsole ausgegeben:
//Autor Anupam schreibt auf JournalDev
//Autor Anupam schreibt auf JournalDev.com
//Autor Pankaj schreibt auf JournalDev
//Autor Pankaj schreibt auf JournalDev.com
Sekundäre Konstruktoren
Sekundäre Konstruktoren werden innerhalb des Körper der Klasse geschrieben und mit dem Schlüsselwort constructor versehen. Das folgende Beispiel zeigt dasselbe.
class Student {
var name: String
val age : Int
constructor(name: String, age: Int)
{
this.name = name
this.age = age
}
fun printDetails()
{
println("Name is $name and Age is $age")
}
}
fun main(args: Array) {
var student = Student("Anupam", 24)
student.printDetails()
}
//Folgendes wird in der Konsole ausgegeben:
//Name ist Anupam und Alter ist 24
Die häufigste Verwendung von sekundären Konstruktoren erfolgt in Unterklassen, wenn Sie die Klasse auf unterschiedliche Weisen initialisieren müssen. Wenn die Klasse einen primären Konstruktor enthält, muss der sekundäre Konstruktor in seiner Deklaration darauf Bezug nehmen. Die Deklaration erfolgt unter Verwendung des Schlüsselworts this.
class Student(var name: String, val age: Int) {
var skill: String
init {
skill = "NA"
}
constructor(name: String, age: Int, skill: String) : this(name, age) {
this.skill = skill
}
fun printDetails() {
if (skill.equals("NA"))
println("Name is $name and Age is $age")
else
println("Name is $name and Age is $age Skill is $skill")
}
}
//Folgendes wird im Log-Konsole ausgegeben:
//Name ist Anupam und Alter ist 24
//Name ist Anupam und Alter ist 24 Skill is Kotlin
init-Block wird verwendet, um die Member-Eigenschaft skill zu initialisieren. Der sekundäre Konstruktor delegiert den Primärkonstruktor unter Verwendung von : this.
Benutzerdefinierte Getter und Setter
Bisher haben wir Eigenschaften in einer Klasse mithilfe des Punktoperators auf der Instanz der Klasse zugegriffen und geändert. Lassen Sie uns die Syntax von set und get verwenden, um zu sehen, wie wir den Zugriff anpassen können.
class Name{
var post: String = "default"
set(value) {if(!post.isNotEmpty()) {
throw IllegalArgumentException(" Enter a valid name")
}
field = value
print(value)
}
}
fun main(args: Array<String>) {
var name = Name()
name.post = "Kotlin Classes"
name.post = ""
name.post = "Kotlin Data Classes Our Next Tutorial"
}
Im Protokollfenster wird Folgendes ausgegeben:
Kotlin Classes
Exception in thread "main" java.lang.IllegalArgumentException: Enter a valid name
at Name.setPost(Test.kt:16)
at TestKt.main(Test.kt:78)
Die Variable field im Setter speichert den älteren Wert. Fügen wir einen Getter hinzu.
class Name{
var post: String = "default"
set(value) {if(!post.isNotEmpty()) {
throw IllegalArgumentException(" Enter a valid name")
}
field = value
}
get() {
return field.capitalize()
}
}
fun main(args: Array) {
var name = Name()
name.post = "kotlin classes"
println(name.post)
name.post = "kotlin data Classes our next Tutorial"
println(name.post)
}
//Folgendes wird ausgegeben:
//Kotlin-Klassen
//Kotlin-Datanklassen unser nächstes Tutorial
capitalize() Großbuchstaben am Anfang des Strings. Hinweis: Wenn die Eigenschaft ein val ist, wird die set-Methode nicht kompiliert.
Sichtbarkeitsmodifikator in Kotlin
- Öffentlich: Jede Klasse, Funktion, Eigenschaft, Schnittstelle oder Objekt, das diesen Modifikator hat, ist sichtbar und kann von überall aus zugegriffen werden.
- Privat: Eine mit diesem Modifier definierte Klasse/Funktion kann nur in derselben Datei aufgerufen werden. Ein Mitglied/Eigenschaft in einer Klasse/Funktion mit diesem Modifier kann nur innerhalb dieses Blocks aufgerufen werden.
- Geschützt: Dieser Modifier ist dasselbe wie „private“, außer dass er Sichtbarkeit und Zugriff in Unterklassen ermöglicht.
- Intern: Eine Klasse/Schnittstelle/Funktion mit diesem Modifier ist nur innerhalb des gleichen Moduls zugänglich.
Sichtbarkeitsmodifier sind auch auf Konstruktoren anwendbar. Einem primären Konstruktor einen Modifier zuzuweisen erfordert, dass wir das Schlüsselwort constructor zusammen mit dem Konstruktor im Klassenheader angeben.
class Student private constructor (var name: String, val age: Int) {
var skill: String
init {
skill = "NA"
}
constructor(name: String, age: Int, skill: String) : this(name, age) {
this.skill = skill
}
fun printDetails() {
if (skill.equals("NA"))
println("Name is $name and Age is $age")
else
println("Name is $name and Age is $age Skill is $skill")
}
}
fun main(args: Array) {
var student = Student("Anupam",24,"Kotlin")
student.printDetails()
}
//prints
//Name ist Anupam und Alter ist 24. Fähigkeit ist Kotlin
Private Konstruktoren können außerhalb der Klasse nicht aufgerufen werden. Im obigen Code können wir die Klasse nur in einer anderen Funktion mithilfe des sekundären Konstruktors instanziieren.
Kotlin abstrakte Klasse
Wie in Java wird das Schlüsselwort abstract verwendet, um abstrakte Klassen in Kotlin zu deklarieren. Eine abstrakte Klasse kann nicht instanziiert werden. Sie kann jedoch von Unterklassen geerbt werden. Standardmäßig sind die Mitglieder einer abstrakten Klasse nicht abstrakt, es sei denn, es wird anders angegeben.
abstract class Person(name: String) {
init {
println("Abstract Class. init block. Person name is $name")
}
abstract fun displayAge()
}
class Teacher(name: String): Person(name) {
var age : Int
init {
age = 24
}
override fun displayAge() {
println("Non-abstract class displayAge function overridden. Age is $age")
}
}
fun main(args: Array) {
val person = Teacher("Anupam")
person.displayAge()
}
//Folgendes wird in der Konsole gedruckt.
//Abstrakte Klasse. Initialisierungsblock. Name der Person ist Anupam
//Nicht abstrakte Klasse. Alter ist 24
Hinweis: Abstrakte Klassen sind standardmäßig open. Daher ist es nicht erforderlich, einen open-Modifizierer hinzuzufügen, um die Unterklassenerstellung zu ermöglichen. Das Schlüsselwort override wird verwendet, um eine Methode in der Unterklasse zu überschreiben. In diesem Tutorial haben wir die Grundlagen von Kotlin-Klassen behandelt. Es gibt noch viel mehr, wie Datenklassen, versiegelte Klassen, Vererbung usw. Wir werden sie in den kommenden Tutorials behandeln. Referenzen: Kotlin Docs
Source:
https://www.digitalocean.com/community/tutorials/kotlin-class-constructor