[RAILS] Hello World, une application d'interface graphique multiplateforme avec Groovy fonctionnant sur la plate-forme Java

Qu'est-ce que Groovy

Un langage de script qui s'exécute sur Java. C'est le résultat de l'ajout des fonctions nécessaires à Java.

Installation rapide Groovy

Pour les fenêtres

1. Sinon, installez JDK (Java SE Development Kit).
2. Téléchargez le programme d'installation à partir du site groovy. Au moment de la rédaction de cet article, Groovy 2.4 était la dernière version stable.
3. Exécutez le programme d'installation.
4. Si la variable d'environnement Groovy est introuvable dans votre PATH, ajoutez-la. (Le programme de désinstallation ne supprime pas ces informations) Un avertissement s'affiche si JAVA_HOME n'est pas défini. Sans cela, Groovy ne fonctionnera pas correctement. Si vous recevez un avertissement, vérifiez que le JDK n'est peut-être pas installé.
5. L'installation est terminée lorsque "Démarrer Groovy Console" s'affiche dans le menu Démarrer.

Hello Groovy World

1. Démarrez GroovyConsole.
2. Écrivez le script suivant en haut de l'écran (zone de description du script). println("HelloWorld");
3. Appuyez sur le bouton ** Exécuter GroovyScript ** ou ** Ctrl + R ** pour exécuter le script.
4. Succès si * Hello World * est affiché comme résultat de l'exécution en bas de l'écran.

Essayez également GUI (AWT Frame). Ci-dessous se trouve l'écran d'exécution de Hello Groovy World (AWT).

Exemple) HelloGroovyWorld(AWT)

/* Hello World (GUI)scénario*/
import java.awt.*;
import java.awt.event.*;

/**
 *Classe MainFrame
 */
class MainFrame extends Frame
{
  def _menuBar;
  def _labelBody;

 /**
  *constructeur
  */
  MainFrame() {

    /*Initialiser le titre*/
    setTitle("Hello World")

    /*Menu Initialiser*/
    _menuBar = new MenuBar();
    def _menu = new Menu("Fichier");
    def _menuItem = new MenuItem("Fermer");
    _menuItem.addActionListener(new java.awt.event.ActionListener()
    {
        public void actionPerformed(ActionEvent e) {
            closeFrame(e);
        }
    });
    _menu.add(_menuItem);
    _menuBar.add(_menu);
    setMenuBar(_menuBar);

    /*Initialiser le contenu d'affichage dans le cadre*/
    _labelBody = new Label("Hello World");
    this.add(_labelBody);

    /*Initialiser la taille*/
    setSize(new Dimension(300, 200));
  }

  /*Opération de fermeture de cadre*/
  def closeFrame(e)
  {
    this.dispose();
  }
}

/*Point d'accès*/
new MainFrame().show();

Fonctionnalités Groovy pour Java

Référence: Apache Groovy - Différences avec Java Référence: Code Zine - Quel genre de langage est Groovy? Introduction à Groovy pour les programmeurs Java

• Certains des packages de classe couramment utilisés sont importés par défaut, vous pouvez donc les utiliser sans les déclarer.

