Constructeur primaire et paramètres de propriétés
Déclarez des classes avec des constructeurs primaires et des déclarations de propriétés intégrées.
Constructeur primaire et paramètres de propriétés est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.
Le constructeur primaire
Une classe Kotlin déclare son constructeur primaire juste après le nom de la classe, entre parenthèses. Il n’y a pas de corps de méthode, uniquement une liste de paramètres.
La classe la plus simple
Sans modificateurs, le constructeur primaire est invisible après le nom de la classe.
class Greeter(val name: String) {
fun greet() = "Hello, $name!"
}
fun main() {
println(Greeter("Ada").greet())
}Paramètres de propriété
Préfixez un paramètre de constructeur avec val ou var pour en faire une propriété de classe en une seule étape.
class Person(val name: String, var age: Int)
fun main() {
val p = Person("Bob", 30)
println("${p.name} is ${p.age}")
p.age = 31
println("Now ${p.age}")
}Paramètres sans val/var
Les paramètres de constructeur sans val/var sont locaux au constructeur : ils peuvent être utilisés dans les blocs init ou les initialiseurs de propriétés, mais ne sont pas accessibles ultérieurement.
class Logger(prefix: String) {
val msg = "$prefix: ready"
}
fun main() {
val l = Logger("[INFO]")
println(l.msg)
// l.prefix // ERROR — not a property
}Valeurs de paramètres par défaut
Fournissez des valeurs par défaut pour les paramètres du constructeur afin d’éviter le code répétitif des surcharges.
class User(
val name: String,
val age: Int = 0,
val email: String = ""
)
fun main() {
println(User("Ana").age) // 0
println(User("Ben", 25).email) // ""
println(User("Cal", 30, "c@x.io").email)
}Arguments nommés
Ignorez l’ordre positionnel et nommez les paramètres lors de l’appel — c’est particulièrement utile avec les valeurs par défaut.
class HttpClient(
val baseUrl: String,
val timeoutMs: Int = 5000,
val retries: Int = 3
)
fun main() {
val c = HttpClient(
baseUrl = "https://api.example.com",
retries = 5
)
println("retries=${c.retries} timeout=${c.timeoutMs}")
}Visibilité du constructeur
Utilisez private constructor pour empêcher l’instanciation externe — une pratique courante avec les méthodes fabrique.
class Singleton private constructor() {
companion object {
val instance = Singleton()
}
}
fun main() {
val s = Singleton.instance
println(s)
}Constructeurs secondaires
Ajoutez des constructeurs supplémentaires avec le mot-clé constructor. Ils doivent déléguer au constructeur primaire avec this(...).
class Point(val x: Int, val y: Int) {
constructor(value: Int) : this(value, value)
}
fun main() {
println("${Point(3).x}, ${Point(3).y}") // 3, 3
}Constructeur avec visibilité
Vous pouvez définir une visibilité différente pour chaque constructeur — c’est utile dans les bibliothèques.
class Lib internal constructor(val key: String) {
companion object {
fun create(key: String) = Lib(key)
}
}
fun main() {
println(Lib.create("abc").key)
}Récapitulatif des blocs init
Le code qui doit s’exécuter pendant la construction se place dans un bloc init { }. Plusieurs blocs init s’exécutent dans l’ordre du code source.
class Validator(val value: String) {
init { require(value.isNotBlank()) { "value cannot be blank" } }
}
fun main() {
println(Validator("ok").value)
// Validator("") // throws IllegalArgumentException
}Combiner propriétés et logique
Les déclarations de propriétés, les constructeurs secondaires et les blocs init se combinent pour former une chaîne d’initialisation flexible.
class Account(
val owner: String,
initialBalance: Double = 0.0
) {
var balance: Double = initialBalance
private set
init {
require(initialBalance >= 0) { "balance must be non-negative" }
}
fun deposit(amount: Double) { balance += amount }
}
fun main() {
val a = Account("Alice", 100.0)
a.deposit(50.0)
println("${a.owner}: ${a.balance}") // Alice: 150.0
}Vérification rapide
Que fait le mot-clé val lorsqu’il est utilisé dans un paramètre du constructeur primaire ?
Récapitulatif
Le constructeur primaire se trouve dans l’en-tête de la classe. Utilisez val/var pour les paramètres de propriété ; les paramètres seuls restent locaux au constructeur. Ajoutez des valeurs par défaut pour réduire les surcharges et exécutez la logique de préparation dans les blocs init. Les constructeurs secondaires délèguent via this(...).
Questions Fréquemment Posées
La leçon « Constructeur primaire et paramètres de propriétés » est-elle gratuite ?
Oui — le texte complet de « Constructeur primaire et paramètres de propriétés » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Constructeur primaire et paramètres de propriétés » ?
Déclarez des classes avec des constructeurs primaires et des déclarations de propriétés intégrées. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Kotlin Academy ?
Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Constructeur primaire et paramètres de propriétés » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?
Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Constructeur primaire et paramètres de propriétés
- Blocs init et ordre d’initialisation
- Accesseurs get et set personnalisés avec field
- lateinit et initialisation différée