Jython - Guide rapide

Jython est l'implémentation JVM du langage de programmation Python. Il est conçu pour fonctionner sur la plate-forme Java. Un programme Jython peut importer et utiliser n'importe quelle classe Java. Tout comme Java, le programme Jython se compile enbytecode. L'un des principaux avantages est qu'une interface utilisateur conçue en Python peut utiliser des éléments GUI deAWT, Swing ou SWT Package.

Jython, qui a commencé comme JPython et a été renommé plus tard, suit de près l'implémentation standard de Python appelée CPython tel que créé par Guido Van Rossum. Jython a été créé en 1997 parJim Hugunin. Jython 2.0 est sorti en 1999. Depuis lors, les versions de Jython 2.x correspondent aux versions équivalentes de CPython. Jython 2.7.0 sorti en mai 2015, correspond à CPython 2.7. Le développement de Jython 3.x est en cours.

Différence entre Python et Java

Voici les différences entre Python et Java -

  • Python est un langage typé dynamiquement. Par conséquent, la déclaration de type de variable n'est pas nécessaire. Java, par contre, est un langage de type statique, ce qui signifie que la déclaration de type de variable est obligatoire et ne peut pas être modifiée.

  • Python n'a que des exceptions non vérifiées, tandis que Java a à la fois des exceptions vérifiées et non vérifiées.

  • Python utilise des retraits pour la portée, tandis que Java utilise des accolades correspondantes.

  • Puisque Python est un langage basé sur un interpréteur, il n'a pas d'étapes de compilation distinctes. Un programme Java doit cependant être compilé en bytecode et est à son tour exécuté par une JVM.

  • Python prend en charge l'héritage multiple, mais en Java, l'héritage multiple n'est pas possible. Il a cependant l'implémentation d'une interface.

  • Par rapport à Java, Python a une structure de données intégrée plus riche (listes, dictés, tuples, tout est un objet).

Différence entre Python et Jython

Voici les différences entre Python et Jython -

  • L'implémentation de référence de Python, appelée CPython, est écrite en langage C. Jython, quant à lui, est entièrement écrit en Java et est une implémentation JVM.

  • Le Python standard est disponible sur plusieurs plates-formes. Jython est disponible pour toutes les plates-formes sur lesquelles une JVM est installée.

  • Le code Python standard se compile en un .pyc fichier, tandis que le programme Jython se compile en un .class fichier.

  • Les extensions Python peuvent être écrites en langage C. Les extensions pour Jython sont écrites en Java.

  • Jython est vraiment multi-thread par nature. Python utilise cependant leGlobal Interpreter Lock (GIL) à cet effet.

  • Les deux implémentations ont différents mécanismes de garbage collection.

Dans le chapitre suivant, nous apprendrons comment importer les bibliothèques Java en Jython.

Avant d'installer Jython 2.7, assurez-vous que le système a JDK 7ou plus installés. Jython est disponible sous la forme d'un fichier jar exécutable. Téléchargez-le depuis -http://www.jython.org/downloads.html et double-cliquez sur son icône ou exécutez la commande suivante -

java -jar jython_installer-2.7.0.jar

Un assistant d'installation commencera avec les options d'installation à donner. Voici la procédure d'installation systématique.

La première étape de l'assistant vous demande de sélectionner la langue.

La deuxième étape vous invite à accepter le contrat de licence.

À l'étape suivante, choisissez le type d'installation. Il est recommandé de choisir l'installation standard.

L'écran suivant vous demande de confirmer vos options et procède à la fin de l'installation.

La procédure d'installation peut prendre un certain temps.

Une fois l'installation terminée, appelez jython.exeà partir du répertoire bin dans le répertoire de destination. En supposant que Jython est installé dansC:\jython27, exécutez ce qui suit à partir de la ligne de commande.

C:\jython27\bin\jython

Une invite Python (>>>) apparaîtra, devant laquelle toute instruction Python ou script Python peut être exécuté.

L'une des fonctionnalités les plus importantes de Jython est sa capacité à importer des classes Java dans un programme Python. Nous pouvons importer n'importe quel package ou classe Java en Jython, comme nous le faisons dans un programme Java. L'exemple suivant montre comment lejava.util les packages sont importés dans un script Python (Jython) pour déclarer un objet de la classe Date.

from java.util import Date
d = Date()
print d

Enregistrez et exécutez le code ci-dessus comme UtilDate.pyà partir de la ligne de commande. L'instance de la date et de l'heure actuelles sera affichée.

C:\jython27\bin>jython UtilDate.py
Sun Jul 09 00:05:43 IST 2017

Les packages suivants de la bibliothèque Java sont plus souvent importés dans un programme Jython principalement parce que la bibliothèque Python standard n'a pas leurs équivalents ou n'est pas aussi bonne.

  • Servlets
  • JMS
  • J2EE
  • Javadoc
  • Swing est considéré comme supérieur aux autres boîtes à outils GUI

Tout package Java peut être importé dans un script Jython. Ici, le programme java suivant est stocké et compilé dans un package appeléfoo.

package foo;
public class HelloWorld {
   public void hello() {
      System.out.println("Hello World!");
   }
   public void hello(String name) {
      System.out.printf("Hello %s!", name);
   }
}

Ce HelloWorld.classest importé dans le script Jython suivant. Les méthodes de cette classe peuvent être appelées à partir du script Jythonimportex.py.

from foo import HelloWorld
h = HelloWorld()
h.hello()
h.hello("TutorialsPoint")

Enregistrez et exécutez le script ci-dessus à partir de la ligne de commande pour obtenir la sortie suivante.

C:\jython27\bin>jython importex.py
Hello World!
Hello TutorialsPoint!

Les variables sont des emplacements nommés dans la mémoire de l'ordinateur. Chaque variable peut contenir un élément de données. Contrairement à Java, Python est un langage typé dynamiquement. Par conséquent, tout en utilisant Jython également; la déclaration préalable du type de données de la variable n'est pas effectuée. Plutôt que le type de variable qui décide quelles données peuvent y être stockées, les données déterminent le type de variable.

Dans l'exemple suivant, une variable reçoit une valeur entière. En utilisant la fonction intégrée type (), nous pouvons vérifier que le type de variable est un entier. Mais, si une chaîne est attribuée à la même variable, la fonction type () sera associée au type de la même variable.

> x = 10
>>> type(x)
<class 'int'>

>>> x = "hello"
>>> type(x)
<class 'str'>

Cela explique pourquoi Python est appelé un langage typé dynamiquement.

Les types de données intégrés Python suivants peuvent également être utilisés dans Jython -

  • Number
  • String
  • List
  • Tuple
  • Dictionary

Python reconnaît les données numériques comme un nombre, qui peut être un entier, un nombre réel à virgule flottante ou un nombre complexe. Les types de données String, List et Tuple sont appelés séquences.

Numéros Jython

En Python, tout entier signé est dit de type «int». Pour exprimer un entier long, la lettre «L» lui est attachée. Un nombre avec un point décimal séparant la partie entière d'un composant fractionnaire est appelé «float». La partie fractionnaire peut contenir un exposant exprimé dans la notation scientifique en utilisant «E» ou «e».

Un nombre complexe est également défini comme un type de données numérique en Python. Un nombre complexe contient une partie réelle (un nombre à virgule flottante) et une partie imaginaire ayant un «j» attaché.

Afin d'exprimer un nombre dans la représentation octale ou hexadécimale, 0O ou 0Xy est préfixé. Le bloc de code suivant donne des exemples de différentes représentations de nombres en Python.

int     -> 10, 100, -786, 80
long    -> 51924361L, -0112L, 47329487234L
float   -> 15.2, -21.9, 32.3+e18, -3.25E+101
complex -> 3.14j, 45.j, 3e+26J, 9.322e-36j

Chaînes Jython

Une chaîne est une séquence de caractères entre guillemets simples (par exemple «bonjour»), doubles (par exemple «bonjour») ou triples (par exemple «bonjour» ou «« bonjour »»). Les guillemets triples sont particulièrement utiles si le contenu de la chaîne s'étend sur plusieurs lignes.

Les caractères de la séquence d'échappement peuvent être inclus textuellement dans une chaîne entre guillemets triples. Les exemples suivants montrent différentes manières de déclarer une chaîne en Python.

str = ’hello how are you?’
str = ”Hello how are you?”
str = """this is a long string that is made up of several lines and non-printable
characters such as TAB ( \t ) and they will show up that way when displayed. NEWLINEs
within the string, whether explicitly given like this within the brackets [ \n ], or just
a NEWLINE within the variable assignment will also show up.
"""

La troisième chaîne une fois imprimée, donnera la sortie suivante.

this is a long string that is made up of
several lines and non-printable characters such as
TAB ( 	 ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [
], or just a NEWLINE within
the variable assignment will also show up.

Listes Jython

Une liste est un type de données de séquence. Il s'agit d'une collection d'éléments séparés par des virgules, pas nécessairement du même type, stockés entre crochets. Les éléments individuels de la liste sont accessibles à l'aide de l'index de base zéro.

Le bloc de code suivant résume l'utilisation d'une liste en Python.

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]

Le tableau suivant décrit certaines des expressions Jython les plus courantes liées aux listes Jython.

