[Monatlich 2017/04] Einführung in groovy !! ~ Java Grammatik / Spezifikationsvergleich ~

Einführung! !!

Ja! !! Ist es nein? ?? !! !! ?? !! !! !! !! Vor diesem Hintergrund möchte ich weiterhin groovig lernen. (Damit?) Nun, ich bin ein Anfänger, also schauen Sie sich bitte den rudimentären Inhalt ww an! !! (Dies ist das Ende der seltsamen Spannung ...)

Die Motivation zum Lernen besteht darin, die Java-Aktivität in Zukunft zu verbessern. Ich möchte die Bibliothek ausprobieren und Werkzeuge erstellen.

Nun, wenn Sie es tun, möchten Sie alles von den Grundlagen aus tun, so dass der Inhalt dieses Mal hauptsächlich die Sprachspezifikationen von groovy erfasst.

Es ist mein erster Beitrag, also bin ich nicht sehr gut darin (und ich mache rum ...) Ich hoffe es kann irgendwie gelesen werden.

Hello World!!

Die Einführung ist Hello World. Zunächst beginnen wir hier mit dem Vergleich. Siehe Hallo Welt in beiden Sprachen unten.

java

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

/*Ausgabe
Hello java!!
*/

groovy

System.out.println("Hello groovy!!"); //Gleich wie Java. Aber es funktioniert.
System.out.println("Hello groovy!!")  //Funktioniert ohne Semikolon.
System.out.println "Hello groovy!!";  // ()Hören wir auf, es anzuziehen.
System.out.println "Hello groovy!!"   // ;Lass uns übrigens aufhören.
println "Hello groovy!!"              // The groovy.Es kann so sehr vereinfacht werden.

/*Ausgabe
Hello groovy!!
Hello groovy!!
Hello groovy!!
Hello groovy!!
Hello groovy!!
*/

Sie können das groovige Gefühl (* Ich möchte es Freiheit nennen) sehen, indem Sie dies einfach tun. Es gibt viele Möglichkeiten, nur die Ausgabe mit der println-Methode zu schreiben. Was mir persönlich gefällt ist, dass Sie nicht "System.out" schreiben müssen. Dies allein lässt den Code ordentlich aussehen.

Im Gegenteil, in Java fällt mir keine andere Schreibweise ein. Es kann einfacher sein, in einem Projekt mit einer großen Anzahl von Personen zu warten. Groovy ist gut für Hobbys und einfache Werkzeuge.

Typdeklaration

Von hier aus werden wir Variablen vergleichen. Da die Ausgabe mit println nacheinander schwierig ist, definieren Sie disp (), das Variablen in Form von [type: value] ausgibt. Lesen Sie den Code unter der Annahme, dass disp () definiert ist.

java

/**
 * [Schimmel:Wert]Ausgabeargumente im Format
 *
 * @param variable variable
 */
static void disp(Object variable) {
   System.out.println("[ " + variable.getClass().toString() + " : " + variable.toString() + " ]");
}

groovy

/**
 * [Schimmel:Wert]Ausgabeargumente im Format
 *
 * @param variable variable
 */
def disp(variable) {
    println "[ " + variable.class.toString() + " : ${variable} ]"
}

Oh, groovig ist einfach zu schreiben ...

String

java

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

        String jString = "java string";

        disp(jString);
    }
}

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

groovy

def gString = "groovy string"   //Mit def deklariert
def gString2 = "${gString}"     //Mit def deklariert. In der Zeichenfolge${Variable}Einbetten

String jString = "java string"  //Als String-Typ deklariert
String jString2 = "${jString}"  //Als String-Typ deklariert. In der Zeichenfolge${Variable}Einbetten

def gString3 = """\
Erste Linie
Zweite Reihe
Dritte Zeile"""                       // """Stellen Sie eine mehrzeilige Zeichenfolge dar, indem Sie sie einschließen.\Kann Zeilenumbrüchen mit entkommen

def gString4 = 'groovy string' // 'Es ist in Ordnung, es einzuschließen

disp gString
disp gString2
disp jString
disp jString2

disp gString3
disp gString4

