Kotlin Tutoriel
Démarrer avec Kotlin

Remarques

Exception in thread "main" java.lang.NoClassDefFoundError: kotlin/jvm/internal/Intrinsics
    at MainKt.main(Main.kt)
Caused by: java.lang.ClassNotFoundException: kotlin.jvm.internal.Intrinsics
    at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:335)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    ... 1 more

Versions

Bonjour le monde

Tous les programmes Kotlin commencent à la fonction main . Voici un exemple de programme Kotlin "Hello World" simple:

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 totalement arbitraire)

Lorsque vous ciblez 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 contenant les fonctions de niveau supérieur pour un fichier particulier, placez l'annotation suivante en haut du fichier au-dessus de la déclaration de package:

@file:JvmName("MyApp")

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

Voir également:

• Fonctions de niveau package, y @JvmName annotation @JvmName .
  
• Cibles d'utilisation des annotations

Bonjour tout le monde 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, 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 intégrées à la classe App . Vous avez ensuite également une instance singleton App pour stocker l'état et faire d'autres travaux.

Voir également:

• Méthodes statiques incluant l'annotation @JvmStatic

Bonjour tout le monde en utilisant un objet compagnon

Semblable à l'utilisation d'une déclaration d'objet, vous pouvez définir la fonction main d'un programme Kotlin en utilisant un objet compagnon d'une classe.

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, en l'occurrence 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 intégrées à la classe App . Ceci est similaire à l'exemple de Object Declaration , sauf que vous contrôlez l'instanciation de classes pour effectuer d'autres tâches.

Une légère variation qui instancie la classe pour faire le bonjour:

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

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

Voir également:

• Méthodes statiques incluant l'annotation @JvmStatic

Principales méthodes utilisant varargs

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

package my.program

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

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

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

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

Identique à kotlinc pour compiler les fichiers kotlin pour exécuter les fichiers kotlin.

Lecture de l'entrée de la ligne de commande

Les arguments transmis depuis la console peuvent être reçus dans le programme Kotlin et peuvent être utilisés en entrée. Vous pouvez passer N (1 2 3 et ainsi de suite) nombre 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. Sortie:

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 .

Remarque: l'exemple ci-dessus est compilé et exécuté sur Intellij.