Premiers pas avec Kotlin

Bonjour le monde

Tous les programmes Kotlin commencent par la fonction “main”. Voici un exemple d’un simple programme Kotlin “Hello World”:

package my.program

fun main(args: Array<String>) {
    println("Hello, world!")
}

Placez le code ci-dessus dans un fichier nommé Main.kt (ce nom de fichier est entièrement arbitraire)

Lors du ciblage de la JVM, la fonction sera compilée en tant que méthode statique dans une classe avec un nom dérivé du nom de fichier. Dans l’exemple ci-dessus, la classe principale à exécuter serait my.program.MainKt.

Pour modifier le nom de la classe qui contient les fonctions de niveau supérieur pour un fichier particulier, placez l’annotation suivante en haut du fichier au-dessus de l’instruction package :

@file:JvmName("MyApp")

Dans cet exemple, la classe principale à exécuter serait désormais my.program.MyApp.

Voir également:

  • [Fonctions au niveau du package] (https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#package-level-functions) y compris l’annotation @JvmName.
    Annotation use-site target

Hello World à l’aide d’un objet compagnon

Semblable à l’utilisation d’une déclaration d’objet, vous pouvez définir la fonction “main” d’un programme Kotlin à l’aide d’un [objet compagnon] (https://kotlinlang.org/docs/reference/object-declarations.html#companion-objects) d’un classer.

package my.program

class App {
    companion object {
        @JvmStatic fun main(args: Array<String>) {
            println("Hello World")
        }
    }
}

Le nom de la classe que vous allez exécuter est le nom de votre classe, dans ce cas c’est my.program.App.

L’avantage de cette méthode par rapport à une fonction de niveau supérieur est que le nom de la classe à exécuter est plus évident et que toutes les autres fonctions que vous ajoutez sont incluses dans la classe “App”. Ceci est similaire à l’exemple Déclaration d'objet, sauf que vous contrôlez l’instanciation de toutes les classes pour effectuer d’autres travaux.

Une légère variation qui instancie la classe pour faire le vrai “hello”:

class App {
    companion object {
        @JvmStatic fun main(args: Array<String>) {
            App().run()
        }
    }

    fun run() {
        println("Hello World")
    }
}

Voir également:

  • [Méthodes statiques] (https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#static-methods) incluant l’annotation @JvmStatic

Hello World en utilisant une déclaration d’objet

Vous pouvez également utiliser une Déclaration d’objet contenant la fonction principale d’un programme Kotlin.

package my.program

object App {
    @JvmStatic fun main(args: Array<String>) {
        println("Hello World")
    }
}

Le nom de la classe que vous allez exécuter est le nom de votre objet, dans ce cas c’est my.program.App.

L’avantage de cette méthode par rapport à une fonction de niveau supérieur est que le nom de la classe à exécuter est plus évident et que toutes les autres fonctions que vous ajoutez sont incluses dans la classe “App”. Vous disposez alors également d’une instance singleton de “App” pour stocker l’état et effectuer d’autres tâches.

Voir également:

  • [Méthodes statiques] (https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#static-methods) incluant l’annotation @JvmStatic

Principales méthodes utilisant varargs

Tous ces styles de méthode principaux peuvent également être utilisés avec [varargs][1] :

package my.program

fun main(vararg args: String) {
    println("Hello, world!")
}

[1] : https://kotlinlang.org/docs/reference/functions.html#variable-number-of-arguments-varargs

Compiler et exécuter le code Kotlin en ligne de commande

Comme java, fournissez deux commandes différentes pour compiler et exécuter du code Java. Comme Kotlin vous fournit également différentes commandes.

javac pour compiler les fichiers java. java pour exécuter les fichiers java.

Pareil que kotlinc pour compiler les fichiers kotlin kotlin pour exécuter les fichiers kotlin.

Lecture de l’entrée depuis la ligne de commande

Les arguments passés depuis la console peuvent être reçus dans le programme Kotlin et peuvent être utilisés comme entrée. Vous pouvez passer N (1 2 3 et ainsi de suite) nombres d’arguments à partir de l’invite de commande.

Un exemple simple d’argument de ligne de commande dans Kotlin.

fun main(args: Array<String>) {

    println("Enter Two number")
    var (a, b) = readLine()!!.split(' ') // !! this operator use for NPE(NullPointerException).

    println("Max number is : ${maxNum(a.toInt(), b.toInt())}")
}



fun maxNum(a: Int, b: Int): Int {

    var max = if (a > b) {
        println("The value of a is $a");
        a
    } else {
        println("The value of b is $b")
        b
    }

    return max;

}

Ici, entrez deux nombres à partir de la ligne de commande pour trouver le nombre maximum. Production :

Enter Two number
71 89 // Enter two number from command line

The value of b is 89
Max number is: 89

Pour !! Opérateur Veuillez vérifier [Null Safety][1].

Remarque : l’exemple ci-dessus compile et s’exécute sur Intellij.

[1] : https://kotlinlang.org/docs/reference/null-safety.html