Types de base courants (`Int`, `String`, `Boolean`, `Double`)

Introduction aux types : classer nos données

En programmation, nous manipulons constamment des données : des âges, des noms, des prix, des états (activé/désactivé), etc. Pour que l'ordinateur et le compilateur puissent comprendre et traiter correctement ces données, nous devons leur indiquer leur *nature*. C'est le rôle des types de données. Un type définit le genre de valeurs qu'une variable peut contenir et les opérations qui peuvent être effectuées sur ces valeurs.

Kotlin, comme la plupart des langages modernes, est un langage à typage statique. Cela signifie que le type de chaque variable est connu au moment de la compilation, ce qui permet de détecter de nombreuses erreurs avant même l'exécution du programme (par exemple, essayer d'additionner un nombre et un nom).

Bien que Kotlin dispose d'un système de types riche, nous allons nous concentrer ici sur les types de base les plus fondamentaux et les plus couramment utilisés, qui forment le socle de la manipulation de données : `Int` (entiers), `Double` (nombres décimaux), `Boolean` (valeurs logiques) et `String` (chaînes de caractères).

`Int` : représenter les nombres entiers

Le type `Int` est utilisé pour représenter des nombres entiers, c'est-à-dire des nombres sans partie décimale, positifs, négatifs ou nuls. C'est le type par défaut pour les nombres entiers en Kotlin.

Techniquement, un `Int` en Kotlin correspond à un entier signé de 32 bits, ce qui signifie qu'il peut stocker des valeurs allant approximativement de -2 milliards à +2 milliards. Pour des nombres entiers plus grands, Kotlin propose le type `Long` (64 bits).

fun main() {
    val age: Int = 30       // Déclaration explicite du type
    val year = 2024         // Inférence de type: Kotlin devine que c'est un Int
    val score = -150        // Entier négatif
    val numberOfItems = 0   // Zéro

    println("Age: $age")
    println("Année: $year")

    // Opérations arithmétiques de base
    val nextYear = year + 1
    val pointsLost = score * 2
    val itemsPerBox = 100 / 5

    println("Année prochaine: $nextYear") // Affiche 2025
    println("Points perdus x2: $pointsLost") // Affiche -300
    println("Objets par boîte: $itemsPerBox") // Affiche 20

    // Attention: la division entière tronque le résultat
    val divisionIncomplete = 10 / 3
    println("10 / 3 (Int) = $divisionIncomplete") // Affiche 3, pas 3.333...
}

Vous utiliserez `Int` pour toutes sortes de comptages, d'indices, d'identifiants numériques, etc.

`Double` : manipuler les nombres à virgule flottante

Lorsque vous avez besoin de représenter des nombres avec une partie décimale (nombres réels), vous utiliserez principalement le type `Double`. C'est le type par défaut pour les nombres à virgule flottante en Kotlin.

