Ce que j'ai appris sur Kotlin

Qu'est-ce que Kotlin

Kotlin est un langage de programmation orienté objet développé par Jet Brains, célèbre pour IntelliJ IDEA. Parce que le code compilé s'exécute sur la JVM Il est désormais possible de détourner les actifs créés par JAVA.

Syntaxe de base de Kotlin

Déclaration de variable

//La déclaration avec val empêche la réaffectation des valeurs
val firstName: String = "Tanaka"  
//Pas besoin de définir chaque type dans l'inférence de type
val lastName = "Taro"  
  
//Peut être réaffecté en le déclarant avec var
var age = 20  
age = 21

Tableau

//Tableau(array)Créer
val nameList: Array<String> = arrayOf("tanaka", "saitou", "kimura")  
println(nameList[0]) //sortie par tanaka
  
//Réécrire les éléments d'un tableau
nameList[1] = "sakurai"  
println(nameList[1]) //sortie par sakurai
  
//Tableau(liste)Créer
val animalList: List<String> = listOf("dog", "cat", "rabbit")  
println(animalList[0]) //sorties de chien
  
//Réécrire les éléments d'un tableau
animalList[1] = "tiger" //La liste des interfaces d'erreur est en lecture seule

Même avec List, mutableListOf () peut être utilisé pour créer une liste qui peut être modifiée, donc je ne sais pas comment utiliser Array et List correctement.

carte

//Création de carte
val numberMap: MutableMap<String, Int> = mutableMapOf("one" to 1)  
println(numberMap["one"]) //1 est la sortie
////Ajouter de la valeur
numberMap["tow"] = 2  
println(numberMap)        // {one=1, tow=2}Les sorties
  
//Créer une carte avec mapOf
val reNumberMap: Map<Int, String> = mapOf(1 to "one")  
println(reNumberMap[1])   //1 est la sortie
////Ajouter de la valeur
reNumberMap["tow"] = 2    //L'erreur mapOf est en lecture seule

Branche conditionnelle

//Instruction if ordinaire
if (true) {  
    println("if")   //si sorties
} else {  
    println("else")  
}  
  
//Kotlin n'a pas d'opérateur ternaire, donc ça ressemble à ça
val animal = "dog"  
val isDog = if (animal == "dog") true else false  
println(isDog)      //vrai est la sortie
  
//Pour chèque vide
val person:String? = null  
val personName = person?: "NoName"  
println(personName) //NoName est sorti
  
//Instruction When Similaire à l'instruction switch
val result = when("hoge") {  
    "hoge" -> "hoge"  
    "fuga" -> "fuga"  
     else -> "else"  
}  
println(result)     //sorties hoge

Traitement en boucle

//déclaration while
var count = 5  
while(0 < count--) {  
    println("while count: ${count}")  
}  
  
//pour déclaration
for (i in 1..5) {  
    println("for count: ${i}")  
}

Comparaison de l'écriture entre JAVA et Kotlin

Ajouter l'âge, le nom et le sexe à la classe d'utilisateurs J'ai écrit le code pour exécuter la méthode d'auto-introduction.

Kotlin

user.kt

fun main() {  
    val user = userData(20, "Taro", "Men")  
    user.selfIntroduction()  
}

userData.kt

data class userData (  
    var age: Int? = 0,  
    var name: String = "NoName",  
    var gender: String? = null  
) {  
    fun selfIntroduction() {  
        println("My name is ${name}")  
        println("Age is ${age}")  
        println("Gender is ${gender}")  
    }  
}

JAVA

user.java

public class user {  
    public static void main(String[] args) {  
        userData user = new userData(20, "Taro", "Men");  
        user.selfIntroduction();  
    }  
}

userData.java

public class userData {  
    private int age;  
    private String name;  
    private String gender;  
  
    public userData(int age, String name, String gender) {  
        this.age = age;  
        this.name = name;  
        this.gender = gender;  
    }  
  
    public void selfIntroduction() {  
        System.out.println("My name is " + this.name);  
        System.out.println("Age is " + this.age);  
        System.out.println("Gender is " + this.gender);  
    }  
}

La différence que j'ai ressentie après avoir écrit

Vous n'avez pas besoin de Nouveau pour créer un constructeur
Il n'est pas nécessaire de définir le type en raison de la fonction d'inférence de type.
Le point-virgule de fin n'est pas obligatoire
Vous pouvez mettre une expression dans une chaîne littérale

Bonjour le monde à Spring Boot

environnement

Windows10 Pro IntelliJ Community Edition 2020.2 JAVA 14

Créer un modèle pour le projet

Utilisez Spring Initializr pour obtenir un modèle pour votre projet.

Le réglage est Project : Gradle Project Language : Kotlin Spring Boot : 2.3.4 ** Métadonnées du projet **: laisser la valeur par défaut Packaging Jar Java : 14 Dependencies : Spring Web

Enfin, appuyez sur ** GENERATE ** pour télécharger le modèle de projet

Construire le modèle du projet créé

Depuis IntelliJ ** Fichier → Ouvrir ... → Sélectionner le modèle du projet téléchargé → Extraire avec la procédure OK **

Créer un contrôleur

Pour le dossier demo / src / main / kotlin / com.example.demo / controller ** Clic droit → Nouveau → Appuyez sur Kotlin File / Class ** Créez HelloController.kt.

HelloController.kt

package com.example.demo.controller

import org.springframework.web.bind.annotation.RestController
import org.springframework.web.bind.annotation.RequestMapping

@RestController
public class HelloController {
    @RequestMapping("/")
    fun hello():String {
        return "Hello World"
    }
}

Démarrez le serveur Web

Cliquez sur le ** bouton de lecture ** en haut à droite pour créer

Lien

Connectez-vous à http: // localhost: 8080 lorsque la construction est terminée

Impressions

Je n'ai pas tellement touché JAVA, alors J'avais peur que Kotlin irait bien sans connaître JAVA. Quand j'ai soudainement commencé à écrire à partir de Kotlin, il n'y avait soudainement aucun problème avec Kotlin Au contraire, j'ai senti qu'il était plus facile de démarrer avec Kotlin. Quand je l'ai comparé avec JAVA, la quantité de code dans Kotlin est devenue plus petite, J'ai senti que l'inférence de type, les classes de données, etc. aidaient à garder le code simple.

[JAVA] Ce que j'ai appris sur Kotlin