• java.io.*, java.lang.*, java.math.BigDecimal, java.math.BigInteger, java.net.*, java.util.*, groovy.lang.*, groovy.util.* --Multi-méthode (ou répartition à l'exécution) vous permet de définir des méthodes avec le même nom de méthode et le même type de retour, mais avec des types d'arguments différents. Pour ceux-ci, la méthode à exécuter est sélectionnée en fonction du type d'argument donné au moment de l'exécution. * Je ne sais pas dans quel cas c'est pratique.

• Vous pouvez utiliser la fermeture.

• Les fermetures peuvent accepter des arguments. L'argument est implicitement représenté par l'argument formel ** it **. Il peut également être spécifié explicitement. clodure = {println (" $ {it} a réussi. ");}; Clodure (" test ");, clodure = {nom, âge-> println (" $ {nom} est $ {âge " } Je suis vieux. ");}; Clodure (" Alice ", 10); --Closer peut être spécifié comme argument. Par conséquent, en le donnant à un argument tel que chaque méthode, l'accès à tous les éléments du tableau peut être facilement décrit sans utiliser la syntaxe de contrôle. somme = 0; (1..10) .chaque {somme + = it}; println (somme);

• Les fermetures peuvent accéder aux variables de la classe déclarée. Par conséquent, l'opération événementielle peut être facilement définie.

• Le format d'initialisation du tableau est différent. (Parce que {} est réservé par la fermeture) ʻint [] array = [1,2,3]; `

• Si le contrôleur d'accès est omis lors de la définition des variables, il sera reconnu comme un champ privé et Getter / Setter sera automatiquement défini. Si vous souhaitez le définir comme un package privé valide dans le package, décrivez @PackageScope. (Il est écrit comme privé, mais il semble que l'accès ne soit pas contrôlé)

• Les noms de méthode de Getter / Setter sont getXXX () et setXXX (). * Si une erreur se produit avec un nom de méthode que vous n'avez pas déclaré au moment de la compilation, ce problème peut en être la cause.

• La gestion automatique des ressources (ARM) ne peut pas être utilisée. Un traitement équivalent peut être traité à l'aide de fermetures. nouveau fichier ('C: \\ chemin \\ vers \\ fichier.txt'). eachLine ('Shift-JIS') {println it;}

• Le comportement des classes internes anonymes suit les directives Java, mais le comportement est différent. Consultez la documentation de Groovy pour plus de détails.

• Les expressions Lambda définies dans Java 8 peuvent être reconnues comme des classes internes anonymes, mais Groovy donne une erreur de syntaxe. Utilisez plutôt une fermeture.

• Un littéral de chaîne entre guillemets est traité comme une valeur de type GString.

• Les littéraux de chaîne entre guillemets simples sont traités comme des chaînes, sauf s'ils sont explicitement déclarés comme char. Le cast d'une chaîne de deux caractères ou plus en tant que char la traite comme char avec uniquement le premier caractère. --Le type de données est reconnu comme un objet et automatiquement piégé à un type primitif, etc., il peut donc différer du résultat du traitement de conversion élargi / rétréci.

• Le comportement de l'opérateur de comparaison == est une comparaison promiscuité en Java, mais dans Groovy, il est remplacé par ʻa.compareTo (b) == 0ou ʻa.equals (b). Utilisez ʻa.is (b) `pour vérifier l'identité.

• Le comportement de la conversion de type implicite dans Groovy est différent de Java. Consultez la documentation de Groovy pour plus de détails.

• De plus, il y a ** as **, ** def **, ** in **, ** trait **. (Caractère réservé)

• Règles d'écriture de code source lâches par rapport à Java (à l'opposé de Strict). Par exemple, le signe deux-points à la fin de la ligne n'est pas nécessaire et le type de données n'a pas à être déclaré. Vous pouvez également écrire des instructions qui n'appartiennent à aucune classe. (Déclaration lâche) -Déclarer une variable avec def modifie dynamiquement le type approprié en fonction de la valeur assignée à la variable.

• Le type de carte est disponible. map = [" Alice ": 10," Bob ": 20," Charlie ": 30]; println (map [" Alice "]); --Dans la syntaxe de contrôle, il est implicitement faux si le résultat de l'évaluation est 0 ou nul, et vrai dans le cas contraire.

• L'instruction switch peut être divisée en cas en évaluant des valeurs autres que numériques.

• Le format de l'instruction for est différent. for (m dans la liste) {print m.toString ();}; --Une fonction de définition de classe dynamique (Expando) est fournie. def e = new Expando (); e.msg =" Bonjour tout le monde "; e.show = {println (msg);}; e.show ();

• Le package java.sql facilite l'écriture du traitement des requêtes SQL. --Builder vous permet de décrire facilement des données structurées telles que HTML / XML / Swing. ʻImport groovy.xml.MarkupBuilder; new MarkupBuilder (). Html {body {div {mkp.yield ('Hello World')}; div (style: 'style.css') {mkp.yield ('Groovy')} }} `