Le Langage

fun main(){
    println(Int.MIN_VALUE)
    println(Int.MAX_VALUE)
    println(Long.MIN_VALUE)
    println(Long.MAX_VALUE)
}

-2147483648
2147483647
-9223372036854775808
9223372036854775807

Process finished with exit code 0

fun main(){
    println(Int.SIZE_BYTES) // 4
    println(Int.SIZE_BITS)  // 32
}

4
32

Process finished with exit code 0

    var unFlottant: Float
    unFlottant = 43.2

Kotlin: The floating-point literal does not conform to the expected type Float

    var unFlottant: Float
    unFlottant = 43.2f

479.7825F
54.2089f

    var unInt: Int
    unInt = 13L

Kotlin: The integer literal does not conform to the expected type Int

    var unDouble: Double
    unDouble = 12.607e-6

    var unDouble: Double
    unDouble = 3_987_124_051.0

    println(0b1111_1110)
    println(0x00_FE)

    var carMutable: Char    // Déclaration d'un caractère mutable.
    val carImmuable: Char   // Déclaration d'un caractère immuable.

    var charAnd: Char = '&'
    var charAndUnicode: Char = '\u0026'
    println("charAnd = $charAnd")
    println("charUnicode = $charAndUnicode")

charAnd = &
charUnicode = &

Process finished with exit code 0

    var uneLigneDeTexte: String // String mutable
    val unParagraphe: String    // String immuable

    uneLigneDeTexte = "Bonjour à tous."

    unParagraphe =  """ |Pour faciliter les sauts de lignes dans un String
                        |nous pouvons utiliser la méthode trimMargin().
                        |Fin du paragraphe.""".trimMargin()

fun main(){
    var texte = "Un, deux, trois, quatre, cinq"
    println(texte[4])
    //texte[4] = "D" // Ne fonctionne pas car les Strings sont toujours immuables

    // Il faut réaffecter une nouvelle chaîne si nous désirons la modifier :
    texte = texte.substring(0..3) + 'D' + texte.substring(5..28)
    println(texte)
}

 // Les méthodes de transtypage/cast :
    var data01: Byte = 3
    var data02: Short = data01.toShort()
    var data03: Int = data01.toInt()
    var data04: Long = data01.toLong()
    var data05: Double = data01.toDouble()

    var idArray: Array<type>

    var tableau: Array<Int>           // Declaration d'un Array de Int
    var tableauFloat: Array<Float>    // Declaration d'un Array de Float
    var tableauChar: Array<Char>      // Declaration d'un Array de Char
    var tableauString: Array<String>   // Declaration d'un Array de String
    // Non exhaustif...

idRefTableau = Array(taille, lambda)

idRefTableau = Array(taille)lambda

    // Déclaration de la référence :
    var tableauInt: Array<Int>

    // Initialisation d'un table de taille 5 contenant la valeur 9:
    tableauInt = Array(5, {9})

    // Affichage :
    println(tableauInt.contentToString())

[9, 9, 9, 9, 9]

Process finished with exit code 0

    //Déclaration & initialisation (le type est déduit par inférence) :
    var tableauInt = Array(5, {it}) // it est une variable d'itération générée automatiquement par Kotlin

    // Affichage :
    println(tableauInt.contentToString())

[0, 1, 2, 3, 4]

Process finished with exit code 0

    //Déclaration & initialisation  :
    var tableauInt: Array<Int> = Array(5){3 * it}

    // Affichage :
    println(tableauInt.contentToString())

[0, 3, 6, 9, 12]

Process finished with exit code 0

    //Déclaration & initialisation  :
    var tableauInt = arrayOf("zéro", "un", "deux", "trois", "quatre")

    // Affichage :
    println(tableauInt.contentToString())

[zéro, un, deux, trois, quatre]

Process finished with exit code 0

    //Déclaration & initialisation  :
    var tableauInt = (5..10).toList().toTypedArray()

    // Affichage :
    println(tableauInt.contentToString())

[5, 6, 7, 8, 9, 10]

Process finished with exit code 0

    //Déclaration & initialisation d'un tableau de tableaux :
    var tableauDeTableaux = arrayOf(arrayOf(0, 1, 2, 3), arrayOf(4, 5, 6, 7), arrayOf(8, 9, 10, 11))
    // Affichage du contenu (attention il faut utiliser la méthode contentDeepToString ()):
    println(tableauDeTableaux.contentDeepToString())

