[JAVA] Pourquoi Kotlin est si pratique

Contexte de cet article

https://qiita.com/ngsmvn/items/b74328291d0b5342e407

Pour ceux qui sont trop longs et ne veulent pas lire, chaque section a un résumé, afin que vous puissiez comprendre le but par lui-même.

Pourquoi Kotlin est si pratique

En un mot, la raison pour laquelle Kotlin est si utile est ** parce que c'est une bonne correspondance pour d'autres langues **.

Un livre écrit par le développeur de Kotlin appelé Kotlin in Action dit:

We aren’t trying to advance the state of the art in programming language design and explore innovative ideas in computer science. Instead, whenever possible, we’re relying on features and solutions that have already appeared in other programming languages and have proven to be successful.

(Ma traduction)

Nous n'essayons pas de relever la barre des langages de programmation ou d'explorer des idées innovantes en informatique. Au lieu de cela, nous nous appuyons autant que possible sur des fonctionnalités et des solutions qui sont déjà dans d'autres langages de programmation et dont nous savons qu'elles fonctionneront.

Vous pouvez voir que c'est pratique et qu'il essaie activement d'incorporer les bons points des langages de programmation existants.

Points utiles spécifiques

Je pense qu'il y a beaucoup d'autres choses, mais je vais me concentrer sur les trois points suivants.

1. "Flexible" et "concis" bien qu'il soit typé statiquement
2. "Transparence de référence" tirée d'un langage fonctionnel
3. Puisqu'il fonctionne sur la JVM (décrit plus loin), «écrivez une fois, exécutez partout»

"Concision" et "flexibilité" des langues à typage dynamique

Résumé de cette section: Les langages typés statiquement donnent beaucoup d'informations sur un programme à l'ordinateur afin que les erreurs dans le programme puissent être trouvées rapidement. C'est ennuyeux d'écrire à la place. Kotlin est un langage à typage statique qui est simple et flexible à écrire

Avez-vous déjà eu une faute de frappe lorsque vous pensiez qu'un programme écrit en JavaScript ou PHP ne fonctionnerait pas? Des erreurs simples seraient plus faciles si votre ordinateur pouvait les trouver.

Un langage de type statique est un langage qui détecte des erreurs telles que des fautes d'orthographe et différents types de données avant l'exécution. Inversement, JavaScript et PHP sont appelés langages à typage dynamique. Les deux diffèrent dans le moment où le type (type de données) est déterminé.

--Dynamique → Déterminé lorsque le programme est exécuté

• Les incohérences de données sont introuvables avant l'exécution --Statique → Déterminé avant d'exécuter le programme
• Des incohérences de données peuvent être trouvées avant l'exécution

Si vous trouvez une erreur, vous devez toujours utiliser un langage typé statiquement, n'est-ce pas? Mais ce n'est pas le cas. Comparons les programmes qui produisent des chaînes de caractères.

--JavaScript (typage dynamique)

alert("JavaScript");

--PHP (typage dynamique)

echo "PHP";

--Java (typage statique)

public class Main {
    public static void main(String[] args){
        System.out.println("Java");
    }
}

Vous avez juste besoin d'écrire autant, même si vous voulez simplement afficher la chaîne. Chaque langage à typage statique et langage à typage dynamique a ses avantages et ses inconvénients.

Ce serait formidable s'il y avait un langage typé statiquement qui pourrait être écrit de manière concise et flexible. Cela signifie que Kotlin est le plus fort.

fun main() = println("Kotlin") //Bien qu'il soit typé statiquement, il peut être écrit de manière concise!!

Grâce à l'apprentissage des erreurs d'autres langages de programmation et à l'apprentissage des bons points, je suis capable d'écrire de manière aussi concise que les langages à typage dynamique existants.

Kotlin dispose de nombreuses fonctionnalités pour écrire de manière concise et flexible. ** Je ne peux pas tout vous montrer, alors google **

Qiita a un bon article. (Lancement)

--Inférence de type --Fonction d'extension --Fonction locale

• Fonction de portée --Fonction de correction (infixe)
• Retour local
• Argument par défaut
• Arguments nommés --Classe de données --Traitement sur listes (sumBy, groupBy, fold, first, drop ...) --Fonction d'ordre supérieur

"Transparence de référence" des langages fonctionnels

Résumé de cette section: Lorsque diverses valeurs changent, il est difficile de réfléchir davantage. Kotlin, qui imite le langage fonctionnel et son mécanisme, peut être écrit de manière à ce que la valeur ne puisse pas être réécrite.

La transparence de référence est la propriété que si l'entrée est la même, le résultat de l'exécution de la fonction sera le même. L'avez-vous pris pour acquis? Considérez maintenant l'exemple suivant.