/*Ausgabe
 * [ 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 :Erste Linie
 *Zweite Reihe
 *Dritte Zeile]
 * [ class java.lang.String : groovy string ]
 */

Was ich im Typ "String" beachten möchte, ist das Verhalten, wenn "$ {variable}" in den Wert "string" eingebettet ist. groovy erweitert den Wert von $ {variable} in `` in den String, aber das Verhalten ändert sich je nachdem, wie es deklariert wird.

• Bei der Deklaration durch "def" wird der Wert von "$ {variable}" als Referenz verwendet. Wenn sich der Wert der erweiterten Variablen ändert, wird er in der Zeichenfolge wiedergegeben.
• Bei der Deklaration durch "String" wird der Variablenwert zum Zeitpunkt der Deklaration in der Zeichenfolge erweitert, und selbst wenn sich der Variablenwert ändert, wird er nicht in der Zeichenfolge wiedergegeben.

Nebenbei gibt es eine Notation für die Verzögerungsbewertung. Wenn Sie bei der Deklaration durch "def" "$ {-> variable}" als Wert angeben, kann die Änderung der Referenz auch dann wiedergegeben werden, wenn sich das Referenzziel der Variablen ändert. In diesem Fall hat es den Wert "$ {variable}" als Abschluss. Da der Wert der vom Abschluss zurückgegebenen Variablen zum Zeitpunkt der Anzeige erweitert wird, kann der Wert auch dann wiedergegeben werden, wenn sich das Referenzziel ändert.

Beispiel

def string = ["groovy string"]

String gStringValue = "${string}"     //Werteinbettung
def gStringReference = "${string}"    //Referenz
def gStringLazy = "${-> string}"      //Verzögerungsauswertung

string.add "changed"

disp gStringValue
disp gStringReference
disp gStringLazy
println()

string = "replaced"

disp gStringValue
disp gStringReference
disp gStringLazy

/*Ausgabe
 * [ 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 ]
 */

Das obige Verhalten wird als Implementierung eines Zeichenkettentyps gezeigt, wenn auf Variablen verwiesen und eine Verzögerungsbewertung durchgeführt wird, damit es aus dem Ausgabeergebnis gelesen werden kann. Dies liegt daran, dass "org.codehaus.groovy.runtime.GStringImpl" verwendet wird. Es ist eine sehr praktische Funktion, wenn Sie sie beherrschen können.

Numerischer Wert

java

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

        int jInt = 1;                                                            // int
        long jLong = 100000000000000L;                                           //Ist es Volumen?
        BigInteger jBigInteger = new BigInteger("1000000000000000000000000000"); //Dies ist wahrscheinlich die einfachste

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

        double jDouble = 1.212121;                            // double
        float jFloat = 1.212121F;                             //Ist es elektrostatische Kapazität?
        BigDecimal jBigDecimal = new BigDecimal(1.212121);    //Wenn Sie es mit einem kleinen Zahlenwert übergeben, wird ein Schwanz erstellt
        BigDecimal jBigDecimal2 = new BigDecimal("1.212121"); //Dies ist wahrscheinlich die einfachste

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

/*Ausgabe
 * [ 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                                    //Passt in int
def gLong = 100000000000000                     //int passt nicht
def gBigInteger = 1000000000000000000000000000  //Passt nicht mal in Long

disp gInt
disp gLong
disp gBigInteger
println()

def gBigDecimal = 2.121212                     //Versuchen Sie, ein paar zu setzen
double jDouble = 2.121212                      //Mit double deklariert
float jFloat = 2.121212                        //Mit float deklariert

disp gBigDecimal
disp jDouble
disp jFloat

/*Ausgabe
 * [ 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 ]
 */

groovig ist ziemlich gut im Umgang mit Zahlen. Wie der obige Code werden bei ganzzahligen Werten die Typen von "int" bis "BigInteger" automatisch bestimmt und entsprechend dem zugewiesenen Wert behandelt. Wenn es sich um einen Minderheitswert handelt, wird er als "BigDecimal" behandelt. Es ist auch attraktiv, dass selbst wenn Sie einen Minderheitswert so wie er ist übergeben, er keinen Fehlerschwanz wie Java aufweist. Wenn Sie den Typ angeben, wird er natürlich als der angegebene Typ behandelt.

