[Mensuel 2017/04] Introduction à groovy !! ~ Comparaison de grammaire / spécification Java ~

Introduction! !!

Ouais! !! N'est-ce pas? ?? !! !! ?? !! !! !! !! Cela dit, j'aimerais continuer à apprendre le groovy. (Alors?) Eh bien, je suis un débutant, alors jetez un œil au contenu rudimentaire ww! !! (C'est la fin de l'étrange tension ...)

La motivation de l'apprentissage est d'améliorer l'activité Java à l'avenir. Je veux me sentir libre d'essayer la bibliothèque et de créer des outils.

Eh bien, si vous le faites, vous voulez tout faire depuis les bases, donc le contenu de cette fois-ci comprend principalement les spécifications linguistiques de groovy.

C'est mon premier post, donc je ne suis pas très doué (et je m'amuse ...) J'espère qu'il peut être lu d'une manière ou d'une autre.

Hello World!!

L'introduction est Hello World. Tout d'abord, nous allons commencer la comparaison à partir d'ici. Voir Hello World dans les deux langues ci-dessous.

java

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

/*production
Hello java!!
*/

groovy

System.out.println("Hello groovy!!"); //Identique à java. Mais ça marche.
System.out.println("Hello groovy!!")  //Fonctionne sans point-virgule.
System.out.println "Hello groovy!!";  // ()Arrêtons de le mettre.
System.out.println "Hello groovy!!"   // ;Arrêtons-nous en passant.
println "Hello groovy!!"              // The groovy.Cela peut être tellement simplifié.

/*production
Hello groovy!!
Hello groovy!!
Hello groovy!!
Hello groovy!!
Hello groovy!!
*/