Expression Jython La description
len (Liste) Longueur
Liste [2] = 10 Mise à jour
Supprimer la liste [1] Effacement
List.append (20) Ajouter
List.insert (1,15) Insertion
List.sort () Tri

Tuples Jython

Un tuple est une collection immuable d'éléments de données séparés par des virgules stockés entre parenthèses. Il n'est pas possible de supprimer ou de modifier un élément dans tuple, ni d'ajouter un élément à la collection de tuple. Le bloc de code suivant montre les opérations Tuple.

tup1 = ('physics','chemistry‘,1997,2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print "tup1[0]: ", tup1[0]
print "tup2[1:5]: ", tup2[1:5]

Dictionnaire Jython

Le dictionnaire Jython est similaire à la classe Map dans le framework Java Collection. C'est une collection de paires clé-valeur. Les paires séparées par des virgules sont placées entre accolades. Un objet Dictionary ne suit pas l'index de base zéro pour récupérer l'élément à l'intérieur car ils sont stockés par la technique de hachage.

La même clé ne peut pas apparaître plus d'une fois dans un objet dictionnaire. Cependant, plusieurs clés peuvent avoir les mêmes valeurs associées. Les différentes fonctions disponibles avec l'objet Dictionary sont expliquées ci-dessous -

dict = {'011':'New Delhi','022':'Mumbai','033':'Kolkata'}
print "dict[‘011’]: ",dict['011']
print "dict['Age']: ", dict['Age']

Le tableau suivant décrit certaines des expressions Jython les plus courantes liées au dictionnaire.

Expression Jython La description
dict.get ('011') Chercher
len (dict) Longueur
dict ['044'] = 'Chennai' Ajouter
del dict ['022'] Effacer
dict.keys () liste des clés
dict.values ​​() Liste de valeurs
dict.clear () Supprime tous les éléments

En plus des types de données intégrés de Python, Jython a l'avantage d'utiliser les classes de collection Java en important le java.util package. Le code suivant décrit les classes données ci-dessous -

  • Objet Java ArrayList avec add ()
  • remove()
  • méthodes get () et set () de la classe ArrayList.
import java.util.ArrayList as ArrayList
arr = ArrayList()
arr.add(10)
arr.add(20)
print "ArrayList:",arr
arr.remove(10) #remove 10 from arraylist
arr.add(0,5) #add 5 at 0th index
print "ArrayList:",arr
print "element at index 1:",arr.get(1) #retrieve item at index 1
arr.set(0,100) #set item at 0th index to 100
print "ArrayList:",arr

Le script Jython ci-dessus produit la sortie suivante -

C:\jython27\bin>jython arrlist.py
ArrayList: [10, 20]
ArrayList: [5, 20]
element at index 1: 20
ArrayList: [100, 20]

Classe Jarray

Jython implémente également le Jarray Object, qui permet la construction d'un tableau Java en Python. Pour travailler avec un jarray, définissez simplement un type de séquence en Jython et passez-le au jarrayobject avec le type d'objet contenu dans la séquence. Toutes les valeurs d'un fichier jarray doivent être du même type.

Le tableau suivant montre les codes de type de caractères utilisés avec un jarray.

Code de type de caractère Type Java correspondant
Z Booléen
C carboniser
B octet
H court
je int
L longue
F flotte
ré double

L'exemple suivant montre la construction de jarray.

my_seq = (1,2,3,4,5)
from jarray import array
arr1 = array(my_seq,'i')
print arr1
myStr = "Hello Jython"
arr2 = array(myStr,'c')
print arr2

Ici my_seqest défini comme un tuple d'entiers. Il est converti en Jarray arr1. Le deuxième exemple montre que Jarray arr2 est construit à partir demySttr stringséquence. La sortie du script ci-dessusjarray.py est comme suit -

array('i', [1, 2, 3, 4, 5])
array('c', 'Hello Jython')

Les structures de prise de décision ont une ou plusieurs conditions à évaluer ou à tester par le programme, ainsi qu'une ou plusieurs instructions à exécuter, si la condition est jugée vraie, et éventuellement d'autres instructions à exécuter, si la condition est déterminé comme étant faux.

L'illustration suivante montre la forme générale d'une structure de prise de décision typique trouvée dans la plupart des langages de programmation -

Jython n'utilise pas de parenthèses pour indiquer les blocs d'instructions à exécuter lorsque la condition est vraie ou fausse (comme c'est le cas en Java). Au lieu de cela, un retrait uniforme (espace blanc à partir de la marge gauche) est utilisé pour former un bloc d'instructions. Un tel bloc uniformément indenté rend le code conditionnel à exécuter lorsqu'une condition donnée dans l'instruction «if» est vraie.

Un bloc similaire peut être présent après une instruction «else» facultative. Jython fournit également leelif statementen utilisant quelles conditions successives peuvent être testées. Ici leelse clauseapparaîtra en dernier et ne sera exécuté que lorsque toutes les conditions précédentes échouent. La syntaxe générale de l'utilisationif..elif..else est comme suit.

if expression1:
   statement(s)
elif expression2:
   statement(s)
elif expression3:
   statement(s)
else:
   statement(s)

Dans l'exemple suivant, si ..elif ..else construct est utilisé pour calculer la remise sur différentes valeurs de montant saisies par l'utilisateur.

discount = 0
amount = input("enter Amount")
if amount>1000:
   discount = amount*0.10
elif amount>500:
   discount = amount*0.05
else:
   discount = 0
print 'Discount = ',discount
print 'Net amount = ',amount-discount

La sortie du code ci-dessus sera comme indiqué ci-dessous.

enter Amount1500
Discount = 150.0
Net amount = 1350.0
enter Amount600
Discount = 30.0
Net amount = 570.0
enter Amount200
Discount = 0
Net amount = 200

En général, les instructions d'un programme sont exécutées séquentiellement: la première instruction d'une fonction est exécutée en premier, suivie de la seconde, et ainsi de suite. Il peut arriver que vous deviez exécuter un bloc de code plusieurs fois. Les déclarations qui fournissent une telle capacité de répétition sont appeléeslooping statements.

En Jython, une boucle peut être formée par deux instructions, qui sont -

  • le while déclaration et

  • le for déclaration

La boucle WHILE

Une instruction de boucle while en Jython est similaire à celle en Java. Il exécute à plusieurs reprises un bloc d'instructions tant qu'une condition donnée est vraie. L'organigramme suivant décrit le comportement d'unwhile boucle.

La syntaxe générale de l'instruction while est donnée ci-dessous.

while expression:
   statement(s)

Le code Jython suivant utilise la boucle while pour incrémenter et afficher à plusieurs reprises la valeur d'une variable jusqu'à ce qu'elle soit inférieure à zéro.

count = 0
while count<10:
   count = count+1
   print "count = ",count
print "Good Bye!"

Output - La sortie serait la suivante.

count =  1
count =  2
count =  3
count =  4
count =  5
count =  6
count =  7
count =  8
count =  9
count =  10
Good Bye!

La boucle FOR

La boucle FOR en Jython n'est pas une boucle comptée comme en Java. Au lieu de cela, il a la capacité de parcourir des éléments dans un type de données de séquence tel qu'une chaîne, une liste ou un tuple. La syntaxe générale de l'instruction FOR en Jython est la suivante:

for iterating_var in sequence:
   statements(s)

Nous pouvons afficher chaque caractère dans une chaîne, ainsi que chaque élément dans une liste ou un tuple en utilisant l'instruction FOR comme indiqué ci-dessous -

#each letter in string
for letter in 'Python':
   print 'Current Letter :', letter

Output - La sortie serait la suivante.

Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : h
Current Letter : o
Current Letter : n

Considérons un autre exemple comme suit.

#each item in list
libs = [‘PyQt’, 'WxPython',  'Tkinter']
for lib in libs:        # Second Example
   print 'Current library :', lib

Output - La sortie sera la suivante.

Current library : PyQt
Current library : WxPython
Current library : Tkinter

Voici un autre exemple à considérer.

#each item in tuple
libs = (‘PyQt’, 'WxPython',  'Tkinter')
for lib in libs:        # Second Example
   print 'Current library :', lib

Output - La sortie du programme ci-dessus est la suivante.

Current library : PyQt
Current library : WxPython
Current library : Tkinter

En Jython, le forL'instruction est également utilisée pour parcourir une liste de nombres générée par la fonction range (). La fonction range () prend la forme suivante -

range[([start],stop,[step])

Les paramètres de démarrage et d'étape sont 0 et 1 par défaut. Le dernier numéro généré est l'étape d'arrêt. L'instruction FOR parcourt la liste formée par lerange() function. Par exemple -

for num in range(5):
   print num

Il produit la sortie suivante -

0
1
2
3
4

Une logique de programmation complexe est divisée en un ou plusieurs blocs d'instructions indépendants et réutilisables appelés fonctions. La bibliothèque standard de Python contient un grand nombre de fonctions intégrées. On peut également définir sa propre fonction en utilisant ledefmot-clé. Le nom défini par l'utilisateur de la fonction est suivi d'un bloc d'instructions qui forme son corps, qui se termine par l'instruction return.

Une fois défini, il peut être appelé depuis n'importe quel environnement un nombre illimité de fois. Considérons le code suivant pour clarifier le point.

#definition of function
defSayHello():
   "optional documentation string"
   print "Hello World"
   return

#calling the function
SayHello()

Une fonction peut être conçue pour recevoir un ou plusieurs paramètres / arguments de l'environnement appelant. Lors de l'appel d'une telle fonction paramétrée, vous devez fournir le même nombre de paramètres avec des types de données similaires utilisés dans la définition de fonction, sinon l'interpréteur Jython lance unTypeError exception.

Exemple

#defining function with two arguments
def area(l,b):
   area = l*b
   print "area = ",area
   return

#calling function
length = 10
breadth = 20
#with two arguments. This is OK
area(length, breadth)
#only one argument provided. This will throw TypeError
area(length)

le output sera comme suit -

area = 200
Traceback (most recent call last):
   File "area.py", line 11, in <module>
   area(length)
TypeError: area() takes exactly 2 arguments (1 given)

Après avoir exécuté les étapes qui y sont définies, la fonction appelée retourne à l'environnement appelant. Il peut renvoyer les données, si une expression est mentionnée devant le mot-clé return dans la définition de la fonction.

#defining function
def area(l,b):
   area = l*b
   print "area = ",area
   return area

#calling function
length = 10
breadth = 20
#calling function and obtaining its reurned value
result = area(length, breadth)
print "value returned by function : ", result

La sortie suivante est obtenue si le script ci-dessus est exécuté à partir de l'invite Jython.

area = 200
value returned by function : 200

Un module est un script Jython dans lequel une ou plusieurs fonctions, classes ou variables associées sont définies. Cela permet une organisation logique du code Jython. Les éléments de programme définis dans un module peuvent être utilisés dans un autre script Jython en important le module ou l'élément spécifique (fonction / classe) à partir de celui-ci.

Dans le code suivant (hello.py) une fonction SayHello() est défini.

#definition of function
defSayHello(str):
   print "Hello ", str
   return

Pour utiliser la fonction SayHello () à partir d'un autre script, importez le hello.py module dedans.

import hello
hello.SayHello("TutorialsPoint")

Cependant, cela importera toutes les fonctions définies dans le module. Afin d'importer une fonction spécifique du module, utilisez la syntaxe suivante.

from modname import name1[, name2[,... nameN]

Par exemple, pour importer uniquement la fonction SayHello (), modifiez le script ci-dessus comme suit.

from hello import SayHello
SayHello("TutorialsPoint")

Il n'est pas nécessaire de préfixer le nom du module lors de l'appel de la fonction.

Tout dossier contenant un ou plusieurs modules Jython est reconnu comme un package. Cependant, il doit avoir un fichier spécial appelé__init__.py, qui fournit l'index des fonctions à utiliser.

Voyons maintenant comment créer et importer un package.

Step 1 - Créez un dossier appelé package1, puis créez et enregistrez les éléments suivants g modules dedans.

#fact.py
def factorial(n):
   f = 1
   for x in range(1,n+1):
      f = f*x
   return f

#sum.py
def add(x,y):
   s = x+y
   return s

#mult.py
def multiply(x,y):
   s = x*y
   return s

Step 2 - Dans le dossier package1, créez et enregistrez le __init__.py fichier avec le contenu suivant.

#__init__.py
from fact import factorial
from sum import add
from mult import multiply

Step 3 - Créez le script Jython suivant en dehors du dossier package1 comme test.py.

# Import your Package.
import package1

f = package1.factorial(5)
print "factorial = ",f
s = package1.add(10,20)
print "addition = ",s
m = package1.multiply(10,20)
print "multiplication = ",m

Step 4- Exécutez test.py à partir de l'invite Jython. La sortie suivante sera obtenue.

factorial = 120
addition = 30
multiplication = 200

Télécharger jython-standalone-2.7.0.jar - Pour intégrer Jython dans les applications Java à partir de leur page de téléchargement officielle: http://www.jython.org/downloads.html et incluez ce fichier jar dans la variable d'environnement Java CLASSPATH.

Cette bibliothèque contient le PythonInterpreterclasse. En utilisant l'objet de cette classe, tout script Python peut être exécuté en utilisant leexecfile()méthode. Le PythonInterpreter vous permet d'utiliserPyObjectsdirectement. Tous les objets connus du système d'exécution Jython sont représentés par une instance de la classe PyObject ou l'une de ses sous-classes.

La classe PythonInterpreter a quelques méthodes régulièrement utilisées, qui sont expliquées dans le tableau ci-dessous.

Sr.No. Méthode et description
1

setIn(PyObject)

Définir l'objet Python à utiliser pour le flux d'entrée standard
2

setIn(java.io.Reader)

Définissez un java.io.Reader à utiliser pour le flux d'entrée standard
3

setIn(java.io.InputStream)

Définissez un java.io.InputStream à utiliser pour le flux d'entrée standard
4

setOut(PyObject)

Définir l'objet Python à utiliser pour le flux de sortie standard
5

setOut(java.io.Writer)

Définissez le java.io.Writer à utiliser pour le flux de sortie standard
6

setOut(java,io.OutputStream)

Définissez le java.io.OutputStream à utiliser pour le flux de sortie standard
sept

setErr(PyObject)

Définir un objet d'erreur Python à utiliser pour le flux d'erreur standard
8

setErr(java.io.Writer

Définissez un java.io.Writer à utiliser pour le flux d'erreur standard
9

setErr(java.io.OutputStream)

Définissez un java.io.OutputStream à utiliser pour le flux d'erreur standard
dix

eval(String)

Évaluer une chaîne comme source Python et renvoyer le résultat
11

eval(PyObject)

Évaluer un objet de code Python et renvoyer le résultat
12

exec(String)

Exécuter une chaîne source Python dans l'espace de noms local
13

exec(PyObject)

Exécuter un objet de code Python dans l'espace de noms local
14

execfile(String filename)

Exécuter un fichier de source Python dans l'espace de noms local
15

execfile(java.io.InputStream)

Exécuter un flux d'entrée de la source Python dans l'espace de noms local
16

compile(String)

Compilez une chaîne source Python en tant qu'expression ou module
17

compile(script, filename)

Compiler un script de source Python en tant qu'expression ou module
18

set(String name, Object value)

Définir une variable de type Object dans l'espace de noms local
19

set(String name, PyObject value)

Définir une variable de type PyObject dans l'espace de noms local
20

get(String)

Récupère la valeur d'une variable dans l'espace de noms local
21

get(String name, Class javaclass

Récupère la valeur d'une variable dans l'espace de noms local. La valeur sera renvoyée en tant qu'instance de la classe Java donnée.

Le bloc de code suivant est un programme Java ayant un script Jython intégré “hello.py”.usingexecfile()méthode de l'objet PythonInterpreter. Il montre également comment une variable Python peut être définie ou lue à l'aide des méthodes set () et get ().

import org.python.util.PythonInterpreter;
import org.python.core.*;

public class SimpleEmbedded {
   public static void main(String []args) throws PyException {
      PythonInterpreter interp = new PythonInterpreter();
      System.out.println("Hello, world from Java");
      interp.execfile("hello.py");
      interp.set("a", new PyInteger(42));
      interp.exec("print a");
      interp.exec("x = 2+2");
      PyObject x = interp.get("x");
      System.out.println("x: "+x);
      System.out.println("Goodbye ");
   }
}

Compilez et exécutez le programme Java ci-dessus pour obtenir la sortie suivante.

Hello, world from Java
hello world from Python
42
x: 4
Goodbye

PyDev est un plugin open source pour Eclipse IDE pour permettre le développement de projets en Python, Jython ainsi qu'en IronPython. Il est hébergé auhttps://pydev.org. Une procédure étape par étape pour installer le plugin PyDev dans Eclipse IDE est donnée ci-dessous.

Step 1 - Ouvrez Eclipse IDE et choisissez le Install New Software option dans le menu Aide.

Step 2 - Entrez http://pydev.org/updatesdans la zone de texte en face de travailler avec étiquette et cliquez sur ajouter. Choisissez toutes les entrées disponibles dans la liste et cliquez sur Suivant. L'assistant prendra quelques minutes pour terminer l'installation et il invitera l'EDI à redémarrer.

Step 3- Choisissez maintenant l'option Préférences dans le menu Fenêtre. La boîte de dialogue Préférences s'ouvre comme illustré ci-dessous.

Step 4- Développez le nœud Interprètes et sélectionnez Interpréteur Jython dans le volet gauche. Dans le volet de droite, cliquez sur nouveau pour donner le chemin vers lejython.jar file.

Nous sommes maintenant prêts à démarrer un projet Jython en utilisant Eclipse.

Pour faire un projet dans eclipse, nous devons suivre les étapes ci-dessous.

Step 1- Choisissez Fichier? Nouveau ? Projet. ChoisirPyDevdans la boîte de dialogue de filtre. Donnez le nom du projet, le type de projet et cliquez sur Terminer.

Step 2- Le projet Hello apparaîtra maintenant dans l'explorateur de projet sur la gauche. Faites un clic droit pour y ajouter hello.py.

Step 3- Un hello.py vide apparaîtra dans l'éditeur. Écrivez le code Jython et enregistrez-le.

Step 4- Cliquez sur le bouton Exécuter dans la barre de menu. La sortie apparaîtra dans la fenêtre de la console comme indiqué ci-dessous.

La prise en charge de Python et Jython pour NetBeans est disponible via le nbPython plugin. Téléchargez le plugin à partir de l'URL suivante -http://plugins.netbeans.org/plugin/56795. Décompressez l'archive téléchargée dans un dossier. Par exemple -d:\nbplugin. Pour installer le plugin NetBeans, suivons les étapes ci-dessous.

Step 1 - Démarrez le Netbeans IDEpuis allez dans Tools / Plugin pour ouvrir le Plugin Manager. Choisissez l'onglet «Téléchargé» et accédez au dossier dans lequel le fichier téléchargé a été décompressé. La fenêtre NetBeans apparaîtra comme indiqué ci-dessous.

Step 2 - L'étape suivante consiste à sélectionner tous les .nbm fichiers et cliquez sur Ouvrir.

Step 3 - Cliquez sur le bouton Installer.

Step 4 - Acceptez le contrat de licence suivant pour continuer.

Ignorez l'avertissement concernant la source non approuvée de plugins et redémarrez l'EDI pour continuer.

Projet Jython dans NetBeans

Une fois redémarré, démarrez un nouveau projet en choisissant Fichier / Nouveau. La catégorie Python sera désormais disponible dans la liste des catégories. Choisissez-le pour continuer.

Si Python est installé sur le système, sa / ses versions seront automatiquement détectées et affichées dans la liste déroulante de la plateforme Python. Cependant, Jython ne sera pas répertorié. Cliquez sur le bouton Gérer pour l'ajouter.

Cliquez sur le bouton 'Nouveau' pour ajouter un nom de plate-forme et un chemin vers l'exécutable Jython.

Jython sera désormais disponible dans la liste des plateformes. Sélectionnez dans la liste déroulante comme indiqué dans la capture d'écran suivante.

Nous pouvons maintenant remplir le nom du projet, l'emplacement et le fichier principal dans la fenêtre suivante.

La structure du projet apparaîtra dans la fenêtre des projets de l'EDI NetBeans et un modèle de code Python dans la fenêtre de l'éditeur.

Générez et exécutez le projet Jython pour obtenir le résultat suivant dans la fenêtre de sortie de l'EDI NetBeans.

Un servlet Java est la technique de développement Web la plus utilisée. Nous pouvons utiliser Jython pour écrire des servlets et cela ajoute de nombreux autres avantages au-delà de ce que Java a à offrir, car maintenant nous pouvons également utiliser les fonctionnalités du langage Python.

Nous utiliserons l'EDI NetBeans pour développer une application Web Java avec un servlet Jython. Assurez-vous que lenbPython pluginest installé dans l'installation de NetBeans. Démarrez un nouveau projet pour créer une application Web en choisissant le chemin suivant -File → New Project → Java web → New Web Application.

Indiquez le nom et l'emplacement du projet. L'EDI créera la structure du dossier du projet. Ajoutez un fichier de servlet Java (ServletTest.java) sous le nœud des packages source dans la fenêtre Projets. Cela ajouteraservlet-api.jardans le dossier lib du projet. Laissez également l'EDI créer le fichier web.xmldescriptor file. Ajoutez le code suivant dansServletTest.java.

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class ServletTest extends HttpServlet {
   
   public void doGet (HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      doPost(request, response);
   }
   
   public void doPost (HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      response.setContentType ("text/html");
      PrintWriter toClient = response.getWriter();
      
      toClient.println (
         "<html>
            <head>
               <title>Servlet Test</title>" + "
            </head>
            <body>
               <h1>Servlet Test</h1>
            </body>
         </html>"
      );
   }
}

Le fichier web.xml créé par NetBeans sera comme indiqué ci-dessous -

<web-app>
   <servlet>
      <servlet-name>ServletTest</servlet-name>
      <servlet-class>ServletTest</servlet-class>
   </servlet>
   
   <servlet-mapping>
      <servlet-name>ServletTest</servlet-name>
      <url-pattern>/ServletTest</url-pattern>
   </servlet-mapping>
</web-app>

Générez et exécutez le projet pour obtenir le texte Servlet Testapparaissant dans la balise <h1> dans la fenêtre du navigateur. Ainsi, nous avons ajouté une servlet Java standard dans l'application.

Maintenant, nous allons ajouter le servlet Jython. Les servlets Jython fonctionnent au moyen d'un servlet Java intermédiaire également appelé PyServlet. Le PyServlet.class est présent dans lejython standalone.jar. Ajoutez-le dans leWEB-INF/lib dossier.

L'étape suivante consiste à configurer le web.xml pour appeler le PyServlet, chaque fois qu'une demande *.py fileest soulevé. Cela devrait être fait en y ajoutant le code XML suivant.

<servlet>
   <servlet-name>PyServlet</servlet-name>
   <servlet-class>org.python.util.PyServlet</servlet-class>
   <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
   <servlet-name>PyServlet</servlet-name>
   <url-pattern>*.py</url-pattern>
</servlet-mapping>

Le code web.xml complet ressemblera à celui ci-dessous.

<web-app>
   <servlet>
      <servlet-name>ServletTest</servlet-name>
      <servlet-class>ServletTest</servlet-class>
   </servlet>
   
   <servlet>
      <servlet-name>PyServlet</servlet-name>
      <servlet-class>org.python.util.PyServlet</servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>
   
   <servlet-mapping>
      <servlet-name>ServletTest</servlet-name>
      <url-pattern>/ServletTest</url-pattern>
   </servlet-mapping>
   
   <servlet-mapping>
      <servlet-name>PyServlet</servlet-name>
      <url-pattern>*.py</url-pattern>
   </servlet-mapping>
</web-app>

Placez le code Jython suivant dans le dossier WEB-INF à l'intérieur du dossier du projet en tant que JythonServlet.py, ce qui équivaut au ServletTest.java précédent.

from javax.servlet.http import HttpServlet
class JythonServlet1 (HttpServlet):
   def doGet(self,request,response):
      self.doPost (request,response)
   def doPost(self,request,response):
      toClient = response.getWriter()
      response.setContentType ("text/html")
      
      toClient.println (
         "<html>
            <head>
               <title>Servlet Test</title>" + "
            </head>
            <body>
               <h1>Servlet Test</h1>
            </body>
         </html>"
      )

Construisez le projet et dans le navigateur ouvrez l'URL suivante -

http://localhost:8080/jythonwebapp/jythonservlet.py

Le navigateur affichera le Servlet Test dans la balise <h1> comme dans le cas de la sortie Java Servlet.

Jython utilise le zxJDBC packagequi fournit un wrapper Python facile à utiliser autour de JDBC. zxJDBC relie deux normes:JDBC est la plate-forme standard pour l'accès aux bases de données en Java, et DBI est l'API de base de données standard pour les applications Python.

ZxJDBC fournit une interface conforme à la norme DBI 2.0 avec JDBC. Plus de 200 pilotes sont disponibles pour JDBC et ils fonctionnent tous avec zxJDBC. Des pilotes hautes performances sont disponibles pour toutes les principales bases de données relationnelles, notamment:

  • DB2
  • Derby
  • MySQL
  • Oracle
  • PostgreSQL
  • SQLite
  • SQL Server et
  • Sybase.

Le package ZxJDBC peut être téléchargé depuis https://sourceforge.net/projects/zxjdbc/ ou http://www.ziclix.com/zxjdbc/. L'archive téléchargée contient le ZxJDBC.jar, qui doit être ajouté à la variable d'environnement CLASSPATH.

Nous avons l'intention d'établir une connectivité de base de données avec la base de données MySQL. Pour cela, le pilote JDBC pour MySQL est requis. Téléchargez leMySQL J connector à partir du lien suivant - https://dev.mysql.com/downloads/connector/j/ et incluez le connecteur mysql java-5.1.42-bin.jar dans le CLASSPATH.

Connectez-vous au serveur MySQL et créez une table étudiant dans la base de données de test avec la structure suivante -

Champ Type Largeur
Nom Varchar dix
Âge Int 3
Des marques Int 3

Ajoutez-y quelques enregistrements.

Nom Âge Des marques
Ravi 21 78
Ashok 20 65
Anil 22 71

Créez le script Jython suivant comme dbconnect.py.

url = "jdbc:mysql://localhost/test"
user = "root"
password = "password"
driver = "com.mysql.jdbc.Driver"
mysqlConn = zxJDBC.connect(url, user, password, driver)
mysqlConn = con.cursor()
mysqlConn.execute(“select * from student)
for a in mysql.fetchall():
   print a

Exécutez le script ci-dessus à partir de l'invite Jython. Les enregistrements dans le tableau des étudiants seront répertoriés comme indiqué ci-dessous -

(“Ravi”, 21, 78)
(“Ashok”, 20, 65)
(“Anil”,22,71)

Ceci explique la procédure d'établissement de JDBC en Jython.

L'une des principales fonctionnalités de Jython est sa capacité à utiliser la bibliothèque Swing GUI dans JDK. La distribution Python standard (souvent appelée CPython) a leTkinter GUI librarylivré avec. D'autres bibliothèques GUI commePyQt et WxPython sont également disponibles pour une utilisation avec elle, mais la bibliothèque swing offre une boîte à outils GUI indépendante de la plate-forme.

L'utilisation de la bibliothèque swing en Jython est beaucoup plus simple que de l'utiliser en Java. En Java, les classes anonymes doivent être utilisées pour créer une liaison d'événement. En Jython, nous pouvons simplement passer une fonction dans le même but.

La fenêtre de niveau supérieur de base est créée en déclarant un objet du JFrame classet définissez sa propriété visible sur true. Pour cela, la classe Jframe doit être importée du package swing.

from javax.swing import JFrame

La classe JFrame a plusieurs constructeurs avec un nombre variable d'arguments. Nous utiliserons celui, qui prend une chaîne comme argument et la définit comme titre.

frame = JFrame(“Hello”)

Définissez les propriétés de taille et d'emplacement du cadre avant de définir sa propriété visible sur true. Stockez le code suivant commeframe.py.

from javax.swing import JFrame

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(300,200)
frame.setVisible(True)

Exécutez le script ci-dessus à partir de l'invite de commande. Il affichera la sortie suivante montrant une fenêtre.

La bibliothèque Swing GUI est fournie sous la forme de javax.swingpackage en Java. Ses principales classes de conteneurs,JFrame et JDialogsont respectivement dérivés des classes Frame et Dialog, qui se trouvent dans la bibliothèque AWT. Autres contrôles GUI commeJLabel, JButton, JTextField, etc., sont dérivés de la classe JComponent.

L'illustration suivante montre la hiérarchie des classes de packages Swing.

Le tableau suivant résume les différentes classes de contrôle GUI dans une bibliothèque swing -

Sr.No. Classe et description
1

JLabel

Un objet JLabel est un composant permettant de placer du texte dans un conteneur.
2

JButton

Cette classe crée un bouton étiqueté.
3

JColorChooser

Un JColorChooser fournit un volet de contrôles conçu pour permettre à un utilisateur de manipuler et de sélectionner une couleur.
4

JCheckBox

Un JCheckBox est un composant graphique qui peut être dans un on (vrai ou off (faux) état.
5

JRadioButton

La classe JRadioButton est un composant graphique qui peut être dans un état activé (vrai) ou désactivé (faux). dans un groupe.
6

JList

Un composant JList présente à l'utilisateur une liste déroulante d'éléments de texte.
sept

JComboBox

Un composant JComboBox présente à l'utilisateur une liste déroulante d'éléments
8

JTextField

Un objet JTextField est un composant de texte qui permet l'édition d'une seule ligne de texte.
9

JPasswordField

Un objet JPasswordField est un composant de texte spécialisé pour la saisie de mot de passe.
dix

JTextArea

Un objet JTextArea est un composant de texte qui permet de modifier plusieurs lignes de texte.
11

ImageIcon

Un contrôle ImageIcon est une implémentation de l'interface Icon qui peint des icônes à partir d'images
12

JScrollbar

Un contrôle Scrollbar représente un composant de barre de défilement afin de permettre à l'utilisateur de sélectionner une plage de valeurs.
13

JOptionPane

JOptionPane fournit un ensemble de boîtes de dialogue standard qui invitent les utilisateurs à saisir une valeur ou les informent de quelque chose.
14

JFileChooser

Un contrôle JFileChooser représente une fenêtre de dialogue dans laquelle l'utilisateur peut sélectionner un fichier.
15

JProgressBar

Au fur et à mesure que la tâche progresse vers l'achèvement, la barre de progression affiche le pourcentage d'achèvement de la tâche.
16

JSlider

Un JSlider permet à l'utilisateur de sélectionner graphiquement une valeur en faisant glisser un bouton dans un intervalle limité.
17

JSpinner

Un JSpinner est un champ de saisie sur une seule ligne qui permet à l'utilisateur de sélectionner un nombre ou une valeur d'objet dans une séquence ordonnée.

Nous utiliserions certains de ces contrôles dans les exemples suivants.

Les gestionnaires de disposition en Java sont des classes qui gèrent le placement des contrôles dans les objets conteneurs comme Frame, Dialog ou Panel. Les gestionnaires de mise en page conservent le positionnement relatif des contrôles dans un cadre, même si la résolution change ou si le cadre lui-même est redimensionné.

Ces classes implémentent le Layout interface. Les gestionnaires de disposition suivants sont définis dans leAWT library -

  • BorderLayout
  • FlowLayout
  • GridLayout
  • CardLayout
  • GridBagLayout

Les gestionnaires de mise en page suivants sont définis dans le Swing library -

  • BoxLayout
  • GroupLayout
  • ScrollPaneLayout
  • SpringLayout

Nous utiliserons les gestionnaires de disposition AWT ainsi que les gestionnaires de disposition swing dans les exemples suivants.

  • Disposition absolue
  • Disposition de flux
  • Disposition de la grille
  • Disposition de la bordure
  • Disposition de la boîte
  • Disposition de groupe

Examinons maintenant chacun de ces éléments en détail.

Disposition absolue

Avant d'explorer tous les gestionnaires de disposition ci-dessus, nous devons examiner le positionnement absolu des contrôles dans un conteneur. Nous devons définir la méthode de mise en page de l'objet frame sur «Aucun».

frame.setLayout(None)

Placez ensuite le contrôle en appelant le setBounds()méthode. Il prend quatre arguments - position x, position y, largeur et hauteur.

Par exemple - Pour placer un objet bouton à la position absolue et à la taille absolue.

btn = JButton("Add")
btn.setBounds(60,80,60,20)

De même, tous les contrôles peuvent être placés en attribuant correctement la position et la taille. Cette disposition est relativement facile à utiliser, mais ne parvient pas à conserver son apparence lorsque la fenêtre est redimensionnée ou si le programme est exécuté lorsque la résolution de l'écran change.

Dans le script Jython suivant, trois objets Jlabel sont utilisés pour afficher respectivement le texte «phy», «maths» et «Total». Devant ces trois objets - JTextField sont placés. Un objet Button est placé au-dessus de l'étiquette «Total».

Tout d'abord, la fenêtre JFrame est créée avec une mise en page définie sur aucune.

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(300,200)
frame.setLayout(None)

Ensuite, différents contrôles sont ajoutés en fonction de leur position absolue et de leur taille. Le code complet est donné ci-dessous -

from javax.swing import JFrame, JLabel, JButton, JTextField

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(300,200)
frame.setLayout(None)

lbl1 = JLabel("Phy")
lbl1.setBounds(60,20,40,20)
txt1 = JTextField(10)
txt1.setBounds(120,20,60,20)
lbl2 = JLabel("Maths")
lbl2.setBounds(60,50,40,20)
txt2 = JTextField(10)
txt2.setBounds(120, 50, 60,20)
btn = JButton("Add")
btn.setBounds(60,80,60,20)
lbl3 = JLabel("Total")
lbl3.setBounds(60,110,40,20)
txt3 = JTextField(10)
txt3.setBounds(120, 110, 60,20)

frame.add(lbl1)
frame.add(txt1)
frame.add(lbl2)
frame.add(txt2)
frame.add(btn)
frame.add(lbl3)
frame.add(txt3)
frame.setVisible(True)

La sortie pour le code ci-dessus est la suivante.

Jython FlowLayout

Le FlowLayout est le gestionnaire de disposition par défaut pour les classes de conteneur. Il organise le contrôle de gauche à droite, puis de haut en bas.

Dans l'exemple suivant, un objet Jlabel, un objet JTextField et un objet JButton doivent être affichés dans un JFrame à l'aide du gestionnaire FlowLayout. Pour commencer, importons les classes requises depuis lejavax.swing package et le java.awt paquet.

from javax.swing import JFrame, JLabel, JButton, JTextField
from java.awt import FlowLayout

Créez ensuite un objet JFrame et définissez son emplacement ainsi que les propriétés de taille.

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(200,200)
Set the layout manager for the frame as FlowLayout.
frame.setLayout(FlowLayout())

Déclarez maintenant des objets pour les classes JLabel, JTextfield et JButton.

label = JLabel("Welcome to Jython Swing")
txt = JTextField(30)
btn = JButton("ok")

Enfin, ajoutez ces contrôles dans le cadre en appelant le add() méthode de la classe JFrame.

frame.add(label)
frame.add(txt)
frame.add(btn)

Pour afficher le cadre, définissez sa propriété visible sur true. Le script Jython complet et sa sortie sont indiqués ci-dessous -

from javax.swing import JFrame, JLabel, JButton, JTextField
from java.awt import FlowLayout

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(200,200)

frame.setLayout(FlowLayout())

label = JLabel("Welcome to Jython Swing")
txt = JTextField(30)
btn = JButton("ok")

frame.add(label)
frame.add(txt)
frame.add(btn)
frame.setVisible(True)

Jython GridLayout

Le gestionnaire Gridlayout permet de placer les contrôles dans une grille rectangulaire. Un contrôle est placé dans chaque cellule de la grille.

Dans l'exemple suivant, le GridLayout est appliqué à un objet JFrame en le divisant en 4 lignes et 4 colonnes. Un objet JButton doit être placé dans chaque cellule de la grille.

Importons d'abord les bibliothèques requises -

from javax.swing import JFrame, JButton
from java.awt import GridLayout

Créez ensuite le conteneur JFrame -

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(400,400)

Maintenant, appliquez GridLayout en spécifiant ses dimensions comme 4 par 4.

frame.setLayout(GridLayout(4,4))

Nous devrions maintenant utiliser deux boucles FOR, chacune allant de 1 à 4, donc seize objets JButton sont placés dans les cellules suivantes.

k = 0
frame.setLayout(GridLayout(4,4))
for i in range(1,5):
   for j in range(1,5):
      k = k+1
      frame.add(JButton(str(k)))

Enfin, définissez la visibilité du cadre sur true. Le code Jython complet est donné ci-dessous.

from javax.swing import JFrame, JButton
from java.awt import GridLayout

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(400,400)

frame.setLayout(GridLayout(4,4))

k = 0
for i in range(1,5):
   for j in range(1,5):
      k = k+1
      frame.add(JButton(str(k)))

frame.setVisible(True)

La sortie du code ci-dessus est la suivante -

Bordure Jython

Le gestionnaire BorderLayout divise le conteneur en cinq régions géographiques et lieux avec un composant dans chaque région. Ces régions sont représentées par des constantes définies comme suit -

  • BorderLayout.NORTH
  • BorderLayout.SOUTH
  • BorderLayout.EAST
  • BorderLayout.WEST
  • BorderLayout.CENTER

Prenons l'exemple suivant -

Boîte Jython

La classe BoxLayout est définie dans le javax.swing package. Il est utilisé pour organiser les composants dans le conteneur verticalement ou horizontalement. La direction est déterminée par les constantes suivantes -

  • X_AXIS
  • Y_AXIS
  • LINE_AXIS
  • PAGE_AXIS

La constante entière spécifie l'axe le long duquel les composants du conteneur doivent être disposés. Lorsque le conteneur a l'orientation de composant par défaut, LINE_AXIS spécifie que les composants doivent être disposés de gauche à droite et PAGE_AXIS spécifie que les composants doivent être disposés de haut en bas.

Dans l'exemple suivant, le panneau (de la classe JPanel) est ajouté dans un objet JFrame. Vertical BoxLayout lui est appliqué et deux autres panneaux, haut et bas, y sont ajoutés. Ces deux panneaux internes ont chacun deux boutons ajoutés dans la disposition horizontale de la boîte.

Créons d'abord la fenêtre JFrame de niveau supérieur.

frame = JFrame()
frame.setTitle("Buttons")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setSize(300, 150)

L'objet JPanel est déclaré avec un BoxLayout vertical. Ajoutez-le dans le cadre de niveau supérieur.

panel = JPanel()
panel.setLayout(BoxLayout(panel, BoxLayout.Y_AXIS))
frame.add(panel)

Dans ce panneau, deux autres panneaux en haut et en bas y sont ajoutés. Chacun d'eux a deux objets JButton qui leur sont ajoutés horizontalement avec un espace de 25 pixels les séparant.

###top panel
top = JPanel()
top.setLayout(BoxLayout(top, BoxLayout.X_AXIS))
b1 = JButton("OK")
b2 = JButton("Close")
top.add(Box.createVerticalGlue())
top.add(b1)
top.add(Box.createRigidArea(Dimension(25, 0)))
top.add(b2)

De même, le panneau inférieur est construit.

###bottom panel
bottom = JPanel()
bottom.setLayout(BoxLayout(bottom, BoxLayout.X_AXIS))
b3 = JButton("Open")
b4 = JButton("Save")
bottom.add(b3)
bottom.add(Box.createRigidArea(Dimension(25, 0)))
bottom.add(b4)
bottom.add(Box.createVerticalGlue())

Notez que le createRigidArea()La fonction est utilisée pour créer un espace de 25 pixels entre deux boutons. ÉgalementcreateVerticalGlue() La fonction occupe l'espace de début ou de fin de la mise en page.

Pour commencer, ajoutez les panneaux supérieur et inférieur et définissez la propriété de visibilité du cadre sur true. Le code complet est le suivant -

from java.awt import Dimension
from javax.swing import JButton, JFrame,JPanel,BoxLayout,Box

frame = JFrame()
frame.setTitle("Buttons")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setSize(300, 150)

panel = JPanel()
panel.setLayout(BoxLayout(panel, BoxLayout.Y_AXIS))
frame.add(panel)

###top panel
top = JPanel()
top.setLayout(BoxLayout(top, BoxLayout.X_AXIS))
b1 = JButton("OK")
b2 = JButton("Close")
top.add(Box.createVerticalGlue())
top.add(b1)
top.add(Box.createRigidArea(Dimension(25, 0)))
top.add(b2)

###bottom panel
bottom = JPanel()
bottom.setLayout(BoxLayout(bottom, BoxLayout.X_AXIS))
b3 = JButton("Open")
b4 = JButton("Save")
bottom.add(b3)
bottom.add(Box.createRigidArea(Dimension(25, 0)))
bottom.add(b4)
bottom.add(Box.createVerticalGlue())

panel.add(bottom)
panel.add(top)
frame.setVisible(True)

Le code ci-dessus générera la sortie suivante.

Groupe Jython

Le gestionnaire GroupLayout regroupe les composants de manière hiérarchique. Le regroupement se fait par deux classes,SequentialGroup et ParallelGroup, tous deux implémentent l'interface de groupe en Java.

La procédure de mise en page est divisée en deux étapes. En une seule étape, les composants sont placés le long de l'axe horizontal et en second le long de l'axe vertical. Chaque composant doit être défini deux fois dans la mise en page.

Il existe deux types d'arrangements, séquentiels et parallèles. Dans les deux cas, nous pouvons organiser les composants séquentiellement ou en parallèle. Dans la disposition horizontale, la ligne est appelée groupe séquentiel et la colonne est appelée groupe parallèle. D'autre part, dans un agencement parallèle, la ligne d'élément est un groupe parallèle et une colonne, qui est appelée séquentielle.

Dans l'exemple suivant, cinq boutons sont disposés de telle manière que trois apparaissent chacun en ligne et en colonne. Pour commencer, ajoutez un objet Jpanel dans une fenêtre JFrame et définissez sa disposition sur Grouplayout.

frame =  JFrame()
panel =  JPanel()
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
layout =  GroupLayout(panel)
panel.setLayout(layout)

Puis construisez les objets JButton -

buttonD = JButton("D")
buttonR = JButton("R")
buttonY = JButton("Y")
buttonO = JButton("O")
buttonT = JButton("T")

Ensuite, nous créons un SequentialGroup nommé LeftToRightauquel s'ajoutent buttonD et buttonY. Entre eux, un ParallelGroup ColumnMiddle (avec trois autres boutons ajoutés verticalement) est placé.

leftToRight = layout.createSequentialGroup()
leftToRight.addComponent(buttonD)
columnMiddle = layout.createParallelGroup()
columnMiddle.addComponent(buttonR)
columnMiddle.addComponent(buttonO)
columnMiddle.addComponent(buttonT)
leftToRight.addGroup(columnMiddle)
leftToRight.addComponent(buttonY)

Vient maintenant la définition de SequentialGroup vertical appelé TopToBottom. Ajoutez une ligne ParallelGroup de trois boutons, puis posez deux boutons verticalement.

topToBottom = layout.createSequentialGroup()
rowTop = layout.createParallelGroup()
rowTop.addComponent(buttonD)
rowTop.addComponent(buttonR)
rowTop.addComponent(buttonY)
topToBottom.addGroup(rowTop)
topToBottom.addComponent(buttonO)
topToBottom.addComponent(buttonT)

Enfin, définissez le groupe LeftToRight horizontalement et le groupe TopToBottom verticalement sur l'objet de mise en page. Le code complet est donné ci-dessous -

from javax.swing import JButton, JFrame,JPanel,GroupLayout

frame = JFrame()
panel = JPanel()
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
layout = GroupLayout(panel)
panel.setLayout(layout)

buttonD = JButton("D")
buttonR = JButton("R")
buttonY = JButton("Y")
buttonO = JButton("O")
buttonT = JButton("T")

leftToRight = layout.createSequentialGroup()
leftToRight.addComponent(buttonD)
columnMiddle = layout.createParallelGroup()
columnMiddle.addComponent(buttonR)
columnMiddle.addComponent(buttonO)
columnMiddle.addComponent(buttonT)
leftToRight.addGroup(columnMiddle)
leftToRight.addComponent(buttonY)

topToBottom = layout.createSequentialGroup()
rowTop = layout.createParallelGroup()
rowTop.addComponent(buttonD)
rowTop.addComponent(buttonR)
rowTop.addComponent(buttonY)
topToBottom.addGroup(rowTop)
topToBottom.addComponent(buttonO)
topToBottom.addComponent(buttonT)

layout.setHorizontalGroup(leftToRight)
layout.setVerticalGroup(topToBottom)

frame.add(panel)
frame.pack()
frame.setVisible(True)

La sortie du code ci-dessus est la suivante -

La gestion des événements dans Java swing nécessite que le contrôle (comme JButton ou JList, etc.) soit enregistré auprès de l'écouteur d'événements respectif. L'interface d'écouteur d'événements ou la classe Adapter correspondante doit être implémentée ou sous-classée avec sa méthode de gestion des événements remplacée. En Jython, la gestion des événements est très simple. Nous pouvons passer n'importe quelle fonction en tant que propriété de la fonction de gestion d'événements correspondant au contrôle.

Voyons d'abord comment un événement de clic est géré en Java.

Pour commencer, nous devons importer le java.awt.event package. Ensuite, la classe étendant JFrame doit implémenter l'interface ActionListener.

public class btnclick extends JFrame implements ActionListener

Ensuite, nous devons déclarer l'objet JButton, l'ajouter au ContentPane de frame puis l'enregistrer avec ActionListener par la méthode addActionListener ().

JButton b1 = new JButton("Click here");
   getContentPane().add(b1);
   b1.addActionListener(this);

Désormais, la méthode actionPerformed () de l'interface ActionListener doit être remplacée pour gérer l'événement ActionEvent.

Voici tout le code Java -

import java.awt.event.*;
import javax.swing.*;
public class btnclick extends JFrame implements ActionListener {
   btnclick() {
      JButton b1 = new JButton("Click here");
      getContentPane().add(b1);
      b1.addActionListener(this);
   }
   
   public void actionPerformed(ActionEvent e) {
      System.out.println("Clicked");
   }
   
   public static void main(String args[]) {
      btnclick b = new btnclick();
      b.setSize(300,200);
      b.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      b.setVisible(true);
   }
}

Maintenant, nous allons écrire le code Jython équivalent au même code.

Pour commencer, nous n'avons pas besoin d'importer l'ActionEvent ou l'ActionListener, car le typage dynamique de Jython nous permet d'éviter de mentionner ces classes dans notre code.

Deuxièmement, il n'est pas nécessaire d'implémenter ou de sous-classer ActionListener. Au lieu de cela, toute fonction définie par l'utilisateur est immédiatement fournie au constructeur JButton en tant que valeur deactionPerformed propriété de haricot.

button = JButton('Click here!', actionPerformed = clickhere)

le clickhere() La fonction est définie comme une fonction Jython standard, qui gère l'événement de clic sur le bouton.

def change_text(event):
print clicked!'

Voici le code équivalent Jython.

from javax.swing import JFrame, JButton

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(300,200)

def clickhere(event):
   print "clicked"

btn = JButton("Add", actionPerformed = clickhere)
frame.add(btn)

frame.setVisible(True)

La sortie du code Java et Jython est identique. Lorsque le bouton est cliqué, il imprimera le message «cliqué» sur la console.

Dans le code Jython suivant, deux objets JTextField sont fournis dans la fenêtre JFrame pour entrer des marques dans «phy» et «maths». L'objet JButton exécute la fonction add () lorsque l'utilisateur clique dessus.

btn = JButton("Add", actionPerformed = add)

La fonction add () lit le contenu de deux champs de texte par la méthode getText () et les analyse en entiers, de sorte que l'addition puisse être effectuée. Le résultat est ensuite placé dans le troisième champ de texte par la méthode setText ().

def add(event):
   print "add"
   ttl = int(txt1.getText())+int(txt2.getText())
   txt3.setText(str(ttl))

Le code complet est donné ci-dessous -

from javax.swing import JFrame, JLabel, JButton, JTextField
from java.awt import Dimension

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(300,200)
frame.setLayout(None)

def add(event):
   print "add"
   ttl = int(txt1.getText())+int(txt2.getText())
   txt3.setText(str(ttl))

lbl1 = JLabel("Phy")
lbl1.setBounds(60,20,40,20)
txt1 = JTextField(10)
txt1.setBounds(120,20,60,20)
lbl2 = JLabel("Maths")
lbl2.setBounds(60,50,40,20)
txt2 = JTextField(10)
txt2.setBounds(120, 50, 60,20)
btn = JButton("Add", actionPerformed = add)
btn.setBounds(60,80,60,20)
lbl3 = JLabel("Total")
lbl3.setBounds(60,110,40,20)
txt3 = JTextField(10)
txt3.setBounds(120, 110, 60,20)

frame.add(lbl1)
frame.add(txt1)
frame.add(lbl2)
frame.add(txt2)
frame.add(btn)
frame.add(lbl3)
frame.add(txt3)
frame.setVisible(True)

Lorsque le code ci-dessus est exécuté à partir de l'invite de commande, la fenêtre suivante apparaît. Entrez des marques pour «Phy», Maths »et cliquez sur le bouton« Ajouter ». Le résultat sera affiché en conséquence.

Événement Jython JRadioButton

La classe JRadioButton est définie dans le javax.swing package. Il crée un bouton bascule sélectionnable avec des états d'activation ou de désactivation. Si plusieurs boutons radio sont ajoutés dans un ButtonGroup, leur sélection est mutuellement exclusive.

Dans l'exemple suivant, deux objets de la classe JRadioButton et deux JLabels sont ajoutés à un conteneur Jpanel dans un BoxLayout vertical. Dans le constructeur des objets JRadioButton, leOnCheck()function est définie comme la valeur de la propriété actionPerformed. Cette fonction est exécutée lorsque le bouton radio est cliqué pour changer son état.

rb1 = JRadioButton("Male", True,actionPerformed = OnCheck)
rb2 = JRadioButton("Female", actionPerformed = OnCheck)

Notez que l'état par défaut du bouton radio est faux (non sélectionné). Le bouton rb1 est créé avec son état de départ True (sélectionné).

Les deux boutons radio sont ajoutés à un ButtonGroup radio pour les rendre mutuellement exclusifs, de sorte que si l'un est sélectionné, l'autre est automatiquement désélectionné.

grp = ButtonGroup()
grp.add(rb1)
grp.add(rb2)

Ces deux boutons radio ainsi que deux étiquettes sont ajoutés à un objet de panneau dans la disposition verticale avec une zone de séparation de 25 pixels en hauteur entre rb2 et lbl2.

panel = JPanel()
panel.setLayout(BoxLayout(panel, BoxLayout.Y_AXIS))

panel.add(Box.createVerticalGlue())
panel.add(lbl)
panel.add(rb1)
panel.add(rb2)
panel.add(Box.createRigidArea(Dimension(0,25)))
panel.add(lbl1)

Ce panneau est ajouté à un objet JFrame de niveau supérieur, dont la propriété visible est définie sur «True» à la fin.

frame = JFrame("JRadioButton Example")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(250,200)
frame.setVisible(True)
The complete code of radio.py is given below:
from javax.swing import JFrame, JPanel, JLabel, BoxLayout, Box

from java.awt import Dimension
from javax.swing import JRadioButton,ButtonGroup
frame = JFrame("JRadioButton Example")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(250,200)
panel = JPanel()
panel.setLayout(BoxLayout(panel, BoxLayout.Y_AXIS))
frame.add(panel)

def OnCheck(event):
   lbl1.text = ""
   if rb1.isSelected():
      lbl1.text = lbl1.text+"Gender selection : Male"
   else:
      lbl1.text = lbl1.text+"Gender selection : Female "
      lbl = JLabel("Select Gender")

rb1 = JRadioButton("Male", True,actionPerformed = OnCheck)
rb2 = JRadioButton("Female", actionPerformed = OnCheck)
grp = ButtonGroup()
grp.add(rb1)
grp.add(rb2)

lbl1 = JLabel("Gender Selection :")

panel.add(Box.createVerticalGlue())
panel.add(lbl)
panel.add(rb1)
panel.add(rb2)
panel.add(Box.createRigidArea(Dimension(0,25)))
panel.add(lbl1)

frame.setVisible(True)

Exécutez le script Jython ci-dessus et modifiez la sélection du bouton radio. La sélection apparaîtra dans l'étiquette en bas.

Événement Jython JCheckBox

Comme le JRadioButton, L'objet JCheckBox est également un bouton sélectionnable avec une case à cocher rectangulaire en plus de sa légende. Ceci est généralement utilisé pour permettre à l'utilisateur de sélectionner plusieurs options dans la liste des éléments.

Dans l'exemple suivant, deux cases à cocher et une étiquette du package swing sont ajoutées à un JPanel dans BoxLayout vertical. L'étiquette en bas affiche l'état de sélection instantané de deux cases à cocher.

Les deux cases à cocher sont déclarées avec le constructeur dont la propriété actionPerformed est définie sur OnCheck() fonction.

box1 = JCheckBox("Check1", actionPerformed = OnCheck)
box2 = JCheckBox("Check2", actionPerformed = OnCheck)

La fonction OnCheck () vérifie l'état de sélection de chaque case à cocher et affiche le message correspondant sur l'étiquette en bas.

def OnCheck(event):
   lbl1.text = ""
   if box1.isSelected():
      lbl1.text = lbl1.text + "box1 selected "
   else:
      lbl1.text = lbl1.text + "box1 not selected "
   if box2.isSelected():
      lbl1.text = lbl1.text + "box2 selected"
   else:
      lbl1.text = lbl1.text + "box2 not selected"

Ces boîtes et un objet JLabel sont ajoutés à un JPanel avec un espace réservé de 50 pixels de hauteur ajouté entre eux.

panel = JPanel()
panel.setLayout(BoxLayout(panel, BoxLayout.Y_AXIS))
panel.add(Box.createVerticalGlue())
panel.add(box1)
panel.add(box2)
panel.add(Box.createRigidArea(Dimension(0,50)))
panel.add(lbl1)

Le panneau lui-même est ajouté à une fenêtre JFrame de niveau supérieur, dont la propriété visible est définie sur true à la fin.

frame = JFrame("JCheckBox Example")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(250,150)
frame.add(panel)

frame.setVisible(True)

Exécutez le code ci-dessus et testez la sélection de cases à cocher. L'état instantané des deux cases à cocher est affiché en bas.

Événement JList Jython

Le contrôle JList dans le package swing fournit à l'utilisateur une liste déroulante d'éléments à choisir. La JComboBox propose une liste déroulante d'éléments. En Java, l'événement de sélection est traité en implémentant la méthode valueChanged () dans ListSelectionListener. En Jython, un gestionnaire d'événements est affecté à la propriété valueChanged de l'objet JList.

Dans l'exemple suivant, un objet JList et une étiquette sont ajoutés à un JFrame dans BorderLayout. La JList est remplie avec une collection d'éléments dans un tuple. Sa propriété valueChanged est définie sur la fonction listSelect ().

lang = ("C", "C++", "Java", "Python", "Perl", "C#", "VB", "PHP", "Javascript", "Ruby")
lst = JList(lang, valueChanged = listSelect)

La fonction de gestionnaire d'événements obtient l'index de l'élément sélectionné et extrait l'élément correspondant de l'objet JList à afficher sur l'étiquette en bas.

def listSelect(event):
   index = lst.selectedIndex
   lbl1.text = "Hello" + lang[index]

Les objets JList et JLabel sont ajoutés au JFrame à l'aide de BorderLayout.

Le code complet est donné ci-dessous -

from javax.swing import JFrame, JPanel, JLabel, JList
from java.awt import BorderLayout

frame = JFrame("JList Example")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(300,250)

frame.setLayout(BorderLayout())

def listSelect(event):
   index = lst.selectedIndex
   lbl1.text = "Hello" + lang[index]

lang = ("C", "C++", "Java", "Python", "Perl", "C#", "VB", "PHP", "Javascript", "Ruby")
lst = JList(lang, valueChanged = listSelect)
lbl1 = JLabel("box1 not selected box2 not selected")
frame.add(lst, BorderLayout.NORTH)
frame.add(lbl1, BorderLayout.SOUTH)

frame.setVisible(True)

La sortie du code suivant est la suivante.

La plupart des applications basées sur l'interface graphique ont une barre de menus en haut. Il se trouve juste en dessous de la barre de titre de la fenêtre de niveau supérieur. Le paquet javax.swing a une fonction élaborée pour construire un système de menu efficace. Il est construit avec l'aide deJMenuBar, JMenu et JMenuItem Des classes.

Dans l'exemple suivant, une barre de menus est fournie dans la fenêtre de niveau supérieur. Un menu Fichier composé de trois boutons d'élément de menu est ajouté à la barre de menus. Préparons maintenant un objet JFrame avec la disposition définie sur BorderLayout.

frame = JFrame("JMenuBar example")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(400,300)
frame.setLayout(BorderLayout())

Désormais, un objet JMenuBar est activé par la méthode SetJMenuBar ().

bar = JMenuBar()
frame.setJMenuBar(bar)

Ensuite, un objet JMenu ayant la légende «File» est déclaré. Trois boutons JMenuItem sont ajoutés au menu Fichier. Lorsque vous cliquez sur l'un des éléments de menu, la fonction OnClick () du gestionnaire ActionEvent est exécutée. Il est défini avec la propriété actionPerformed.

file = JMenu("File")
newfile = JMenuItem("New",actionPerformed = OnClick)
openfile = JMenuItem("Open",actionPerformed = OnClick)
savefile = JMenuItem("Save",actionPerformed = OnClick)
file.add(newfile)
file.add(openfile)
file.add(savefile)
bar.add(file)

Le gestionnaire d'événements OnClick () récupère le nom du bouton JMenuItem par la fonction gwtActionCommand () et l'affiche dans la zone de texte en bas de la fenêtre.

def OnClick(event):
   txt.text = event.getActionCommand()

L'objet de menu Fichier est ajouté à la barre de menus. Enfin, un contrôle JTextField est ajouté au bas de l'objet JFrame.

txt = JTextField(10)
frame.add(txt, BorderLayout.SOUTH)

Le code complet de menu.py est donné ci-dessous -

from javax.swing import JFrame, JMenuBar, JMenu, JMenuItem, JTextField
from java.awt import BorderLayout

frame = JFrame("JMenuBar example")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(400,300)
frame.setLayout(BorderLayout())

def OnClick(event):
   txt.text = event.getActionCommand()

bar = JMenuBar()
frame.setJMenuBar(bar)

file = JMenu("File")
newfile = JMenuItem("New",actionPerformed = OnClick)
openfile = JMenuItem("Open",actionPerformed = OnClick)
savefile = JMenuItem("Save",actionPerformed = OnClick)
file.add(newfile)
file.add(openfile)
file.add(savefile)
bar.add(file)

txt = JTextField(10)
frame.add(txt, BorderLayout.SOUTH)

frame.setVisible(True)

Lorsque le script ci-dessus est exécuté à l'aide de l'interpréteur Jython, une fenêtre avec le menu Fichier apparaît. Cliquez dessus et ses trois éléments de menu se dérouleront. Si un bouton est cliqué, son nom sera affiché dans le contrôle de zone de texte.

Un objet Dialog est une fenêtre qui apparaît au-dessus de la fenêtre de base avec laquelle l'utilisateur interagit. Dans ce chapitre, nous verrons les dialogues préconfigurés définis dans la bibliothèque swing. Elles sontMessageDialog, ConfirmDialog et InputDialog. Ils sont disponibles grâce à la méthode statique de la classe JOptionPane.

Dans l'exemple suivant, le menu Fichier comporte trois éléments JMenu correspondant aux trois boîtes de dialogue ci-dessus; chacun exécute leOnClick gestionnaire d'événements.

file = JMenu("File")
msgbtn = JMenuItem("Message",actionPerformed = OnClick)
conbtn = JMenuItem("Confirm",actionPerformed = OnClick)
inputbtn = JMenuItem("Input",actionPerformed = OnClick)
file.add(msgbtn)
file.add(conbtn)
file.add(inputbtn)

La fonction de gestionnaire OnClick () récupère la légende du bouton Élément de menu et appelle la méthode showXXXDialog () respective.

def OnClick(event):
   str = event.getActionCommand()
   if str == 'Message':
      JOptionPane.showMessageDialog(frame,"this is a sample message dialog")
   if str == "Input":
      x = JOptionPane.showInputDialog(frame,"Enter your name")
      txt.setText(x)
   if str == "Confirm":
      s = JOptionPane.showConfirmDialog (frame, "Do you want to continue?")
      if s == JOptionPane.YES_OPTION:
         txt.setText("YES")
      if s == JOptionPane.NO_OPTION:
         txt.setText("NO")
      if s == JOptionPane.CANCEL_OPTION:
         txt.setText("CANCEL")

Si l'option de message du menu est choisie, un message apparaît. Si l'option Entrée est cliquée, une boîte de dialogue demandant l'entrée apparaît. Le texte d'entrée est ensuite affiché dans la zone de texte de la fenêtre JFrame. Si l'option Confirmer est sélectionnée, une boîte de dialogue avec trois boutons, OUI, NON et ANNULER apparaît. Le choix de l'utilisateur est enregistré dans la zone de texte.

Le code complet est donné ci-dessous -

from javax.swing import JFrame, JMenuBar, JMenu, JMenuItem, JTextField
from java.awt import BorderLayout
from javax.swing import JOptionPane
frame = JFrame("Dialog example")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(400,300)
frame.setLayout(BorderLayout())

def OnClick(event):
   str = event.getActionCommand()
   if str == 'Message':
      JOptionPane.showMessageDialog(frame,"this is a sample message dialog")
   if str == "Input":
      x = JOptionPane.showInputDialog(frame,"Enter your name")
      txt.setText(x)
   if str == "Confirm":
      s = JOptionPane.showConfirmDialog (frame, "Do you want to continue?")
      if s == JOptionPane.YES_OPTION:
         txt.setText("YES")
      if s == JOptionPane.NO_OPTION:
         txt.setText("NO")
      if s == JOptionPane.CANCEL_OPTION:
         txt.setText("CANCEL")

bar = JMenuBar()
frame.setJMenuBar(bar)

file = JMenu("File")
msgbtn = JMenuItem("Message",actionPerformed = OnClick)
conbtn = JMenuItem("Confirm",actionPerformed = OnClick)
inputbtn = JMenuItem("Input",actionPerformed = OnClick)
file.add(msgbtn)
file.add(conbtn)
file.add(inputbtn)
bar.add(file)
txt = JTextField(10)
frame.add(txt, BorderLayout.SOUTH)
frame.setVisible(True)

Lorsque le script ci-dessus est exécuté, la fenêtre suivante s'affiche avec trois options dans le menu -

Messagerie

Zone de saisie

Confirmer la boîte de dialogue

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved