companion object : membres semblables aux membres statiques
Ajoutez des companion objects aux classes pour simuler des méthodes et des constantes statiques.
companion object : membres semblables aux membres statiques est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.
Pas de membres statiques, mais un objet compagnon
Kotlin ne possède pas de mot-clé static. À la place, un companion object déclaré à l’intérieur d’une classe fournit des membres de niveau classe, similaires aux membres statiques.
Déclarer un objet compagnon
Placez un companion object dans une classe. Ses membres peuvent être appelés avec ClassName.member.
class MathUtils {
companion object {
fun square(x: Int) = x * x
}
}
fun main() {
println(MathUtils.square(5)) // 25
}Constantes dans un objet compagnon
Les constantes se trouvent généralement dans l’objet compagnon, souvent avec const val pour les littéraux connus à la compilation.
class HttpClient {
companion object {
const val DEFAULT_TIMEOUT = 5000
const val USER_AGENT = "MyApp/1.0"
}
}
fun main() {
println(HttpClient.DEFAULT_TIMEOUT)
println(HttpClient.USER_AGENT)
}Objet compagnon nommé
Vous pouvez nommer l’objet compagnon. ClassName.member et ClassName.CompanionName.member fonctionnent tous les deux.
class Database {
companion object Factory {
fun create() = Database()
}
}
fun main() {
val db1 = Database.create() // works
val db2 = Database.Factory.create() // also works
println("$db1 / $db2")
}Patron de méthode de fabrique
Utilisez l’objet compagnon pour créer des instances avec une validation ou une logique de construction alternative.
class User private constructor(val name: String, val email: String) {
companion object {
fun create(name: String, email: String): User {
require(email.contains("@")) { "invalid email" }
return User(name, email)
}
}
}
fun main() {
val u = User.create("Ada", "ada@example.com")
println("${u.name} <${u.email}>")
}Implémenter des interfaces
L’objet compagnon lui-même peut implémenter des interfaces — ce qui est utile pour le combiner avec des classes nécessitant un contrat de type statique.
interface Loadable<T> { fun load(): T }
class Config(val data: String) {
companion object : Loadable<Config> {
override fun load() = Config("loaded data")
}
}
fun main() {
println(Config.load().data)
}@JvmStatic pour l’interopérabilité avec Java
Annotez les membres de l’objet compagnon avec @JvmStatic afin de les exposer comme de véritables méthodes statiques aux appelants Java.
class Util {
companion object {
@JvmStatic
fun greet(name: String) = "Hello, $name!"
}
}
fun main() {
println(Util.greet("Kotlin"))
// In Java: Util.greet("Java")
}Accéder directement à l’objet compagnon
ClassName.Companion désigne directement l’objet compagnon. Utilisez-le lorsque vous le transmettez comme argument.
class Counter {
companion object {
fun greet() = "hi from companion"
}
}
fun main() {
val ref = Counter.Companion
println(ref.greet())
}Objet compagnon ou niveau supérieur
Pour les fonctions utilitaires qui n’appartiennent pas à une classe, préférez les fonctions de niveau supérieur à une classe contenant uniquement un objet compagnon.
// File-level — usually cleaner:
fun greet(name: String) = "Hi, $name!"
// Versus:
class Greeter { companion object { fun greet(n: String) = "Hi, $n!" } }
fun main() {
println(greet("Ada"))
println(Greeter.greet("Ada"))
}Un seul objet compagnon par classe
Une classe peut contenir au maximum un objet compagnon. Des objets internes ordinaires peuvent contenir un état partagé supplémentaire si nécessaire.
class Service {
companion object {
val version = "1.0"
}
object InternalHelper { fun log() = println("internal") }
}
fun main() {
println(Service.version)
Service.InternalHelper.log()
}Fonctions d’extension de l’objet compagnon
Vous pouvez étendre l’objet compagnon depuis l’extérieur de la classe et lui ajouter des fonctions utilitaires pseudo-statiques.
class Lib {
companion object
}
fun Lib.Companion.helper() = "added later"
fun main() {
println(Lib.helper())
}Vérification rapide
Quel est l’équivalent Kotlin des membres static de Java ?
Récapitulatif
Kotlin ne possède pas de static. Utilisez un objet compagnon pour les membres au niveau de la classe — constantes, fabriques et implémentations d’interfaces. Annotez-les avec @JvmStatic pour l’interopérabilité avec Java, ou étendez-les avec des fonctions d’extension pour créer des fonctions utilitaires pseudo-statiques.
Questions Fréquemment Posées
La leçon « companion object : membres semblables aux membres statiques » est-elle gratuite ?
Oui — le texte complet de « companion object : membres semblables aux membres statiques » 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 « companion object : membres semblables aux membres statiques » ?
Ajoutez des companion objects aux classes pour simuler des méthodes et des constantes statiques. 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 2 sur 4.
Combien de temps prend la leçon « companion object : membres semblables aux membres statiques » ?
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
- Déclaration object : singletons Kotlin
- companion object : membres semblables aux membres statiques
- Objets anonymes et expressions object
- Méthodes fabrique avec companion object