Vous pouvez voir le sentiment de douceur du groovy (* je veux l'appeler liberté) avec cela seul. Il existe de nombreuses façons d'écrire uniquement la sortie avec la méthode println. Ce que j'aime personnellement, c'est que vous n'avez pas besoin d'écrire «System.out». Cela seul rend le code soigné.

Au contraire, en java, je ne vois aucune autre manière d'écrire. Il peut être plus facile à maintenir dans un projet avec un grand nombre de personnes, Groovy est bon pour les loisirs et la création d'outils simples.

Déclaration de type

De là, nous comparerons les variables. Puisqu'il est gênant de sortir avec println un par un, définissez disp () qui génère des variables sous la forme de [type: valeur]. Lisez le code en supposant que disp () est défini.

java

/**
 * [Moule:valeur]Arguments de sortie au format
 *
 * @variable variable param
 */
static void disp(Object variable) {
   System.out.println("[ " + variable.getClass().toString() + " : " + variable.toString() + " ]");
}

groovy

/**
 * [Moule:valeur]Arguments de sortie au format
 *
 * @variable variable param
 */
def disp(variable) {
    println "[ " + variable.class.toString() + " : ${variable} ]"
}

Oh, groovy est facile à écrire ...

Chaîne

java

public class Variable {
    public static void main(String[] args) {

        String jString = "java string";

        disp(jString);
    }
}

/*production
 * [ class java.lang.String : java string ]
 */

groovy

def gString = "groovy string"   //Déclaré avec def
def gString2 = "${gString}"     //Déclaré avec def. Dans la chaîne${variable}Incorporer

String jString = "java string"  //Déclaré comme type chaîne
String jString2 = "${jString}"  //Déclaré en tant que type String. Dans la chaîne${variable}Incorporer

def gString3 = """\
Première ligne
Deuxième ligne
Troisième ligne"""                       // """Représentez une chaîne de caractères sur plusieurs lignes en l'enveloppant.\Peut échapper aux sauts de ligne avec

def gString4 = 'groovy string' // 'Il est correct de l'enfermer dans

disp gString
disp gString2
disp jString
disp jString2

disp gString3
disp gString4

/*production
 * [ class java.lang.String : groovy string ]
 * [ class org.codehaus.groovy.runtime.GStringImpl : groovy string ]
 * [ class java.lang.String : java string ]
 * [ class java.lang.String : java string ]
 * [ class java.lang.String :Première ligne
 *Deuxième ligne
 *Troisième ligne]
 * [ class java.lang.String : groovy string ]
 */

Ce à quoi je veux faire attention dans le type String est le comportement lorsque$ {variable}est incorporé dans la chaîne de valeur. groovy étend la valeur de $ {variable} incluse dans `" ʻ dans la chaîne, mais le comportement change en fonction de la façon dont il est déclaré.

• Dans le cas d'une déclaration par def, la valeur de` $ {variable} ʻest utilisée comme référence, et lorsque la valeur de la variable développée change, elle est reflétée dans la chaîne de caractères.
• Dans le cas d'une déclaration par String, la valeur de la variable au moment de la déclaration est développée dans la chaîne de caractères, et même si la valeur de la variable change, elle n'est pas reflétée dans la chaîne de caractères.

En passant, il existe une notation pour l'évaluation des retards. Si vous donnez $ {-> variable} comme valeur dans le cas d'une déclaration par def, même si la destination de référence de la variable change, le changement de référence peut être reflété. Dans ce cas, il a la valeur de $ {variable} comme fermeture. La valeur de la variable renvoyée par la fermeture étant développée au moment de l'affichage, la valeur peut être reflétée même si la destination de référence change.

Exemple

def string = ["groovy string"]

String gStringValue = "${string}"     //Intégration de valeur
def gStringReference = "${string}"    //référence
def gStringLazy = "${-> string}"      //Évaluation des retards

string.add "changed"

disp gStringValue
disp gStringReference
disp gStringLazy
println()

string = "replaced"

disp gStringValue
disp gStringReference
disp gStringLazy

/*production
 * [ class java.lang.String : [groovy string] ]
 * [ class org.codehaus.groovy.runtime.GStringImpl : [groovy string, changed] ]
 * [ class org.codehaus.groovy.runtime.GStringImpl : [groovy string, changed] ]
 * 
 * [ class java.lang.String : [groovy string] ]
 * [ class org.codehaus.groovy.runtime.GStringImpl : [groovy string, changed] ]
 * [ class org.codehaus.groovy.runtime.GStringImpl : replaced ]
 */

Le comportement ci-dessus est affiché sous la forme d'une implémentation de type chaîne de caractères lors du référencement de variables et de l'exécution d'une évaluation de retard afin qu'il puisse être lu à partir du résultat de sortie. C'est parce que ʻorg.codehaus.groovy.runtime.GStringImpl` est utilisé. C'est une fonction très pratique si vous pouvez la maîtriser.

Valeur numérique

java

public class Variable {
    public static void main(String[] args) {

        int jInt = 1;                                                            // int
        long jLong = 100000000000000L;                                           //Est-ce du volume?
        BigInteger jBigInteger = new BigInteger("1000000000000000000000000000"); //C'est probablement le plus simple

        disp(jInt);
        disp(jLong);
        disp(jBigInteger);

        double jDouble = 1.212121;                            // double
        float jFloat = 1.212121F;                             //Est-ce une capacité électrostatique?
        BigDecimal jBigDecimal = new BigDecimal(1.212121);    //Si vous le transmettez avec une petite valeur numérique, une queue sera créée
        BigDecimal jBigDecimal2 = new BigDecimal("1.212121"); //C'est probablement le plus simple

        disp(jDouble);
        disp(jFloat);
        disp(jBigDecimal);
        disp(jBigDecimal2);
    }
}

/*production
 * [ class java.lang.Integer : 1 ]
 * [ class java.lang.Long : 100000000000000 ]
 * [ class java.math.BigInteger : 1000000000000000000000000000 ]
 * 
 * [ class java.lang.Double : 1.212121 ]
 * [ class java.lang.Float : 1.212121 ]
 * [ class java.math.BigDecimal : 1.2121210000000000039932501749717630445957183837890625 ]
 * [ class java.math.BigDecimal : 1.212121 ]
 */

groovy

def gInt = 1                                    //Convient à int
def gLong = 100000000000000                     //int ne correspond pas
def gBigInteger = 1000000000000000000000000000  //Ne rentre même pas dans Long

disp gInt
disp gLong
disp gBigInteger
println()

def gBigDecimal = 2.121212                     //Essayez d'en mettre quelques
double jDouble = 2.121212                      //Déclaré avec double
float jFloat = 2.121212                        //Déclaré avec flotteur

disp gBigDecimal
disp jDouble
disp jFloat

/*production
 * [ class java.lang.Integer : 1 ]
 * [ class java.lang.Long : 100000000000000 ]
 * [ class java.math.BigInteger : 1000000000000000000000000000 ]
 *
 * [ class java.math.BigDecimal : 2.121212 ]
 * [ class java.lang.Double : 2.121212 ]
 * [ class java.lang.Float : 2.121212 ]
 */

groovy est plutôt bon pour les nombres. Comme le code ci-dessus, dans le cas d'une valeur entière, les types de ʻintàBigInteger` sont automatiquement déterminés et gérés en fonction de la valeur assignée. S'il s'agit d'une valeur minoritaire, elle sera traitée comme «BigDecimal». Il est également intéressant de noter que même si vous transmettez une valeur minoritaire telle quelle, elle n'a pas de queue d'erreur comme java. Bien entendu, si vous spécifiez le type, il sera traité comme le type spécifié.

Autres types primitifs

java

public class Variable {
    public static void main(String[] args) {

        char aznable = 'c';    //Comète rouge
        disp(aznable);

        boolean jBool = true; //type booléen
        disp(jBool);
    }
}

/*production
 * [ class java.lang.Character : c ]
 * [ class java.lang.Boolean : true ]
 */

groovy

def gChar = 'c'
def gChar2 = 'c' as char
def gChar3 = 'c' as String
char gChar4 = 'c'

disp gChar
disp gChar2
disp gChar3
disp gChar4

/*production
 * [ class java.lang.String : c ]
 * [ class java.lang.Character : c ]
 * [ class java.lang.String : c ]
 * [ class java.lang.Character : c ]
 */


def gBool = true
def gBool2 = "true" as boolean
boolean gBool3 = true
boolean gBool4 = "true"

disp gBool
disp gBool2
disp gBool3
disp gBool4

/*production
 * [ class java.lang.Boolean : true ]
 * [ class java.lang.Boolean : true ]
 * [ class java.lang.Boolean : true ]
 * [ class java.lang.Boolean : true ]
 */

char Il n'y a pas de notation littérale (valeur) de type char dans groovy. Si vous voulez traiter un caractère comme un type char, vous devez affecter le littéral String à une variable déclarée comme type char, ou le spécifier comme type char avec le mot-clé ʻas`. De plus, bien qu'il ne soit pas dans le code ci-dessus, il peut être casté avec (char) et traité comme un type «char».

boolean Pour boolean, suivez le code ci-dessus. (Ce n'est pas une omission. Je n'ai rien à écrire)

Liste et tableau et plage

A partir de là, ça devient ennuyeux ~~ S'il n'y a pas besoin de comparer, je posterai seulement le code groovy. «N'est-ce pas un gros problème jusqu'à maintenant? Ne dis pas ça. Voici un exemple.

groovy

def list = [1, 2, 3]
def linkedList = [1, 2, 3] as LinkedList
LinkedList linkedList2 = [1, 2, 3]

def array = [1, 2, 3] as int[]

def range = 1..3

disp list
disp linkedList
disp linkedList2
disp list[0]
println()
disp array
disp array[0]
println()
disp range
disp range[0]

/*production
 * [ class java.util.ArrayList : [1, 2, 3] ]
 * [ class java.util.LinkedList : [1, 2, 3] ]
 * [ class java.util.LinkedList : [1, 2, 3] ]
 * [ class java.lang.Integer : 1 ]
 *
 * [ class [I : [1, 2, 3] ]
 * [ class java.lang.Integer : 1 ]
 *
 * [ class groovy.lang.IntRange : [1, 2, 3] ]
 * [ class java.lang.Integer : 1 ]
 */

Le tableau List et Range peuvent obtenir des éléments avec la même syntaxe. Facile. Cependant, le nom de classe du tableau semble désordonné. Au fait, la classe du tableau int était [I, le tableau volumique était [Z, et String était[Ljava.lang.String;. C'est un peu désagréable ...

Map

groovy

def map = [ name : "Ponta", age : 20, attend : true]
def hashMap = [ name : "Ponta", age : 20, attend : true] as HashMap
TreeMap treeMap = [ name : "Ponta", age : 20, attend : true]

disp map
disp hashMap
disp treeMap
println()
println map.getClass()
println hashMap.getClass()
println treeMap.getClass()
println()
disp map.name
disp map.age
disp map.attend
println()
disp map["name"]
disp map."name"

/*production
 * [ null : [name:Ponta, age:20, attend:true] ]
 * [ null : [name:Ponta, age:20, attend:true] ]
 * [ null : [age:20, attend:true, name:Ponta] ]
 *
 * class java.util.LinkedHashMap
 * class java.util.LinkedHashMap
 * class java.util.TreeMap
 *
 * [ class java.lang.String :Ponta]
 * [ class java.lang.Integer : 20 ]
 * [ class java.lang.Boolean : true ]
 *
 * [ class java.lang.String :Ponta]
 * [ class java.lang.String :Ponta]
 * [ class java.util.ArrayList : [true, 12, string] ]
 * [ class java.lang.Boolean : true ]
 * [ class java.lang.Integer : 12 ]
 * [ class java.lang.String : string ]
 */

Au moment où j'ai vu la sortie, j'ai été très surpris. Parce que la classe est nulle. Je pensais que c'était définitivement un bug, mais quand je l'ai recherché, c'était une spécification. Pour expliquer cela, il faut connaître les spécifications de deux groovy.

• Vous pouvez appeler le getter d'un objet avec la syntaxe pour accéder au champ. (Vous pouvez appeler ʻObject # getClass () avec ʻObject.class)
• Vous pouvez appeler la valeur de l'objet Map avec la syntaxe pour accéder au champ. (Si la clé est nom, vous pouvez l'appeler avec map.name)

Il semble que ce malheur ait été causé par la résolution du conflit de spécification ci-dessus en donnant la priorité à cette dernière. (Null est retourné lors de l'accès à une clé qui n'existe pas) J'ai pu obtenir la classe en appelant correctement getClass (). ~~ Tous ** LinkedHashMap **, mais ... Est-ce une spécification de langage? Je n'ai pas vraiment compris ici ... ~~ Ce qui précède était dû à une erreur dans la variable affichée (tout map ou embarrassant) Merci, @uehaj.

En passant, groovy peut également accéder aux champs, etc. sous la forme de map." Name ". Si vous le combinez avec $ {variable}, vous pouvez faire de la magie noire légère.

Résumé

** java est un langage typé statiquement ** et ** groovy est un langage typé dynamiquement **. java doit spécifier le type de la variable lors de la déclaration de la variable, groovy est OK avec def. Si vous déclarez une variable avec def, le type change dynamiquement en fonction du littéral (valeur) stocké dans la variable. Cependant, groovy vous permet également de déclarer des types de manière statique. De plus, comme dans l'exemple String, groovy fournit un typage dynamique assez flexible, comme l'écriture de littéraux.

Environnement de vérification

Groovy-2.4.10 jdk1.8.0_60 IntelliJ IDEA Community Edition 2017.1.2

Site de référence

http://groovy-lang.org https://www.slideshare.net/nobeans/javagroovy http://npnl.hatenablog.jp/entry/20100605/1275736594 http://qiita.com/abey1192/items/661766fb728fd9b872e2 http://qiita.com/opengl-8080/items/46790e2292cdd0beb1af

P.S Cela n'a pas d'importance, mais IntelliJ IDEA était foiré et facile à utiliser.