Dans ce tutoriel, nous discuterons des concepts de la Programmation Orientée Objet en Kotlin. Nous examinerons en détail la classe Kotlin. Nous aborderons également les constructeurs Kotlin, les modificateurs d’accès et les classes abstraites.
Classe Kotlin
Une classe est un modèle défini regroupant des fonctions et des propriétés. Les classes en Kotlin sont définies à l’aide du mot-clé class suivi du nom de la classe. Le corps va à l’intérieur des accolades.
class FirstClass {
}
Une instance de la classe est instanciée de la manière suivante :
val firstClass = FirstClass()
var new = FirstClass() //here new is the name of the var.
Contrairement à Java, new n’est pas un mot-clé en Kotlin. Les classes sont par défaut final en Kotlin. Ainsi, l’équivalent des définitions ci-dessus en Java ressemblerait à ceci :
public final class FirstClass {
}
Par conséquent, par défaut, les classes en Kotlin ne sont pas héritables. Pour rendre une classe non finale, nous devons ajouter le mot-clé open.
open class Me{
}
L’annotation open permet à d’autres de hériter de cette classe.
Exemple de classe Kotlin
Créons une classe avec quelques fonctions et une propriété. Nous verrons comment accéder aux fonctions et propriétés de cette classe. De plus, nous verrons comment définir les propriétés des membres.
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.
}
La fonction main appartient à la classe Test.kt. Pour accéder aux membres et aux fonctions, nous devons utiliser l’opérateur point. Une propriété val ne peut pas être réinitialisée en utilisant l’opérateur point.
Init de Kotlin
Le bloc init de Kotlin est défini comme indiqué ci-dessous.
class User {
init{
print("Class instance is initialised.")
}
var loggedIn: Boolean = false
val cantChangeValue = "Hi"
fun logOn() {
loggedIn = true
}
fun logOff() {
loggedIn = false
}
}
Le code à l’intérieur du bloc init est le premier à être exécuté lorsque la classe est instanciée. Le bloc init est exécuté à chaque instantiation de la classe, avec n’importe quel type de constructeur comme nous le verrons ensuite. Plusieurs blocs d’initialisation peuvent être écrits dans une classe. Ils seront exécutés séquentiellement comme indiqué ci-dessous.
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")
}
//Le message suivant est affiché dans la console des journaux.
//Premier bloc d'initialisation qui imprime Kotlin
//Deuxième bloc d'initialisation qui imprime 6
Les classes Kotlin permettent d’afficher les propriétés dans la déclaration elle-même en utilisant la fonction also comme indiqué ci-dessous.
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")
}
//Le message suivant est imprimé.
//Première propriété: Kotlin
//Premier bloc d'initialisation qui imprime Kotlin
//Deuxième propriété: 6
//Deuxième bloc d'initialisation qui imprime 6
Constructeur Kotlin
Les constructeurs Kotlin sont des fonctions membres spéciales utilisées pour initialiser les propriétés. Les constructeurs en Kotlin sont écrits et structurés différemment par rapport à Java. Par défaut, une classe a un constructeur vide comme indiqué ci-dessous:
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 //ne compilera pas. age est val
println("${student.name} age is ${student.age}")
}
//Le message suivant est affiché sur la console:
//Anupam Chugh age is 24
//Votre âge est de 24 ans
Constructeurs principaux
Les constructeurs principaux en Kotlin sont définis dans l’en-tête de la classe comme indiqué ci-dessous.
class User(var name: String, var isAdmin: Boolean) {
init {
name = name + " @ JournalDev.com"
println("Author Name is $name. Is Admin? $isAdmin")
}
}
La définition des constructeurs principaux se trouve dans l’en-tête de la classe. Nous avons défini les types de propriétés (val/var) dans le constructeur lui-même. Remarque : À moins d’être spécifié comme var, par défaut, les arguments du constructeur sont val.
class User(name: String, isAdmin: Boolean)
Dans le code ci-dessus, ni le nom ni isAdmin ne peuvent être réassignés. Alternativement, nous pouvons également attribuer les arguments du constructeur aux propriétés membres de la classe comme indiqué ci-dessous.
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)
}
//Le message suivant est imprimé dans la console des journaux.
//Le nom de l'auteur est Anupam. Est-ce un administrateur? false
//Le nom de l'auteur est Pankaj. Est-ce un administrateur? true
Valeurs par défaut du constructeur Kotlin
Kotlin nous permet de spécifier des valeurs par défaut dans le constructeur lui-même comme illustré ci-dessous.
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")
}
//Ce qui suit est imprimé sur la console:
//L'auteur Anupam écrit sur JournalDev
//L'auteur Anupam écrit sur JournalDev.com
//L'auteur Pankaj écrit sur JournalDev
//L'auteur Pankaj écrit sur JournalDev.com
Constructeurs secondaires
Les constructeurs secondaires sont écrits à l’intérieur du corps de la classe en les préfixant avec le mot-clé constructor. L’exemple suivant démontre la même chose.
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()
}
//Ce qui suit est imprimé dans la console.
//Le nom est Anupam et l'âge est 24
L’utilisation la plus courante des constructeurs secondaires intervient dans les sous-classes lorsque vous devez initialiser la classe de différentes manières. Si la classe contient un constructeur primaire, le constructeur secondaire doit s’y référer dans sa déclaration. La déclaration se fait en utilisant le mot-clé 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")
}
}
//Ce qui suit est imprimé dans la console de log:
//Le nom est Anupam et l'âge est 24
//Le nom est Anupam et l'âge est 24 Skill is Kotlin
Le bloc init est utilisé pour initialiser la propriété membre skill. Le constructeur secondaire délègue au constructeur primaire en utilisant : this.
Getters et Setters Personnalisés
Jusqu’à présent, nous avons accédé et modifié les propriétés dans une classe en utilisant l’opérateur point sur l’instance de la classe. Utilisons la syntaxe set et get pour voir comment nous pouvons personnaliser l’accès.
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"
}
Ce qui suit est imprimé dans la console de journalisation :
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)
La variable field dans le setter enregistre l’ancienne valeur. Ajoutons un getter.
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)
}
//Ce qui suit est imprimé :
//Classes Kotlin
//Les classes de données Kotlin, notre prochain tutoriel
capitalize() met en majuscule la première lettre de la chaîne. Remarque : si la propriété est une val, la méthode set ne compilera pas.
Modificateur de Visibilité Kotlin
- Public : Toute classe, fonction, propriété, interface ou objet ayant ce modificateur est visible et peut être accédé de n’importe où.
- Privé: Une classe/fonction définie avec ce modificateur ne peut être accessible que dans le même fichier. Un membre/propriété dans une classe/fonction avec ce modificateur ne peut être accessible que dans ce bloc.
- Protégé : Ce modificateur est similaire à privé, sauf qu’il permet la visibilité et l’accès dans les sous-classes.
- Interne: Une classe/interface/fonction avec ce modificateur est accessible uniquement dans le même module.
Les modificateurs de visibilité sont également applicables aux constructeurs. Assigner un modificateur à un constructeur primaire nécessite de spécifier le mot-clé constructor aux côtés du constructeur dans l’en-tête de la classe.
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
//Le nom est Anupam et l'âge est de 24 ans. La compétence est Kotlin
Les constructeurs privés ne peuvent pas être appelés en dehors de la classe. Dans le code ci-dessus, nous pouvons instancier la classe dans une fonction différente uniquement en utilisant le constructeur secondaire.
Classe Abstraite Kotlin
Comme en Java, le mot-clé abstract est utilisé pour déclarer des classes abstraites en Kotlin. Une classe abstraite ne peut pas être instanciée. Cependant, elle peut être héritée par des sous-classes. Par défaut, les membres d’une classe abstraite sont non abstraits sauf indication contraire.
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()
}
//Ce qui suit est imprimé dans la console.
//Classe abstraite. Bloc d'initialisation. Le nom de la personne est Anupam
//Classe non-abstraite. L'âge est de 24 ans.
Remarque : Les classes abstraites sont par défaut open. Ainsi, l’ajout d’un modificateur open pour autoriser l’héritage n’est pas nécessaire. Le mot-clé override est utilisé pour substituer une méthode dans la sous-classe. Nous avons abordé les bases des classes Kotlin dans ce tutoriel. Il y a encore beaucoup à explorer, comme les classes de données, les classes scellées, l’héritage, etc. Nous les aborderons dans les tutoriels à venir. Références : Docs Kotlin
Source:
https://www.digitalocean.com/community/tutorials/kotlin-class-constructor