Supposons que vous déposiez une facture de 1000 yens dans un distributeur automatique et que vous appuyiez sur le bouton de café de 100 yens. Les produits et les changements qui en découlent sont-ils toujours les mêmes?

S'il est épuisé, le café ne sortira pas, et le changement sera de 500 yens et 100 yens, ou tous les 100 yens. Si vous remplacez cet exemple par un programme

--Insérez un billet de 1000 yens → Entrez --Appuyez sur le bouton → Appelez la fonction

• Modifications et produits qui sortent → Sortie
• ** Produits et pièces dans le distributeur automatique → État **

Ce que je voulais transmettre dans cet exemple, c'est que ** si l'état change, la sortie changera **. C'est ennuyeux de programmer en pensant à chaque état. En premier lieu, si l’état ne change pas, il n’ya pas lieu d’y penser.

Ainsi, dans un langage purement fonctionnel, la transparence des références est obtenue en ne réécrivant pas l'état de l'objet.

Par exemple, Haskell ne peut pas faire cela. (C'est un pseudo code, donc ce n'est pas un bon Haskell.)

--Liste des langages de programmation disponibles
let skillSet = ["JavaScript", "PHP"]
--Depuis que j'ai participé à la session d'étude, je peux utiliser Kotlin.
skillSet push "Kotlin" --← Ne peut être ajouté à la liste
for (let i = 0; i < skillSet size; i++){ --← La variable de boucle ne peut pas être incrémentée de 1
    --Fier des langages de programmation utilisables
    putStrLn skillSet !! i ++ "Peut être utilisé!!"
}
--Je n'ai pas écrit le code pendant un moment, donc j'ai tout oublié
skillSet = [] --← Ne peut pas être réaffecté. Ou plutôt, cela s'appelle liaison au lieu de substitution
--

Kotlin adopte partiellement cette idée pour faire la distinction entre les objets réinscriptibles (objets mutables) et les objets non réinscriptibles (objets immuables).

--Bouge toi

//Liste des langages de programmation disponibles
var skillSet = mutableListOf("JavaScript", "PHP") //Attribuer une liste mutable à une variable qui peut être réaffectée
//Depuis que j'ai participé à la session d'étude, je peux utiliser Kotlin.
skillSet.add("Kotlin")
for (i in 0 until skillSet.size){
    //Fier des langages de programmation utilisables
    println("${skillSet[i]}Peut être utilisé")
}
//Je n'ai pas écrit le code pendant un moment, donc j'ai tout oublié
skillSet = mutableListOf()

• Ça ne marche pas

//Liste des langages de programmation disponibles
val skillSet = listOf("JavaScript", "PHP") //Attribuer une liste immuable à une variable qui ne peut pas être réaffectée
//Depuis que j'ai participé à la session d'étude, je peux utiliser Kotlin.
skillSet.add("Kotlin") //← Cela ne peut pas être fait
for (i in 0 until skillSet.size){
    //Fier des langages de programmation utilisables
    println("${skillSet[i]}Peut être utilisé")
}
//Je n'ai pas écrit le code pendant un moment, donc j'ai tout oublié
skillSet = listOf() //← Je ne peux pas faire ça non plus

Outre la transparence des références, il semble que les langages fonctionnels soient influencés par des fonctions et des opérations d'ordre supérieur sur les listes.

Java "écrire une fois, exécuter partout (écrire une fois, exécuter partout)"

Résumé de cette section: Java peut être exécuté sur n'importe quel système d'exploitation, tout comme Kotlin, qui imite le fonctionnement de Java.

Langage de compilation et langage d'interprétation

Kotlin est fortement influencé par le langage Java. Pour expliquer pourquoi Kotlin est si génial, nous devons expliquer pourquoi Java est si génial. Je vais faire un petit détour, mais à la fin cela mènera à l'histoire de Kotlin, alors suivez-moi s'il vous plaît.

Il existe deux principaux types de langages de programmation. Un langage de compilation et un langage d'interprétation.

Je ne me souviens pas où j'ai entendu la métaphore, mais c'est comme écrire une lettre à un ordinateur.

"Veuillez me montrer la page Web" "Veuillez me montrer la valeur de la base de données" "Veuillez envoyer un e-mail à cette personne" Je pense qu'il y a plusieurs demandes, mais j'écrirai la demande dans une lettre et je l'enverrai à l'ordinateur. La lettre est le programme et le langage utilisé pour écrire le programme est le langage de programmation.

L'ordinateur ne connaît pas le langage de programmation. L'ordinateur ne connaît que l'actuel ON / OFF. Un mot lisible par ordinateur qui représente ON / OFF avec les nombres 0 et 1 est appelé un langage machine.

