Classe Kotlin à envoyer aux développeurs Java

Pour les développeurs Java, j'écrirai sur les classes Kotlin.

Définition de classe

Écrivez le nom de la classe après le mot-clé class. Définissons la classe Dog.

class Dog {
}

L'héritage de classe et l'implémentation de l'interface sont écrits après les deux points. Héritons de la classe Dog et de la classe Animal.

class Dog: Animal() {
}

De plus, implémentons l'interface Walkable.

class Dog: Animal(), Walkable {
}

Propriété

Les classes Kotlin peuvent avoir des propriétés. Ceci est ** une combinaison de champs Java, getters et setters **. Déclarons une propriété de type String appelée name dans la classe Dog. Utilisez le mot-clé var.

class Dog {
    var name: String = "pochi"
}


val dog = Dog()
val aName = dog.name //Agit comme un getter
dog.name = "taro" //Agit comme un setter

Si vous voulez le rendre en lecture seule, utilisez le mot-clé val.

class Dog {
    val name: String = "pochi"
}

val dog = Dog()
val aName = dog.name //Agit comme un getter
dog.name = "taro" //Erreur de compilation!

Le mot-clé val ne peut pas être réaffecté, donc sa valeur ne peut pas être modifiée à partir de la classe. Utilisez le mot clé private set pour le rendre modifiable dans la classe.

class Dog {
    var name: String = "pochi"
        private set
    
    fun updateName(newName: String) {
        this.name = newName
    }
}

val dog = Dog()
dog.updateName("taro")

À ce stade, ceux qui pensent: "Non, c'est la même chose que de rendre un champ public en Java, n'est-ce pas?" Les propriétés de Kotlin sont clairement séparées en getters, setters et champs. Pour plus d'informations [ici](https://qiita.com/watanave/items/1386d450f11ddf7d6c09#property et champ de sauvegarde)

Constructeur principal

Écrivez le constructeur de Kotlin dans une position légèrement inhabituelle.

class Dog constructor(/*Voici le constructeur*/) {
}

Le mot-clé constructor peut être omis. Il ne peut pas être omis lors de l'ajout d'une annotation. Le constructeur écrit à cette position est appelé ** constructeur principal **. Même si vous dites un constructeur, vous pouvez décrire des propriétés et une liste d'arguments de constructeur.

Définir les propriétés dans le constructeur

Si vous ajoutez le mot-clé var ou val à l'argument constructeur, il devient une propriété telle quelle.

class Dog(var name: String) {
}

↑ est synonyme de ↓.

class Dog(name: String) {
    var name: String = name
}

Initialiseur

Le constructeur principal est désormais capable de déclarer des arguments et des propriétés de constructeur. D'autres processus à exécuter lorsque la classe est initialisée peuvent être décrits dans l'initialiseur.

class Point(val x: Int, val y: Int)
class Size(val width: Int, val height: Int)

class Regtangle(val origin: Point, val size: Size) {
    val area: Int

    init {
        this.area = this.size.width * this.size.height
    }
}

val rectangle = Regtangle(30, 10, 10, 20)
println(rectangle.area)

La classe Regtangle reçoit l'origine et la taille de l'entrepreneur et calcule la zone avec l'initialiseur.

Constructeur secondaire

Puisqu'il existe un constructeur principal, il existe également un constructeur secondaire. Vous pouvez définir plusieurs constructeurs secondaires. Le constructeur secondaire doit appeler le constructeur principal après «:».

class Point(val x: Int, val y: Int)
class Size(val width: Int, val height: Int)

class Regtangle(val origin: Point, val size: Size) {

    constructor(x: Int, y: Int, width: Int, height: Int): this(Point(x, y), Size(width, height))

}

Ajout d'un constructeur à la classe Regtangle qui reçoit l'origine et la taille en tant que paramètres séparés.

Comparez Java et Kotlin

Définissez la classe Dog en Java. Il existe des champs nommés nom et âge, qui définissent respectivement les getters et les setters.

public class Dog {
    
    private String name;
    private int age;
    
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
}

Que diriez-vous d'écrire ceci à Kotlin?

class Dog(var name: String, var age: Int)

C'est tout ce qu'il faut.