Andere primitive Typen

java

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

        char aznable = 'c';    //Roter Komet
        disp(aznable);

        boolean jBool = true; //Boolescher Typ
        disp(jBool);
    }
}

/*Ausgabe
 * [ 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

/*Ausgabe
 * [ 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

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

char In groovy gibt es keine Literal-Notation (Wert) vom Typ "char". Wenn Sie ein Zeichen als "char" -Typ behandeln möchten, müssen Sie das "String" -Literal einer als "char" -Typ deklarierten Variablen zuweisen oder es mit dem Schlüsselwort "as" als "char" -Typ angeben. Auch wenn es nicht im obigen Code enthalten ist, kann es mit (char) umgewandelt und als "char" -Typ behandelt werden.

boolean Folgen Sie für boolean dem obigen Code. (Es ist keine Unterlassung. Ich habe nichts zu schreiben)

Liste & Array & Bereich

Von hier an wird es nervig ~~ Wenn es wenig Vergleichbarkeit gibt, werde ich nur den groovigen Code posten. "Ist es nicht eine große Sache bis jetzt? Sag das nicht. Unten ist ein Beispiel.

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]

/*Ausgabe
 * [ 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 ]
 */

Sowohl List-Arrays als auch Ranges können Elemente mit derselben Syntax abrufen. Einfach. Der Klassenname des Arrays sieht jedoch unordentlich aus. Übrigens war die Klasse des int-Arrays "[I", das volumean Array "[Z" und der String "[Ljava.lang.String;". Es ist irgendwie unangenehm ...

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"

/*Ausgabe
 * [ 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 ]
 */

In dem Moment, als ich die Ausgabe sah, war ich am meisten überrascht. Weil die Klasse null ist. Ich dachte, dies sei definitiv ein Fehler, aber als ich ihn nachschlug, war es eine Spezifikation. Um dies zu erklären, müssen wir die Spezifikationen von zwei Groovy kennen.

• Sie können den Getter eines Objekts mit der Syntax aufrufen, um auf das Feld zuzugreifen. (Object # getClass () kann mit Object.class aufgerufen werden)
• Sie können den Wert des Map-Objekts mit der Syntax aufrufen, um auf das Feld zuzugreifen. (Wenn der Schlüssel name ist, können Sie ihn mit map.name aufrufen.)

Es scheint, dass dieses Unglück durch die Lösung des oben genannten Spezifikationskonflikts verursacht wurde, indem letzterem Vorrang eingeräumt wurde. (Beim Zugriff auf einen nicht vorhandenen Schlüssel wird Null zurückgegeben.) Ich konnte die Klasse erhalten, indem ich getClass () richtig aufrief. ~~ Alle ** LinkedHashMap **, aber ... Ist es eine Sprachspezifikation? Ich habe es hier nicht wirklich verstanden ... ~~ Das obige war auf einen Fehler in der angezeigten Variablen zurückzuführen (alle "Karte" oder peinlich) Vielen Dank, @uehaj.

Nebenbei bemerkt kann groovy auch auf Felder usw. in Form von "map" "Name" "zugreifen. Wenn Sie es mit $ {variable} kombinieren, können Sie hellschwarze Magie anwenden.

Zusammenfassung

** Java ist eine statisch typisierte Sprache ** und ** Groovy ist eine dynamisch typisierte Sprache **. Java muss den Typ der Variablen angeben, wenn die Variable deklariert wird. groovy ist OK mit def. Wenn Sie eine Variable mit "def" deklarieren, ändert sich der Typ dynamisch in Abhängigkeit von dem in der Variablen gespeicherten Literal (Wert). Mit groovy können Sie jedoch auch Typen statisch deklarieren. Darüber hinaus verwendet groovy wie im Beispiel von String eine ziemlich flexible dynamische Typisierung, z. B. das Schreiben von Literalen.

Überprüfungsumgebung

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

Referenzseite

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 Es spielt überhaupt keine Rolle, aber IntelliJ IDEA war durcheinander und einfach zu bedienen.