Il existe deux manières principales de faire lire une lettre à un ordinateur (= exécuter un programme).

1. Traduire toutes les lettres en langage machine à l'avance avant de les envoyer
2. À côté de la lecture de l'ordinateur, expliquez la signification ligne par ligne

Le premier est le langage du compilateur et le second est le langage d'interprétation.

Le langage du compilateur présente des avantages tels qu'une vitesse d'exécution rapide et moins de souci d'imiter des lettres par d'autres personnes (car les humains ne comprennent pas le langage machine), mais il y a quelques problèmes.

Votre lettre dépend du système d'exploitation

Dans les langages de compilation pré-Java, les programmes dépendaient du système d'exploitation. La dépendance à l'OS signifie qu'il était nécessaire de développer et de tester chaque OS. À quoi sert le système d'exploitation en premier lieu?

L'ordinateur doit (bien sûr) utiliser son propre matériel pour effectuer le travail. Supposons que vous ayez besoin d'écrire un programme détaillé sur le matériel, tel que "Afficher les fichiers enregistrés à cet emplacement sur le disque". Que faire si vous souhaitez acheter un nouvel ordinateur ou exécuter votre programme sur l'ordinateur d'un ami?

Bien sûr, la conception et les pièces de l'ordinateur sont différentes, je dois donc réécrire le programme. C'est ennuyeux, non?

Le système d'exploitation se charge d'accéder au matériel de l'ordinateur afin que le programmeur n'ait pas à le toucher directement. Grâce au système d'exploitation, il n'est pas nécessaire de programmer directement sur le matériel.

Le point de contact où le logiciel demande "OS-kun, veuillez accéder au matériel avec un bon feeling" est appelé API. Étant donné que l'API est différente pour chaque système d'exploitation, le programme changera si le système d'exploitation est différent. C'est plus facile que d'accéder directement au matériel, mais cela a toujours l'ennui de gérer les différences entre les systèmes d'exploitation.

La machine virtuelle Java (JVM) a résolu ce problème.

JVM

Une JVM est une machine virtuelle Java. Une machine virtuelle qui s'exécute comme un environnement d'exécution Java. Une machine virtuelle est un logiciel qui prétend être un ordinateur utilisant le matériel d'un ordinateur réel. Il existe de nombreux types autres que JVM.

La JVM fournit des API pour les programmes Java. Cette API est volontairement limitée aux fonctions communes aux différents OS.

Dans l'analogie de la lettre ci-dessus, écrire une lettre en Java remplace le langage machine par un langage intermédiaire qui comprend la JVM. Il sera traduit dans un langage machine avec un bon feeling en fonction de l'OS sur lequel la JVM est installée.

Au lieu de toucher directement le matériel, le logiciel a pu absorber la différence de matériel en passant par le système d'exploitation. De la même manière, vous pouvez absorber la différence entre les systèmes d'exploitation en passant par la JVM au lieu d'accéder directement au système d'exploitation.

C'est "écrire une fois, exécuter partout" préconisé par Sun Microsystems, le créateur de Java. Une fois écrit, vous pouvez utiliser le programme sans avoir à être conscient des différences de système d'exploitation. Ce n'est plus ennuyeux ... ce n'était pas le cas.

Java en tant qu'environnement d'exécution est excellent, mais Java en tant que langage de programmation a une syntaxe longue et est très ennuyeux.

Une entreprise en République tchèque, qui était dégoûtée par "Puis-je créer un IDE comme celui-ci!", A créé un langage de programmation moderne qui fonctionne sur JVM. C'est Kotlin. C'est la bonne chose à propos de la JVM qui réalise "écrire une fois, exécuter partout".

J'ai résumé dans mes propres mots pourquoi Kotlin est si utile.

Matériel de référence

Kotlin In Action [Pourquoi le faire avec Java](https://www.amazon.co.jp/Java%E3%81%A7%E3%81%AA%E3%81%9C%E3%81%A4%E3%81% 8F% E3% 82% 8B% E3% 81% AE% E3% 81% 8B-% E7% 9F% A5% E3% 81% A3% E3% 81% A6% E3% 81% 8A% E3% 81% 8D % E3% 81% 9F% E3% 81% 84Java% E3% 83% 97% E3% 83% AD% E3% 82% B0% E3% 83% A9% E3% 83% 9F% E3% 83% B3% E3 % 82% B0% E3% 81% AE% E5% 9F% BA% E7% A4% 8E% E7% 9F% A5% E8% AD% 98-% E7% B1% B3% E6% 8C% 81-% E5 % B9% B8% E5% AF% BF / dp / 4822281965)