[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]

Process finished with exit code 0

    //Déclaration & initialisation d'un tableau de tableaux :
    var tableauDeTableaux = Array(3){ Array(4){it} }
    // Affichage du contenu (attention il faut utiliser la méthode contentDeepToString ()):
    println(tableauDeTableaux.contentDeepToString())

[[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]

Process finished with exit code 0

    idArray[i] = nouvelleValeur

    //Déclaration & initialisation d'un tableau de tableaux :
    val tableau = arrayOf("Zéro", "Un", "Deux")

    // Modification d'une valeur :
    tableau[1] = "1"

    // Affichage du contenu (attention il faut utiliser la méthode contentDeepToString ()):
    println(tableau.contentDeepToString())

[Zéro, 1, Deux]

Process finished with exit code 0

    val setImmuable = setOf("un", "deux", "deux","trois", "quatre", "un") // Les 2 doublons seront éliminés
    val setDesordre = setOf("deux", "trois", "quatre", "un")

    println(setImmuable)
    println("trois est-il dans l'ensemble : ${"trois" in setImmuable}")
    println("Les 2 ensembles sont-ils égaux : ${setDesordre == setImmuable}")

    // setImmuable[2] est interdit, mais nous pouvons utiliser elementAt() :
    println(setImmuable.elementAt(2))

[un, deux, trois, quatre]
trois est-il dans l'ensemble : true
Les 2 ensembles sont-ils égaux : true
trois

Process finished with exit code 0

    val setMutable = mutableSetOf("un", "deux", "deux","trois", "quatre", "un") // Les 2 doublons seront éliminés
    setMutable += "un"
    setMutable.add("cinq")
    println(setMutable)
    setMutable.remove("trois")
    println(setMutable)
    println(setMutable.elementAt(2))

[un, deux, trois, quatre, cinq]
[un, deux, quatre, cinq]
quatre

Process finished with exit code 0

    // Création d'un map :
    var tabAssoImmuable = mapOf(0 to "Zero", 1 to "Une", 2 to "Deux", 3 to "Trois")
    var tabAssoMutable = mutableMapOf(0 to "Zero", 1 to "Une", 2 to "Deux", 3 to "Trois")

    // Exploitation :
    println("Exemple avec tabAssoImmuable : $tabAssoImmuable")
    println("tabAssoImmuable.keys : ${tabAssoImmuable.keys}")
    println("tabAssoImmuable.values : ${tabAssoImmuable.values}")

    // Accès par clé :
    println("Valeur à la clée 2 : tabAssoImmuable[2] = ${tabAssoImmuable[2]}")

    // Vérification présence clé :
    println("La clée 1 est-elle dans tabAssoImmuable : ${1 in tabAssoImmuable}")
    println("La clée 7 est-elle dans tabAssoImmuable : ${7 in tabAssoImmuable}")

    // Vérification présence valeur :
    println("La valeur \"Deux\" est-elle dans tabAssoImmuable : ${"Deux" in tabAssoImmuable.values}")

Exemple avec tabAssoImmuable : {0=Zero, 1=Une, 2=Deux, 3=Trois}
tabAssoImmuable.keys : [0, 1, 2, 3]
tabAssoImmuable.values : [Zero, Une, Deux, Trois]
Valeur à la clée 2 : tabAssoImmuable[2] = Deux
La clée 1 est-elle dans tabAssoImmuable : true
La clée 7 est-elle dans tabAssoImmuable : false
La valeur "Deux" est-elle dans tabAssoImmuable : true

Process finished with exit code 0

fun idFonction(idArg01: typeArg01, idArg02: typeArg02, ...): typeRetour

fun somme(operandeGauche: Double, operandeDroit: Double): Double

fun idFonction(idArg01: typeArg01, idArg02: typeArg02, ...)

fun procedure(message: String)

fun idFonction(idArg01: typeArg01 = valDefaut01: , idArg02: typeArg02 = valDefaut02, ...)

fun produit(x: Double = 2.0, y: Double = 4.0) : Double {

fun idFonction(vararg idVar: typeArguments): typeRetour

fun somme(vararg termes: Double): Double

fun idFonction(idArg01: Type01 = valDefaut01, vararg idVar: typeArguments): typeRetour{
    // Corps de la fonction contenant l'ensemble des instructions.
    return varRetour

fun exemple(mot1: String = "Bonjour", vararg mots: String): String{
    var phrase: String = mot1
    for (mot in mots)
        phrase += " " + mot
    return phrase
}

fun main(){
    println(exemple("Coucou", "comment", "allez-vous ?"))
}

Coucou comment allez-vous ?

Process finished with exit code 0

fun idFoncExpression(arg01: Type01,...): TypeRetour = expression

fun produit(facteurGauche: Double, facteurDroit: Double): Double = facteurGauche * facteurDroit

fun main(){
    println(produit(3.0, 15.0))
}

fun idFoncOrdreSup(argFonc: () -> Unit): typeRetour{
    // Corps de la fonction...
}

fun idFoncOrdreSup(argFonc: () -> typeRetour): typeRetour{
    // Corps de la fonction...
}

fun idFoncOrdreSup(argFonc: (typeRetour) -> typeRetour): typeRetour{
    // Corps de la fonction...
}

fun fonctionOrdreSuperieur_01(argFonc: () -> Unit){
    argFonc()
}

fun fonctionOrdreSuperieur_02(argFonc: () -> String): String{
    return argFonc()
}

fun fonctionOrdreSuperieur_03(argFonc: (String) -> String): String{
    return argFonc("Hello")
}

idFoncSuperieur(::idArgFonc)

// Définition d'une fonction d'ordre supérieur :
fun cobaye(argFonc: (String) ->String): String{
    return argFonc("Message original")
}
// Définition d'une fonction argument :
fun argument(mot: String): String = mot + " (Ok, message lu)"

fun main(){
    var retour: String
    retour = cobaye(::argument) // Le passage de la référence s'accompagne des ::
    println(retour)
}

Message original (Ok, message lu)

Process finished with exit code 0

{arg01: typeArg01, arg02: typeArg02, ...-> expression}

fun main() {

    fonctionOrdreSuperieur_01({println("Appel de lambda_01")})
    println( fonctionOrdreSuperieur_02( {"Appel de lambda_02"} ) )
    println( fonctionOrdreSuperieur_03 ( { chaine: String ->  chaine + " Fin !" } ) )
    // Utilisation d'une référence :
    val f = { chaine: String ->  chaine + " Ok !" }
    println(  fonctionOrdreSuperieur_03(f))
}
// Définition des fonctions d'ordre supérieur
fun fonctionOrdreSuperieur_01(argFonc: () -> Unit){
    argFonc()
}
fun fonctionOrdreSuperieur_02(argFonc: () -> String): String{
    return argFonc()
}
fun fonctionOrdreSuperieur_03(argFonc: (String) -> String): String{
    return argFonc("Exécution de la fonction d'ordre supérieur n°3")

Appel de lambda_01
Appel de lambda_02
Exécution de la fonction d'ordre supérieur n°3 Fin !
Exécution de la fonction d'ordre supérieur n°3 Ok !

Process finished with exit code 0

    fonctionOrdreSuperieur_01() {println("Appel de lambda_01")}
    println( fonctionOrdreSuperieur_02() {"Appel de lambda_02"} )
    println( fonctionOrdreSuperieur_03 () { chaine: String ->  chaine + " Fin !" } )

// Définition de la fonction d'ordre supérieur :
fun doublerValeur(valeur: Double, lambda: (Double) -> Double) {println("Le double de $valeur = ${lambda(valeur)}")}

fun main(){
    // Appels de la fonction d'ordre supérieur avec une fonction lambda :
    doublerValeur(16.0, {x: Double -> 2 * x}) // Forme complète avec la déclaration du paramètre
    doublerValeur(16.0, {2 * it})              // Forme utilisant le paramètre it

// Syntaxe sous forme d'expression :
val anoynyme01  = fun(arg01: Type01, arg02: Type02, ...): typeRetour = expression

// Syntaxe avec bloc d'instructions :
val anoynyme02  = fun(arg01: Type01, arg02: Type02, ...): typeRetour {// Bloc d'instructions avec return}

// Définition de 2 fonctions anonymes selon 2 variantes syntaxiques :
val somme01 = fun(x: Double, y: Double): Double {return x + y} // Cette variante peut s'écrire sur plusieurs lignes
val somme02 = fun(x: Double, y: Double): Double =  x + y // Doit s'écrire sur 1 ligne.

// Fonction d'ordre supérieur :
fun fonctionOrdreSup(x: Double, y: Double, somme: (Double, Double) -> Double) = println("$x + $y = ${somme(x, y)}")

// Fonction principale :
fun main(){
    fonctionOrdreSup(5.0, 3.0, somme01)
    fonctionOrdreSup(-10.0, 7.0, somme02)
}

5.0 + 3.0 = 8.0
-10.0 + 7.0 = -3.0

Process finished with exit code 0

fun somme(operandeGauche: Double, operandeDroit: Double): Double{
    return operandeGauche + operandeDroit
}

fun main() {
    println(somme(2, 3))
}

Kotlin: The integer literal does not conform to the expected type Double

private fun somme(operandeGauche: Number, operandeDroit: Number): Double{
    return operandeGauche.toDouble() + operandeDroit.toDouble()

fun taille(argObj: Any): Int{
    if (argObj is Collection<*>) return argObj.size
    if (argObj is String) return  argObj.length
    return 0
}

fun main(){
    val listeTest = listOf(0, 1 ,2, 3)
    val setTest = setOf(4, 5, 6)
    val texte = "Kotlin"

    println("Taille de listeTest : ${taille(listeTest)}")
    println("Taille de setTest : ${taille(setTest)}")
    println("Taille de texte : ${taille(texte)}")
}

Taille de listeTest : 4
Taille de setTest : 3
Taille de texte : 6

Process finished with exit code 0

fun taille(argObj: Any) = when(argObj){
    is Collection<*> -> argObj.size
    is String -> argObj.length
    else -> 0
}

    var y: Number = 3L // La constante affectée est un Long
    var z: Long = y as Long

    var k: Number = 3 // La constante affectée est un Int
    var l: Int = k as Int

    var bidule: Any = "Kotlin" // La constante affectée est un String
    var texte: String = bidule as String

class Cercle(val coordCentreX: Number = 0, val coordCentreY:Number = 0, val rayon: Number)

class Cercle(val coordCentreX: Number = 0, val coordCentreY:Number = 0, private val rayon: Number)

fun main(){
    val objCercle = Cercle(rayon = 1)
    println("Coordonnées centre : (${objCercle.coordCentreX}, ${objCercle.coordCentreY})")
    println("Rayon :${objCercle.rayon}")

    println(objCercle.rayon)        // Echec, attribut privé
    objCercle.coordCentreX = 1      // Echec, accès en lecture
}

class Cercle(val coordCentreX: Number = 0, val coordCentreY:Number = 0, val rayon: Number)

import kotlin.math.pow
import kotlin.math.PI

class Cercle(val coordCentreX: Number = 0, val coordCentreY: Number = 0, val rayon: Number){

    // Attributs :
    var perimetre: Double = 0.0
    var surface: Double = 0.0

    // Méthodes :
    private fun calculerPerimetre(){perimetre = 2 * PI * rayon.toDouble()}
    private fun calculerSurface(){surface = PI * rayon.toDouble().pow(2)}

    // Corps du constructeur principal :
    init{
        calculerPerimetre()
        calculerSurface()
    }
}

    val objCercle = Cercle(rayon = 1)
    println("Coordonnées centre : (${objCercle.coordCentreX}, ${objCercle.coordCentreY})")
    println("Rayon : ${objCercle.rayon}")
    println("Périmètre : ${objCercle.perimetre}")
    println("Surface : ${objCercle.surface}")

Coordonnées centre : (0, 0)
Rayon : 1
Périmètre : 6.283185307179586
Surface : 3.141592653589793

Process finished with exit code 0

class Cercle(var coordCentreX: Number = 0, var coordCentreY:Number = 0, rayon: Number){

    // Attributs :
    var perimetre: Double = 0.0
    var surface: Double = 0.0
    var rayon: Number = 0
        get() {
            println("Exécution du getter du rayon !")
            return field    // field est l'attribut, ici rayon
        }
        set(valUpDate) {
            field = valUpDate
            calculerPerimetre()
            calculerSurface()
        }

    // Méthodes :
    private fun calculerPerimetre(){perimetre = 2 * PI * rayon.toDouble()}
    private fun calculerSurface(){surface = PI * rayon.toDouble().pow(2)}

    // Corps du constructeur principal :
    init{
        this.rayon = rayon      // Initialisation de l'attribut à partir du paramètre du constructeur principal
        calculerPerimetre()
        calculerSurface()
    }
}

fun main(){
    val objCercle = Cercle(rayon = 1)
    objCercle.rayon = 2.0
    println("Coordonnées centre : (${objCercle.coordCentreX}, ${objCercle.coordCentreY})")
    println("Rayon : ${objCercle.rayon}")
    println("Périmètre : ${objCercle.perimetre}")
    println("Surface : ${objCercle.surface}")
}

Exécution du getter du rayon !
Exécution du getter du rayon !
Exécution du getter du rayon !
Exécution du getter du rayon !
Exécution du getter du rayon !
Exécution du getter du rayon !
Coordonnées centre : (0, 0)
Exécution du getter du rayon !
Rayon : 2.0
Périmètre : 12.566370614359172
Surface : 12.566370614359172

Process finished with exit code 0

class Exemple01{
    init {
        println("Constructeur primaire")
    }
    constructor(){
        println("Constructeur secondaire")
    }
}

fun main(){
    val obj01 = Exemple01()
}

Constructeur primaire
Constructeur secondaire

Process finished with exit code 0

class Exemple02(){
    init {
        println("Constructeur primaire")
    }
    constructor(bourage: Int): this(){
        println("Constructeur secondaire")
    }
}

fun main(){
    val obj01 = Exemple02(0)
}

Constructeur primaire
Constructeur secondaire

Process finished with exit code 0

// Définition de la classe de base :
open class Base(){
    // Corps de la classe Base
}

// Définition de la classe dérivée :
class Derive(): Base(){
    // Corps de la classe Derive
}

// Définition de la classe dérivée :
class Derive(arg01: Int, arg02: Int, val attrib03: Int): Base(arg01, arg02){
    override var attrib04 = 40  // Redéfinition de la valeur

// Définition de la classe dérivée :
class Derive(arg01: Int, arg02: Int, val attrib03: Int): Base(arg01, arg02){
    init{
        attrib04 = 40
        ...

// Définition de la classe dérivée :
class Derive(arg01: Int, arg02: Int, val attrib03: Int): Base(arg01, arg02){
    override var attrib04 = 40
        get() = field + 10
        set(valeur) {field = valeur - 10}

open class Base(var attrib01: Int, val attrib02: Int){
    open var attrib04: Int = 4
    init{
        println("Constructeur primaire de Base")
    }
    open fun methode01(){
        println("Méthode01 de Base")
    }
}

// Définition de la classe dérivée :
class Derive(arg01: Int, arg02: Int, val attrib03: Int): Base(arg01, arg02){
    init{
        println("Constructeur primaire de Derive")
        println("attrib01 : ${attrib01}\nattrib02 : ${attrib02}\nattrib03 : ${attrib03}")
    }
    override fun methode01(){
        println("Méthode01 redéfinie par Derive")
    }

open class Open(){
    open val attrib01: Int = 1
    open val attrib02: Int = 10
    val attrib03: Int = 100
    open fun  methode01(){
        println("Appel de Open")
    }
}

class Derive(): Open(){
    override val attrib01 = 2 * super.attrib01 + super.attrib02
    override val attrib02: Int = super.attrib02
        get() = field + attrib03

    override fun methode01(){
        super.methode01()
        println("Appel de Derive")
    }
}


fun main(){
    val obj = Derive()
    println("obj.attrib01 = ${obj.attrib01}")
    obj.methode01()
    println("obj.attrib02 = ${obj.attrib02}")

obj.attrib01 = 12
Appel de Open
Appel de Derive
obj.attrib02 = 110

Process finished with exit code 0

open class Base{
    var champ01: Int = 1
    var champ02: Int = 2

    constructor()
    constructor(arg01: Int, arg02: Int): this() {
        champ01 = arg01
        champ02 = arg02
    }
}

class Derive: Base{
    constructor(): super()
    constructor(arg01: Int, arg02: Int): super(arg01, arg02)
}

abstract class Figure{
    abstract var couleur: String
    abstract val perimetre: Float
    abstract val aire: Float
}

abstract class Polygone: Figure(){
    abstract val nbCotes: Int
}

abstract class Quadrilatere: Polygone(){
    override val nbCotes = 4
}

open class Rectangle(
    override var couleur: String,
    var longueur: Float,
    var largeur: Float
    ): Quadrilatere(){

        final override var perimetre: Float = 0.0F // final permet de mettre fin à l'héritage
            get() {
                field = 2 * (longueur + largeur)
                return field
            }
            // Blocage de l'accès en écriture
            private set // Il faut impérativement repasser l'attribut en final pour rendre privé le setter

        final override var aire: Float = 0.0F // final permet de mettre fin à l'héritage
            get() {
                field = longueur * largeur
                return field
            }
            // Blocage de l'accès en écriture :
            private set // Il faut impérativement repasser l'attribut en final pour rendre privé le setter
}

class Carre(couleur: String, longueur: Float): Rectangle(couleur, longueur, longueur)


fun main(){
    val carre01 = Carre("blanc", 5.0F)
    println("Couleur : ${carre01.couleur}")
    println("Perimètre : ${carre01.perimetre}")
    println("Aire : ${carre01.aire}")
}

Couleur : blanc
Perimètre : 20.0
Aire : 25.0

Process finished with exit code 0

abstract class Personne(
    val nom: String,
    val prenom: String,
    var age: Int){

    open fun presenter(){
        println("Nom : ${nom}")
        println("Prenom : ${prenom}")
        println("Age : ${age}")
    }
    fun vieillir(){
        age += 1
    }
}

class Employe(nom: String, prenom: String, age: Int, var poste: String): Personne(nom, prenom, age){
    var salaireMensuel: Float = 0.0F

    override fun presenter(){
        super.presenter()
        println("Poste : ${poste}")
        println("Salaire : ${salaireMensuel}")
    }
    fun augmenterSalaire(augmentation: Float){
        salaireMensuel += augmentation
    }
}

fun main(){
    val comptable01 = Employe("DOE", "Joe", 28, "Comptable")
    comptable01.salaireMensuel = 1_950.00F
    comptable01.presenter()
}

Nom : DOE
Prenom : Joe
Age : 28
Poste : Comptable
Salaire : 1950.0

Process finished with exit code 0

// Définition à la volée d'un objet :
val objDemo = object {
    val mot1 = "Bonjour"
    val mot2 = "à tous !"
    override fun toString() = "$mot1 $mot2"
}

fun main(){
    // Passage de l'identifiant à la fonction println
    println(objDemo)
}

Bonjour à tous !

Process finished with exit code 0

// Définition d'une interface :
interface Personne {
    val nom: String
    val prenom: String
}
// Définition d'une classe abstraite :
abstract class PersonneDefaut(
    override val nom: String = "DOE",
    override val prenom: String = "John"
): Personne

// Fonction prennant en argument un objet de type Personne
fun direBonjour(argObj: Personne) {
    println("Bonjour ${argObj.nom} ${argObj.prenom} !")
}

fun main() {
    direBonjour(object: PersonneDefaut(){})
    direBonjour(object: Personne{
        override val nom: String = "DUPONT"
        override val prenom: String = "Jean"})
}

Bonjour DOE John !
Bonjour DUPONT Jean !

Process finished with exit code 0

enum class Direction {
    NORD, SUD, EST, OUEST

enum class Jours{
    LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI, DIMANCHE

enum class RGB(val r: Int, val g: Int, val b: Int) {
    ROUGE(255, 0, 0),
    VERT(0, 255, 0),
    BLEU(0, 0, 255),
    NOIR(0, 0, 0),
    BLANC(255, 255, 255)
}

fun main(){
   println("Le code RGB de la couleur ${RGB.BLEU} est : [${RGB.BLEU.r}, ${RGB.BLEU.g}, ${RGB.BLEU.b}]")
}

Le code RGB de la couleur BLEU est : [0, 0, 255]

Process finished with exit code 0

enum class JoursSemaine(var numJour: Int, var nomString: String){
    // Constantes de l'énumération :
    LUNDI(1, "Lundi"),
    MARDI(2, "Mardi"),
    MERCREDI(3, "Mercredi"),
    JEUDI(4, "Jeudi"),
    VENDREDI(5, "Vendredi"),
    SAMEDI(6, "Samedi"),
    DIMANCHE(7, "Dimanche");

    // Méthodes supplémentaires :
    fun customToString() = "Jour n°${numJour} : ${nomString}"

    // Objet compagnon (comportement d'une méthode statique) :
    companion object {
        fun presenter() {
            println(values().contentToString())
        }
    }
}

fun main(){
    println(JoursSemaine.MARDI.customToString())
    JoursSemaine.presenter()
}

Jour n°2 : Mardi
[LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI, DIMANCHE]

Process finished with exit code 0

enum class JoursSemaine(var numJour: Int, var nomString: String){
    // Constantes de l'énumération :
    LUNDI(1, "Lundi")
        {override fun customToString() = "Jour n°${numJour} : ${nomString}, c'est la reprise du boulot..."},
    MARDI(2, "Mardi")
        {override fun customToString() = "Jour n°${numJour} : ${nomString}, mieux que le lundi."},
    MERCREDI(3, "Mercredi")
        {override fun customToString() = "Jour n°${numJour} : ${nomString}, encore 3 jours."},
    JEUDI(4, "Jeudi")
        {override fun customToString() = "Jour n°${numJour} : ${nomString}, bientôt le week-end."},
    VENDREDI(5, "Vendredi")
        {override fun customToString() = "Jour n°${numJour} : ${nomString}, vivement ce soir !"},
    SAMEDI(6, "Samedi")
        {override fun customToString() = "Jour n°${numJour} : ${nomString}, c'est le week-end !!!!"},
    DIMANCHE(7, "Dimanche")
        {override fun customToString() = "Jour n°${numJour} : ${nomString}, ça passe trop vite..."};

    // Méthodes supplémentaires :
    abstract fun customToString(): String

    // Objet compagnon (comportement d'une méthode statique) :
    companion object {
        fun presenter() {
            println(values().contentToString())
        }
    }
}

fun main(){
    println(JoursSemaine.LUNDI.customToString())
    println(JoursSemaine.SAMEDI.customToString())
}

Jour n°1 : Lundi, c'est la reprise du boulot...
Jour n°6 : Samedi, c'est le week-end !!!!

Process finished with exit code 0

interface Jour{
    fun customToString(): String
}

enum class JoursSemaine(var numJour: Int, var nomString: String): Jour{
    // Constantes de l'énumération :
    LUNDI(1, "Lundi")
    {override fun customToString() = "${super.customToString()}, c'est la reprise du boulot..."},
    MARDI(2, "Mardi")
    {override fun customToString() = "${super.customToString()}, mieux que le lundi."},
    MERCREDI(3, "Mercredi")
    {override fun customToString() = "${super.customToString()}, encore 3 jours."},
    JEUDI(4, "Jeudi")
    {override fun customToString() = "${super.customToString()}, bientôt le week-end."},
    VENDREDI(5, "Vendredi")
    {override fun customToString() = "${super.customToString()}, vivement ce soir !"},
    SAMEDI(6, "Samedi")
    {override fun customToString() = "${super.customToString()}, c'est le week-end !!!!"},
    DIMANCHE(7, "Dimanche")
    {override fun customToString() = "${super.customToString()}, ça passe trop vite..."};

    // Redéfinition de la méthode héritée de l'interface :
    override fun customToString() = "Jour n°${numJour} : ${nomString}"

    // Objet compagnon (comportement d'une méthode statique) :
    companion object {
        fun presenter() {
            println(values().contentToString())
        }
    }
}

class PlusOuMoinsCinqOuRien(var valeur: Int){
    operator fun unaryMinus(): Int = valeur - 5
    operator fun unaryPlus(): Int = valeur + 5
    operator fun not(): Int = 0
}

fun main(){
    var x = PlusOuMoinsCinqOuRien(17)
    println("x = ${x.valeur}")
    println("-x = ${-x}")
    println("+x = ${+x}")
    println("!x = ${!x}")
}

x = 17
-x = 12
+x = 22
!x = 0

Process finished with exit code 0

class Coord(var x: Double, var y: Double) {
    operator fun plus(b: Coord): Coord {
        var somme = Coord(x + b.x, y + b.y)
        return somme
    }

    operator fun minus(b: Coord): Coord {
        var somme = Coord(x - b.x, y - b.y)
        return somme
    }

    override fun toString() = "[$x, $y]"
}

fun main(){
    var pt1 = Coord(3.0, 7.0)
    var pt2 = Coord(2.0, 3.0)
    println(pt1 + pt2)
    println(pt1 - pt2)

}

[5.0, 10.0]
[1.0, 4.0]

Process finished with exit code 0