Un `Double` utilise 64 bits pour stocker la valeur, offrant une grande précision (environ 15-16 chiffres décimaux). Pour des cas où une précision moindre suffit (et pour économiser de la mémoire, bien que ce soit moins souvent une préoccupation majeure aujourd'hui), Kotlin propose aussi le type `Float` (32 bits, environ 6-7 chiffres décimaux). Pour déclarer explicitement un `Float`, vous devez ajouter un suffixe `f` ou `F` à la valeur.

fun main() {
    val pi: Double = 3.1415926535 // Déclaration explicite
    val price = 99.99              // Inférence de type: Kotlin devine Double (présence du '.')
    val temperature = -10.5        // Nombre négatif

    println("Prix: $price")

    // Pour déclarer un Float, utiliser 'f' ou 'F'
    val gravity: Float = 9.81f
    val anotherPi = 3.14F // C'est un Float

    println("Gravité (Float): $gravity")

    // Opérations arithmétiques
    val circleArea = pi * 5.0 * 5.0 // 5.0 est un Double
    val discountedPrice = price * 0.90 // 10% de réduction

    println("Aire du cercle: $circleArea")
    println("Prix réduit: $discountedPrice")

    // Les opérations entre Int et Double résultent en un Double
    val totalCost = price + 5 // 5 est un Int, mais le résultat est Double
    println("Coût total: $totalCost") // Affiche 104.99
}

`Double` est utilisé pour les calculs scientifiques, financiers (avec précautions sur les arrondis), les coordonnées géographiques, etc.

`Boolean` : gérer les valeurs logiques (vrai/faux)

Le type `Boolean` est l'un des plus simples mais aussi des plus fondamentaux. Une variable de type `Boolean` ne peut avoir que deux valeurs possibles : `true` (vrai) ou `false` (faux).

Les booléens sont le coeur de la logique conditionnelle : ils permettent à votre programme de prendre des décisions en fonction de certaines conditions.

fun main() {
    val isActive: Boolean = true // Déclaration explicite
    val isLoggedIn = false     // Inférence de type
    val hasErrors = true

    println("Est actif: $isActive")

    // Utilisation dans des conditions (sera vu plus en détail)
    if (isLoggedIn) {
        println("Utilisateur connecté.")
    } else {
        println("Utilisateur déconnecté.")
    }

    // Opérateurs logiques
    val canProceed = isActive && !hasErrors // && (ET logique), ! (NON logique)
    println("Peut continuer: $canProceed") // Affiche false (true ET NON(true) -> false)

    val needsAttention = isLoggedIn || hasErrors // || (OU logique)
    println("Nécessite attention: $needsAttention") // Affiche true (false OU true -> true)
}

Vous utiliserez `Boolean` partout où vous devez représenter un état binaire, le résultat d'une comparaison, ou contrôler le flux d'exécution de votre programme.

`String` : travailler avec du texte

Le type `String` est utilisé pour représenter des séquences de caractères, c'est-à-dire du texte. Les chaînes de caractères en Kotlin sont définies en entourant le texte de guillemets doubles `""`.

Les `String` en Kotlin (et Java) sont immuables. Cela signifie qu'une fois qu'une chaîne de caractères est créée, son contenu ne peut plus être modifié directement. Toute opération qui semble modifier une chaîne (comme la concaténation) crée en réalité une nouvelle instance de `String`.

fun main() {
    val greeting: String = "Bonjour" // Déclaration explicite
    val name = "CertiQuizz"       // Inférence de type
    val emptyString = ""           // Chaîne vide

    // Concaténation (crée une nouvelle String)
    val message = greeting + ", " + name + "!"
    println(message) // Affiche "Bonjour, CertiQuizz!"

    // Accéder à la longueur de la chaîne
    val nameLength = name.length
    println("Longueur du nom: $nameLength") // Affiche 10

    // Accéder à un caractère par son index (commence à 0)
    val firstChar = name[0]
    val secondChar = name[1]
    println("Premier caractère: $firstChar") // Affiche C
    println("Deuxième caractère: $secondChar") // Affiche e

    // Les Strings sont immuables
    // name[0] = 'c' // Erreur de compilation: on ne peut pas modifier un caractère

    // Comparaison de chaînes
    val anotherName = "CertiQuizz"
    println("Les noms sont égaux: ${name == anotherName}") // Affiche true
}

Les `String` sont omniprésentes pour afficher des messages, stocker des entrées utilisateur, manipuler des données textuelles, construire des requêtes, etc. Nous verrons bientôt les `String templates` qui facilitent grandement leur manipulation.

Kotlin et les types : une approche unifiée

Une caractéristique importante de Kotlin est que tous les types, y compris ces types de base (`Int`, `Double`, `Boolean`, `String`, etc.), sont des objets. Contrairement à Java où il existe une distinction entre types primitifs (comme `int`, `double`) et leurs wrappers objets (`Integer`, `Double`), Kotlin unifie ce concept. Même un `Int` est un objet sur lequel vous pouvez appeler des méthodes.

fun main() {
    val number = 42
    val textNumber = number.toString() // Appelle la méthode toString() sur un Int
    println("Nombre en texte: $textNumber") // Affiche "42"

    val price = 99.99
    val integerPart = price.toInt() // Convertit le Double en Int (tronque)
    println("Partie entière du prix: $integerPart") // Affiche 99
}

Bien que tout soit objet, le compilateur Kotlin est intelligent et utilise, sous le capot, les types primitifs Java optimisés lorsque c'est possible pour des raisons de performance, tout en vous offrant la cohérence d'un modèle orienté objet.

Récapitulatif des types fondamentaux

Retenons les rôles principaux de ces types essentiels :

• `Int` : Pour les nombres entiers.
• `Double` : Pour les nombres décimaux (haute précision, type par défaut).
• `Boolean` : Pour les valeurs logiques `true` ou `false`.
• `String` : Pour les séquences de caractères (texte).

Maîtriser l'utilisation de ces types de base est indispensable car ils constituent les fondations sur lesquelles vous construirez des structures de données et des logiques de programme plus complexes en Kotlin.