KotlinRush : est-il judicieux de continuer à écrire en Java ?

Bonjour, étudiant JavaRush, avant de vous laisser complètement absorber par Java, j'aimerais élargir vos horizons et attirer votre attention sur le langage Kotlin de plus en plus populaire ! Kotlin est un langage assez jeune développé par JetBrains . Oui, oui, la même entreprise qui a développé notre IDE préféré : IntelliJ IDEA. Kotlin est un langage JVM et est entièrement compatible avec Java , c'est-à-dire qu'à partir du code Kotlin, vous pouvez facilement accéder aux bibliothèques Java familières. Qu'en est-il des bibliothèques : les classes Kotlin et Java peuvent coexister dans un seul package ! Kotlin était si populaire auprès de la communauté des programmeurs que Google l'a reconnu comme le langage de développement officiel pour Android, et récemment, Kotlin a commencé à gagner en popularité dans les projets d'entreprise. Dans cet article, je voudrais donner plusieurs exemples comparatifs de code écrit en Kotlin et Java, et tirer quelques conclusions. Aller! Commençons, comme d'habitude, par "Hello World"

// Java
public class Application {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

// Kotlin
class Application
fun main(vararg args: String) {
    println("Hello World!")
}

En regardant l’exemple de Kotlin, on peut immédiatement noter ce qui suit :

• pas besoin d'écrire un point-virgule à la fin de la ligne ;
• toutes les méthodes sont décrites par le mot-clé fun ;
• Pour imprimer une ligne, un seul mot suffit - println() !

Création d'une instance

// Java (до 10)
final Application application = new Application();

// Kotlin
val application = Application()

Différences Kotlin :

• il n'est pas nécessaire de déclarer le type d'une variable s'il ressort clairement de l'instance ;
• au lieu du type de variable - val (immuable) ou var (modifiable) ;
• Vous n'avez pas besoin d'écrire le nouveau mot-clé pour créer une instance !

Description des méthodes

// Java
public int sum(int a, int b) {
    return (a + b);
}

// Kotlin
fun sum(a: Int, b: Int): Int {
return (a + b)
}

Différences Kotlin :

• si quelque chose doit être renvoyé par une méthode, « : Int » est ajouté à la signature, où Int est le type de retour ;
• description des paramètres de la méthode : d'abord le nom de la variable, puis le type ;
• puisque le corps de la méthode ne comporte qu'une seule ligne, vous pouvez omettre le return :
  

  fun sum(a: Int, b: Int): Int = (a+b)

Sortie de chaîne formatée

// Java
public int sum(int a, int b) {
    int result = (a + b);
    System.out.printf("Сумма %d и %d равна %d\n", a, b, result);
    return result;
}

// Kotlin
fun sum(a: Int, b: Int): Int {
    val result = (a + b)
    println("Сумма $a и $b равна $result")
    return result
}

Kotlin prend en charge l'interpolation de chaîne, utilisez simplement le symbole "$" au début de la variable. Cette notation améliore considérablement la propreté et la lisibilité du code. Comparaison d'instances

// Java
object1.equals(object2)

// Kotlin
object1 == object2

Dans Kotlin, la comparaison " ==" pour les types d'objets est traduite parequals ! Et pour comparer les liens, " ===" est utilisé. Des exceptions

// Java
public List<String> getFileContent(String file) throws IOException {
    Path path = Paths.get(file);
    return Files.readAllLines(path);
}

// Kotlin
fun getFileContent(file: String): List<String> {
    val path = Paths.get(file)
    return Files.readAllLines(path)
}

Il n'y a pas d'exceptions vérifiées dans Kotlin ; vous n'avez désormais plus besoin de lancer sans cesse une exception dans l'ensemble de l'application ou de créer des exceptions à plusieurs niveaux try-catch. Sécurité nulle

// Java
public class Data {
    String value;

