In deze tutorial zullen we de concepten van Object Georiënteerd Programmeren in Kotlin bespreken. We zullen de Kotlin Class in detail bekijken. We zullen ook kijken naar Kotlin constructors, access modifiers en abstracte class.
Kotlin Class
Een class is een blauwdruk die functies en eigenschappen groepeert. Classes in Kotlin worden gedefinieerd met het sleutelwoord class gevolgd door de naam van de class. De inhoud staat tussen de accolades.
class FirstClass {
}
Een instantie van de class wordt op de volgende manier geïnstantieerd:
val firstClass = FirstClass()
var new = FirstClass() //here new is the name of the var.
In tegenstelling tot Java is “new” geen sleutelwoord in Kotlin. Classes zijn standaard final in Kotlin. Dus het equivalent van de bovenstaande definities in Java zou er ongeveer zo uitzien:
public final class FirstClass {
}
Daarom zijn classes in Kotlin standaard niet overerfbaar. Om een class niet-final te maken, moeten we het sleutelwoord open toevoegen.
open class Me{
}
De open annotatie maakt het mogelijk voor anderen om van deze class te erven.
Voorbeeld van een Kotlin Class
Laten we een klasse maken met een paar functies en een eigenschap. We zullen zien hoe we toegang krijgen tot de functies en eigenschappen van die klasse. Verder zullen we zien hoe we de lid-eigenschappen kunnen instellen.
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.
}
De functie main behoort tot de klasse Test.kt. Om toegang te krijgen tot leden en functies moeten we de puntoperator gebruiken. Een val eigenschap kan niet opnieuw worden ingesteld met behulp van een puntoperator.
Kotlin init
Het Kotlin init-blok is gedefinieerd zoals hieronder weergegeven.
class User {
init{
print("Class instance is initialised.")
}
var loggedIn: Boolean = false
val cantChangeValue = "Hi"
fun logOn() {
loggedIn = true
}
fun logOff() {
loggedIn = false
}
}
De code binnen het init-blok wordt als eerste uitgevoerd wanneer de klasse wordt geïnstantieerd. Het init-blok wordt elke keer uitgevoerd wanneer de klasse wordt geïnstantieerd, met elk type constructor zoals we later zullen zien. Er kunnen meerdere initialisatieblokken in een klasse worden geschreven. Ze worden sequentieel uitgevoerd zoals hieronder weergegeven.
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")
}
//Het volgende wordt afgedrukt in de logconsole.
//Eerste initialisatieblok dat Kotlin afdrukt
//Tweede initialisatieblok dat 6 afdrukt
Kotlin-klassen staan toe dat eigenschappen worden afgedrukt in de declaratie zelf door de also-functie te gebruiken zoals hieronder weergegeven.
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")
}
//Het volgende wordt afgedrukt.
//Eerste eigenschap: Kotlin
//Eerste initialisatieblok dat Kotlin afdrukt
//Tweede eigenschap: 6
//Tweede initialisatieblok dat 6 afdrukt
Kotlin Constructor
Kotlin Constructors zijn speciale lidfuncties die worden gebruikt om eigenschappen te initialiseren. Constructors in Kotlin zijn anders geschreven en gestructureerd vergeleken met Java. Standaard heeft een klasse een lege constructor zoals hieronder getoond:
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 //compileert niet. age is val
println("${student.name} age is ${student.age}")
}
//Het volgende wordt afgedrukt op de console:
//Anupam Chugh leeftijd is 24
//Jouw leeftijd is 24
Primaire Constructors
Primaire Constructors in Kotlin worden gedefinieerd in de klasseheader zelf zoals hieronder getoond.
class User(var name: String, var isAdmin: Boolean) {
init {
name = name + " @ JournalDev.com"
println("Author Name is $name. Is Admin? $isAdmin")
}
}
De definitie van de primaire constructor staat binnen de klasseheader. We hebben de eigenschaptypes (val/var) gedefinieerd in de constructor zelf. Opmerking: Tenzij anders vermeld als een var, zijn constructorargumenten standaard val.
class User(name: String, isAdmin: Boolean)
In de bovenstaande code kunnen zowel de naam als isAdmin niet opnieuw worden toegewezen. Alternatief kunnen we ook de constructorargumenten toewijzen aan de ledeneigenschappen in de klasse zoals hieronder getoond.
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)
}
//Het volgende wordt afgedrukt in de logconsole.
//Auteursnaam is Anupam. Is beheerder? false
//Auteursnaam is Pankaj. Is beheerder? true
Standaardwaarden van Kotlin-constructors
Kotlin staat ons toe om standaardwaarden in de constructor zelf te specificeren, zoals hieronder getoond.
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")
}
//Het volgende wordt afgedrukt op de console:
//Auteur Anupam schrijft op JournalDev
//Auteur Anupam schrijft op JournalDev.com
//Auteur Pankaj schrijft op JournalDev
//Auteur Pankaj schrijft op JournalDev.com
Secundaire constructors
Secundaire constructors worden binnen de body van de klasse geschreven door te prefixen met het trefwoord constructor. Het volgende voorbeeld demonstreert hetzelfde.
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()
}
//Het volgende wordt afgedrukt in de console.
//Naam is Anupam en Leeftijd is 24
De meest voorkomende toepassing van secundaire constructors komt voor in subklassen wanneer je de klasse op verschillende manieren moet initialiseren. Als de klasse een primaire constructor bevat, moet de secundaire constructor ernaar verwijzen in zijn declaratie. De declaratie gebeurt met behulp van het trefwoord 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")
}
}
//Het volgende wordt afgedrukt in de logconsole:
//Naam is Anupam en Leeftijd is 24
//Naam is Anupam en Leeftijd is 24 Skill is Kotlin
init-blok wordt gebruikt om het lidmaatschapsattribuut skill te initialiseren. De secundaire constructor delegeert naar de primaire constructor met behulp van : this.
Aangepaste Getters en Setters
Tot nu toe hebben we eigenschappen in een klasse benaderd en aangepast met behulp van de puntoperator op de instantie van de klasse. Laten we set– en get-syntax gebruiken om te zien hoe we de toegang kunnen aanpassen.
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"
}
Het volgende wordt afgedrukt in de logconsole:
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)
De variabele field in de setter slaat de oudere waarde op. Laten we een getter toevoegen.
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)
}
//Het volgende wordt afgedrukt:
//Kotlin-klassen
//Kotlin-gegevensklassen, onze volgende tutorial
capitalize() maakt de eerste letter van de string hoofdletter. Let op: als het attribuut een val is, zal de set-methode niet compileren.
Zichtbaarheidsmodifier in Kotlin
- Openbaar: Elke klasse, functie, eigenschap, interface of object met deze modifier is zichtbaar en kan overal worden benaderd.
- Privé: Een klasse/functie gedefinieerd met deze modifier kan alleen worden benaderd binnen hetzelfde bestand. Een lid/eigenschap in een klasse/functie met deze modifier kan alleen worden benaderd binnen dat blok.
- Beschermd: Deze modifier is hetzelfde als privé, behalve dat het zichtbaarheid en toegang toestaat binnen subklassen.
- Intern: Een klasse/interface/functie met deze modifier is alleen toegankelijk binnen dezelfde module.
Zichtbaarheidsmodifiers zijn ook van toepassing op constructeurs. Het toewijzen van een modifier aan een primaire constructor vereist dat we het trefwoord constructor specificeren naast de constructor in de koptekst van de klasse.
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
//Naam is Anupam en Leeftijd is 24 Vaardigheid is Kotlin
Privé-constructeurs kunnen niet worden aangeroepen buiten de klasse. In de bovenstaande code kunnen we de klasse instantiëren in een andere functie alleen met gebruik van de secundaire constructor.
Kotlin Abstracte Klasse
Net als in Java wordt het trefwoord abstract gebruikt om abstracte klassen in Kotlin te declareren. Een abstracte klasse kan niet worden geïnstantieerd. Het kan echter worden overgeërfd door subklassen. Standaard zijn de leden van een abstracte klasse niet-abstract, tenzij anders vermeld.
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()
}
//Het volgende wordt afgedrukt in de console.
//Abstracte Klasse. init-blok. Persoon naam is Anupam
//Niet-abstracte klasse. Leeftijd is 24
Let op: Abstracte klassen zijn standaard open. Dus het toevoegen van een open modifier om subklassen toe te staan, is niet vereist. Het override-zoekwoord wordt gebruikt om een methode in de subklasse te overschrijven. We hebben de basisprincipes van Kotlin-klassen behandeld in deze tutorial. Er is nog veel meer, zoals Data Classes, Sealed Classes, Erfenis, enz. We zullen ze behandelen in de komende tutorials. Referenties: Kotlin Docs
Source:
https://www.digitalocean.com/community/tutorials/kotlin-class-constructor