Extensions limitées et extensions de companion object
Limitez la visibilité des extensions et ajoutez des extensions aux companion objects.
Extensions limitées et extensions de companion object est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.
Pourquoi limiter la portée des extensions ?
Par défaut, les extensions sont visibles partout où elles sont importées. Limiter leur portée à une classe, un fichier ou un contexte réduit la pollution de l'espace de noms et facilite leur découverte.
Extensions privées au niveau du fichier
Marquez une fonction d'extension private au niveau du fichier pour la limiter à ce fichier.
private fun String.shout() = uppercase() + "!"
fun main() {
println("hello".shout()) // HELLO!
}Visibilité interne
Utilisez internal pour limiter les extensions au module actuel : c'est idéal pour les éléments internes d'une bibliothèque qui ne sont pas destinés à être utilisés à l'extérieur.
internal fun List<Int>.sumIfPositive(): Int = filter { it > 0 }.sum()
fun main() {
println(listOf(-1, 2, 3, -4).sumIfPositive()) // 5
}Fonctions d'extension membres
Déclarez une extension à l'intérieur d'une classe pour qu'elle ne soit utilisable que lorsqu'une instance de cette classe se trouve dans la portée. Elle possède deux récepteurs : dispatch (la classe) et l'extension (la cible).
class StringHelper(val prefix: String) {
fun String.withPrefix() = prefix + this
fun build(): String = "world".withPrefix() // calls extension via instance
}
fun main() {
println(StringHelper("hello ").build()) // hello world
}Visibilité des extensions membres
Les extensions membres sont inaccessibles depuis l'extérieur de la classe dispatch. Elles sont utiles pour l'encapsulation.
class Repo {
fun List<Int>.allPositive() = all { it > 0 }
fun check(xs: List<Int>) = xs.allPositive()
}
fun main() {
val r = Repo()
println(r.check(listOf(1, 2, 3))) // true
// listOf(1).allPositive() // ERROR — no access
}Extension d'un objet compagnon
Ajoutez une extension à l'objet compagnon d'une classe. Elle ressemble à une méthode statique pour les appelants, mais se trouve à l'extérieur de la classe.
class Greeter {
companion object
}
fun Greeter.Companion.morning() = "Good morning!"
fun main() {
println(Greeter.morning())
}Pourquoi utiliser des extensions d'objets compagnons ?
Elles permettent d'ajouter des méthodes de fabrique ou des utilitaires depuis l'extérieur de la classe d'origine, sans la modifier.
class User(val name: String) {
companion object
}
fun User.Companion.guest() = User("Guest")
fun User.Companion.system() = User("System")
fun main() {
println(User.guest().name)
println(User.system().name)
}Un objet compagnon vide est requis
Une classe doit déclarer un objet compagnon (même vide) pour que des extensions de compagnon puissent s'y rattacher. Sinon, la cible de l'extension n'existe pas.
class Box {
companion object // required, even if empty
}
fun Box.Companion.create(): Box = Box()
fun main() {
println(Box.create())
}Extensions à portée limitée via les imports
Vous pouvez limiter l'utilisation d'une extension en ne l'important que dans certains fichiers. Les fichiers qui ne l'importent pas ne peuvent pas y accéder.
// File A:
// fun String.shout() = uppercase()
// File B imports:
// import com.example.shout
// Only File B can call shout()
fun String.shout() = uppercase() + "!"
fun main() { println("hi".shout()) }Fonction d'extension via une fonction de portée
Utilisez with ou apply pour placer temporairement un objet dans la portée et utiliser ses extensions.
class StringTools {
fun String.greet() = "Hello, $this!"
fun process(name: String) = with(this) {
name.greet()
}
}
fun main() {
println(StringTools().process("Ada"))
}Extensions de propriétés sur l’objet compagnon
Les extensions de l’objet compagnon peuvent également être des propriétés : ajoutez des constantes nommées depuis l’extérieur de la classe.
class HttpStatus {
companion object
}
val HttpStatus.Companion.OK_CODE: Int get() = 200
val HttpStatus.Companion.NOT_FOUND: Int get() = 404
fun main() {
println(HttpStatus.OK_CODE)
println(HttpStatus.NOT_FOUND)
}Bonnes pratiques
Utilisez private pour les utilitaires locaux au fichier, internal pour les API limitées au module, les extensions membres pour l’encapsulation et les extensions de l’objet compagnon pour ajouter depuis l’extérieur des utilitaires de type fabrique.
class StringUtils {
companion object
}
fun StringUtils.Companion.isAlpha(s: String) = s.all { it.isLetter() }
fun main() {
println(StringUtils.isAlpha("hello"))
println(StringUtils.isAlpha("hi5"))
}Vérification rapide
Que faut-il déclarer dans une classe pour pouvoir lui ajouter une extension de l’objet compagnon depuis l’extérieur ?
Récapitulatif
Limitez la portée des extensions avec private, internal ou sous forme d’extensions membres à l’intérieur d’une classe. Ajoutez des extensions de l’objet compagnon (fonctions ou propriétés) depuis l’extérieur en les rattachant à l’objet compagnon déclaré de la classe. Cela réduit la pollution de l’espace de noms tout en gardant le code modulaire.
Questions Fréquemment Posées
La leçon « Extensions limitées et extensions de companion object » est-elle gratuite ?
Oui — le texte complet de « Extensions limitées et extensions de companion object » 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 « Extensions limitées et extensions de companion object » ?
Limitez la visibilité des extensions et ajoutez des extensions aux companion objects. 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 3 sur 4.
Combien de temps prend la leçon « Extensions limitées et extensions de companion object » ?
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
- Fonctions d’extension : syntaxe et règles de résolution
- Propriétés d’extension et extensions calculées
- Extensions limitées et extensions de companion object
- Extensions pratiques : utilitaires pour Context, View et String