    String render() {
        if (value == null) {
            return "Value: undefined";
        } else {
            return "Value:" + value.toUpperCase();
        }
    }
}

// Kotlin
class Data {
    var value: String? = null
    fun render(): String =
            "Value: ${value?.toUpperCase() ?: "undefined"}"
}

Kotlin s'est occupé du problème NPE et a introduit un certain nombre d'exigences :

• tous les champs et variables de classe doivent être initialisés ;
• Vous pouvez écrire « null » dans un champ ou une variable, mais vous devez alors indiquer explicitement que votre variable est Nullable (écrivez le signe « ? ») ;
• L'opérateur Elvis « ? : » fonctionne comme ceci : s'il y a Null à gauche, prenez ce qui est à droite. Dans le cas de notre exemple, lorsque la variable valeur n'est pas initialisée, la valeur « undefined » sera prise.

Champs de classe et accès à ceux-ci

// Java
public class Data {
    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}
class App {
    void execute() {
           Data data = new Data()
           data.setValue("Foo")
     }
}

// Kotlin
class Data {
    var value: String = ""
}
class App {
    fun execute() {
          val data = Data()
          data.value = "Foo" // Под капотом выполнится data.set("Foo")
     }
}

En Kotlin, il suffit simplement de décrire un champ et c'est tout : il a déjà des getters et des setters implicites (bonjour lombok ), qui peuvent être remplacés à tout moment si on le souhaite. En même temps, on lit et modifie la valeur du champ simplement en y accédant directement, et sous le capot on l'appelle get()|set(). Cycles

// Java
void example() {
    for(int i = 1; i <= 10; i++) {
        System.out.println(i);
    }

    for(String line : "a,b,c".split(",")) {
        System.out.println(line);
    }
}

// Kotlin
fun example() {
    for(i in 1..10) {
        println(i)
    }

    for(line in "a,b,c".split(",")) {
        println(line)
    }
}

Kotlin a fourni une syntaxe pratique et uniforme pour parcourir les séquences : vous utilisez simplement une variable à gauche , une séquence à droite et le mot-clé « in » entre les deux, le type est déterminé automatiquement par le contenu. Singleton

// Java
public class Singleton {
    private static Singleton ourInstance = new Singleton();

    public static Singleton getInstance() {
        return ourInstance;
    }

    private Singleton() {
    }
}
class App {
    void execute() {
         Singleton singleton = Singleton.getInstance()
    }
}

// Kotlin
object Singleton {}

class App {
    fun execute() {
          val singleton = Singleton
    }
}

Le modèle familier « singler » est utilisé assez souvent dans la pratique, c'est pourquoi Kotlin a décidé de créer un mot-clé distinct « object », qui est écrit à la place de « class » et signifie que la classe est un singleton ; lorsqu'il est utilisé, vous ne le faites même pas. besoin d'appeler le constructeur ou toute autre méthode ! Paramètres de méthode nommée et valeurs par défaut

// Java
void setStatus(String code) {
    setStatus(code, "");
}

void setStatus(String code, String desc) {
    this.code = code;
    this.desc = desc;
}

// Kotlin
fun setStatus(code: String, desc: String = "") {
    this.code = code;
    this.desc = desc;
}

fun execute() {
    setStatus("200")
    setStatus(code = "200", desc = "Ok")
}

Il arrive que tous les paramètres d'une méthode ou d'un constructeur ne soient pas obligatoires, et en Java, nous sommes habitués à créer un ensemble de méthodes ou de constructeurs pour chaque combinaison possible de paramètres. Des paramètres par défaut ont été introduits dans Kotlin, ce qui vous permet de déclarer 1 méthode et de lui transmettre l'ensemble de paramètres requis en fonction de la situation. Ruisseaux

// Java
String getFirst(List<String> strings, String alpha) {
    return strings.stream()
            .filter(x -> x.startsWith(alpha))
            .findFirst()
            .orElse("");
}

// Kotlin
fun getFirst(strings: List<String>, alpha: String): String {
    return strings.first { it.startsWith(alpha) }
}

L'introduction du flux dans Java 8 est devenue une fonctionnalité intégrale lorsque l'on travaille avec des collections. Dans Kotlin, les flux ont été rendus encore plus pratiques et fonctionnels : chaque collection dispose déjà d'un ensemble de méthodes pratiques et fréquemment utilisées pour travailler avec les données. Notez également l'expression lambda à l'intérieur de la première méthode : si une fonction littérale a exactement un paramètre, sa déclaration peut être supprimée (avec le ->) et  appelée . Il est temps de conclure... Je n'ai démontré qu'une petite partie basique des fonctionnalités, mais je suis sûr que vous voulez déjà essayer Kotlin ! De mon expérience, je peux tirer les conclusions suivantes :

• Il est très simple pour un développeur Java de maîtriser la syntaxe Kotlin et de commencer à écrire du code ;
• Kotlin est entièrement compatible avec Java et vous pouvez déjà l'essayer dans vos projets existants, par exemple lors de tests ;
• Le code Kotlin est plus propre et plus lisible, vous n’avez pas besoin d’écrire beaucoup de passe-partout ;
• IDEA dispose d'un convertisseur automatique Java vers Kotlin, vous pouvez prendre du code Java prêt à l'emploi et le convertir automatiquement en Kotlin ;
• un nouveau projet doit être écrit en Kotlin, car d'un point de vue infrastructure c'est la même chose que Java, mais en termes d'utilisation c'est mieux et plus pratique !

Si vous avez aimé l'article et que vous êtes généralement pertinent sur une ressource sur Java, je peux continuer à écrire sur l'expérience de l'utilisation de Kotlin dans un véritable projet d'entreprise. Liens utiles:

• Essayez d'écrire quelque chose dans Kotlin en ligne
• Learning Kotlin - un ensemble et une description de divers exemples interactifs
• Plugin pour IDEA pour la formation avec validation (comme mini-JavaRush)
• Site officiel de Kotlin
• Site russe Kotlin