Jython - Kurzanleitung

Jython ist die JVM-Implementierung der Programmiersprache Python. Es kann auf der Java-Plattform ausgeführt werden. Ein Jython-Programm kann jede Java-Klasse importieren und verwenden. Genau wie Java kompiliert das Jython-Programm zubytecode. Einer der Hauptvorteile ist, dass eine in Python entwickelte Benutzeroberfläche GUI-Elemente von verwenden kannAWT, Swing oder SWT Package.

Jython, das als JPython begann und später umbenannt wurde, folgt genau der Standard-Python-Implementierung namens CPython wie erstellt von Guido Van Rossum. Jython wurde 1997 von erstelltJim Hugunin. Jython 2.0 wurde 1999 veröffentlicht. Seitdem entsprechen Jython 2.x-Versionen äquivalenten CPython-Versionen. Jython 2.7.0, das im Mai 2015 veröffentlicht wurde, entspricht CPython 2.7. Die Entwicklung von Jython 3.x ist im Gange.

Unterschied zwischen Python und Java

Im Folgenden sind die Unterschiede zwischen Python und Java aufgeführt:

  • Python ist eine dynamisch typisierte Sprache. Daher wird die Typdeklaration der Variablen nicht benötigt. Java hingegen ist eine statisch typisierte Sprache. Dies bedeutet, dass die Typdeklaration der Variablen obligatorisch ist und nicht geändert werden kann.

  • Python hat nur nicht aktivierte Ausnahmen, während Java sowohl aktivierte als auch deaktivierte Ausnahmen hat.

  • Python verwendet Einrückungen für das Scoping, während Java passende geschweifte Klammern verwendet.

  • Da Python eine interpretatorbasierte Sprache ist, gibt es keine separaten Kompilierungsschritte. Ein Java-Programm muss jedoch zu Bytecode kompiliert werden und wird wiederum von einer JVM ausgeführt.

  • Python unterstützt Mehrfachvererbung, aber in Java ist Mehrfachvererbung nicht möglich. Es hat jedoch die Implementierung einer Schnittstelle.

  • Im Vergleich zu Java verfügt Python über umfangreichere integrierte Datenstrukturen (Listen, Diktate, Tupel, alles ist ein Objekt).

Unterschied zwischen Python und Jython

Im Folgenden sind die Unterschiede zwischen Python und Jython aufgeführt:

  • Die Referenzimplementierung von Python, CPython genannt, ist in C-Sprache geschrieben. Jython hingegen ist vollständig in Java geschrieben und eine JVM-Implementierung.

  • Standard Python ist auf mehreren Plattformen verfügbar. Jython ist für jede Plattform verfügbar, auf der eine JVM installiert ist.

  • Standard-Python-Code wird zu a kompiliert .pyc Datei, während Jython-Programm zu a kompiliert .class Datei.

  • Python-Erweiterungen können in C-Sprache geschrieben werden. Erweiterungen für Jython sind in Java geschrieben.

  • Jython ist von Natur aus ein Multithread-Unternehmen. Python verwendet jedoch dieGlobal Interpreter Lock (GIL) Mechanismus für den Zweck.

  • Beide Implementierungen verfügen über unterschiedliche Speicherbereinigungsmechanismen.

Im nächsten Kapitel erfahren Sie, wie Sie die Java-Bibliotheken in Jython importieren.

Stellen Sie vor der Installation von Jython 2.7 sicher, dass das System über Folgendes verfügt JDK 7oder mehr installiert. Jython ist in Form einer ausführbaren JAR-Datei verfügbar. Laden Sie es herunter von -http://www.jython.org/downloads.html und doppelklicken Sie entweder auf das entsprechende Symbol oder führen Sie den folgenden Befehl aus:

java -jar jython_installer-2.7.0.jar

Ein Installationsassistent wird gestartet, mit dem Installationsoptionen angegeben werden müssen. Hier ist der systematische Installationsvorgang.

Im ersten Schritt des Assistenten werden Sie aufgefordert, die Sprache auszuwählen.

Im zweiten Schritt werden Sie aufgefordert, die Lizenzvereinbarung zu akzeptieren.

Wählen Sie im nächsten Schritt den Installationstyp. Es wird empfohlen, die Standardinstallation zu wählen.

Der nächste Bildschirm fordert Sie zur Bestätigung Ihrer Optionen auf und fährt mit dem Abschluss der Installation fort.

Der Installationsvorgang kann einige Zeit dauern.

Rufen Sie nach Abschluss der Installation auf jython.exeaus dem bin-Verzeichnis im Zielverzeichnis. Angenommen, Jython ist in installiertC:\jython27Führen Sie Folgendes über die Befehlszeile aus.

C:\jython27\bin\jython

Eine Python-Eingabeaufforderung (>>>) wird angezeigt, vor der jede Python-Anweisung oder jedes Python-Skript ausgeführt werden kann.

Eine der wichtigsten Funktionen von Jython ist die Möglichkeit, Java-Klassen in ein Python-Programm zu importieren. Wir können jedes Java-Paket oder jede Java-Klasse in Jython importieren, genau wie in einem Java-Programm. Das folgende Beispiel zeigt, wie diejava.util Pakete werden in das Python-Skript (Jython) importiert, um ein Objekt der Date-Klasse zu deklarieren.

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

Speichern Sie den obigen Code und führen Sie ihn aus als UtilDate.pyvon der Kommandozeile. Die Instanz des aktuellen Datums und der aktuellen Uhrzeit wird angezeigt.

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

Die folgenden Pakete aus der Java-Bibliothek werden häufiger in ein Jython-Programm importiert, hauptsächlich weil die Standard-Python-Bibliothek entweder nicht die entsprechenden Entsprechungen aufweist oder nicht so gut ist.

  • Servlets
  • JMS
  • J2EE
  • Javadoc
  • Swing gilt als überlegen gegenüber anderen GUI-Toolkits

Jedes Java-Paket kann in ein Jython-Skript importiert werden. Hier wird das folgende Java-Programm in einem Paket namens gespeichert und kompiliertfoo.

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

Diese HelloWorld.classwird in das folgende Jython-Skript importiert. Methoden in dieser Klasse können über das Jython-Skript aufgerufen werdenimportex.py.

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

Speichern Sie das obige Skript und führen Sie es über die Befehlszeile aus, um die folgende Ausgabe zu erhalten.

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

Variablen werden als Speicherorte im Computerspeicher bezeichnet. Jede Variable kann ein Datenelement enthalten. Im Gegensatz zu Java ist Python eine dynamisch typisierte Sprache. Daher auch bei der Verwendung von Jython; Eine vorherige Deklaration des Datentyps der Variablen erfolgt nicht. Anstelle des Variablentyps, der entscheidet, welche Daten darin gespeichert werden können, bestimmen die Daten den Variablentyp.

Im folgenden Beispiel wird einer Variablen ein ganzzahliger Wert zugewiesen. Mit der integrierten Funktion type () können wir überprüfen, ob der Variablentyp eine Ganzzahl ist. Wenn jedoch derselben Variablen eine Zeichenfolge zugewiesen wird, wird die Funktion type () als Typ derselben Variablen Zeichenfolge.

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

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

Dies erklärt, warum Python als dynamisch typisierte Sprache bezeichnet wird.

Die folgenden in Python integrierten Datentypen können auch in Jython verwendet werden:

  • Number
  • String
  • List
  • Tuple
  • Dictionary

Python erkennt numerische Daten als eine Zahl, die eine Ganzzahl, eine reelle Zahl mit Gleitkomma oder eine komplexe Zahl sein kann. String-, List- und Tuple-Datentypen werden als Sequenzen bezeichnet.

Jython-Nummern

In Python wird jede vorzeichenbehaftete Ganzzahl vom Typ 'int' genannt. Um eine lange Ganzzahl auszudrücken, wird der Buchstabe 'L' angehängt. Eine Zahl mit einem Dezimalpunkt, der den ganzzahligen Teil von einer Bruchkomponente trennt, wird als "float" bezeichnet. Der Bruchteil kann einen Exponenten enthalten, der in der wissenschaftlichen Notation mit 'E' oder 'e' ausgedrückt wird.

Eine komplexe Zahl wird in Python auch als numerischer Datentyp definiert. Eine komplexe Zahl enthält einen Realteil (eine Gleitkommazahl) und einen Imaginärteil, an den 'j' angehängt ist.

Um eine Zahl in der Oktal- oder Hexadezimaldarstellung auszudrücken, 0O oder 0Xwird vorangestellt. Der folgende Codeblock enthält Beispiele für verschiedene Darstellungen von Zahlen in 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

Jython Strings

Eine Zeichenfolge ist eine beliebige Folge von Zeichen, die in einfache (z. B. "Hallo"), doppelte (z. B. "Hallo") oder dreifache (z. B. "Hallo" oder "Hallo") Anführungszeichen eingeschlossen sind. Dreifache Anführungszeichen sind besonders nützlich, wenn sich der Inhalt der Zeichenfolge über mehrere Zeilen erstreckt.

Die Escape-Sequenzzeichen können wörtlich in eine dreifach zitierte Zeichenfolge eingefügt werden. Die folgenden Beispiele zeigen verschiedene Möglichkeiten, eine Zeichenfolge in Python zu deklarieren.

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.
"""

Die dritte Zeichenfolge gibt beim Drucken die folgende Ausgabe aus.

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.

Jython-Listen

Eine Liste ist ein Sequenzdatentyp. Es handelt sich um eine Sammlung von durch Kommas getrennten Elementen, die nicht unbedingt vom gleichen Typ sind und in eckigen Klammern gespeichert sind. Auf einzelne Elemente aus der Liste kann über den auf Null basierenden Index zugegriffen werden.

Der folgende Codeblock fasst die Verwendung einer Liste in Python zusammen.

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]

In der folgenden Tabelle werden einige der häufigsten Jython-Ausdrücke für Jython-Listen beschrieben.

Jython-Ausdruck Beschreibung
len (Liste) Länge
Liste [2] = 10 Aktualisierung
Del List [1] Streichung
List.append (20) Anhängen
List.insert (1,15) Einfügen
List.sort () Sortierung

Jython Tupel

Ein Tupel ist eine unveränderliche Sammlung von durch Kommas getrennten Datenelementen, die in Klammern gespeichert sind. Es ist weder möglich, ein Element in Tupel zu löschen oder zu ändern, noch ist es möglich, der Tupelsammlung ein Element hinzuzufügen. Der folgende Codeblock zeigt Tupeloperationen.

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]

Jython-Wörterbuch

Das Jython-Wörterbuch ähnelt der Map-Klasse im Java Collection-Framework. Es ist eine Sammlung von Schlüssel-Wert-Paaren. Durch Komma getrennte Paare sind in geschweiften Klammern eingeschlossen. Ein Dictionary-Objekt folgt nicht dem auf Null basierenden Index, um darin enthaltene Elemente abzurufen, da diese durch Hashing-Techniken gespeichert werden.

Der gleiche Schlüssel kann in einem Wörterbuchobjekt nur einmal vorkommen. Es kann jedoch mehr als ein Schlüssel dieselben zugeordneten Werte haben. Verschiedene Funktionen, die mit dem Dictionary-Objekt verfügbar sind, werden unten erläutert -

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

In der folgenden Tabelle werden einige der häufigsten Jython-Ausdrücke im Zusammenhang mit Dictionary beschrieben.

Jython-Ausdruck Beschreibung
dict.get ('011') Suche
len (dikt) Länge
dict ['044'] = 'Chennai' Anhängen
del dict ['022'] Löschen
dict.keys () Liste der Schlüssel
dict.values ​​() Liste von Werten
dict.clear () Entfernt alle Elemente

Zusätzlich zu den in Python integrierten Datentypen bietet Jython den Vorteil, dass Java-Auflistungsklassen durch Importieren von verwendet werden java.util package. Der folgende Code beschreibt die unten angegebenen Klassen -

  • Java ArrayList-Objekt mit add ()
  • remove()
  • get () - und set () -Methoden der ArrayList-Klasse.
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

Das obige Jython-Skript erzeugt die folgende Ausgabe:

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

Jarray Klasse

Jython implementiert auch das Jarray Object, mit dem ein Java-Array in Python erstellt werden kann. Um mit einem Jarray zu arbeiten, definieren Sie einfach einen Sequenztyp in Jython und übergeben Sie ihn zusammen mit dem in der Sequenz enthaltenen Objekttyp an das Jarray-Objekt. Alle Werte in einem Jarray müssen vom gleichen Typ sein.

Die folgende Tabelle zeigt die Zeichentypcodes, die mit einem Jarray verwendet werden.

Zeichentypcode Entsprechender Java-Typ
Z. Boolescher Wert
C. verkohlen
B. Byte
H. kurz
ich int
L. lange
F. schweben
D. doppelt

Das folgende Beispiel zeigt den Aufbau von 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

Hier my_seqist definiert als ein Tupel von ganzen Zahlen. Es wird in Jarray arr1 umgewandelt. Das zweite Beispiel zeigt, dass Jarray arr2 aus aufgebaut istmySttr stringReihenfolge. Die Ausgabe des obigen Skriptsjarray.py ist wie folgt -

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

Entscheidungsstrukturen haben eine oder mehrere Bedingungen, die vom Programm bewertet oder getestet werden müssen, zusammen mit einer Anweisung oder Anweisungen, die ausgeführt werden sollen, wenn die Bedingung als wahr bestimmt wird, und optional andere Anweisungen, die ausgeführt werden sollen, wenn die Bedingung erfüllt ist wird als falsch bestimmt.

Die folgende Abbildung zeigt die allgemeine Form einer typischen Entscheidungsstruktur, die in den meisten Programmiersprachen zu finden ist.

Jython verwendet keine geschweiften Klammern, um Anweisungsblöcke anzugeben, die ausgeführt werden sollen, wenn die Bedingung wahr oder falsch ist (wie dies in Java der Fall ist). Stattdessen wird ein einheitlicher Einzug (Leerraum vom linken Rand) verwendet, um einen Anweisungsblock zu bilden. Solch ein einheitlich eingerückter Block bewirkt, dass der Bedingungscode ausgeführt wird, wenn eine in der 'if'-Anweisung angegebene Bedingung wahr ist.

Ein ähnlicher Block kann nach einer optionalen 'else'-Anweisung vorhanden sein. Jython bietet auch dieelif statementunter welchen aufeinanderfolgenden Bedingungen getestet werden kann. Hier daselse clausewird zuletzt angezeigt und nur ausgeführt, wenn alle vorhergehenden Bedingungen fehlschlagen. Die allgemeine Syntax der Verwendungif..elif..else ist wie folgt.

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

Im folgenden Beispiel, wenn ..elif ..else Konstrukt wird verwendet, um den Rabatt auf verschiedene Werte des vom Benutzer eingegebenen Betrags zu berechnen.

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

Die Ausgabe des obigen Codes erfolgt wie unten gezeigt.

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

Im Allgemeinen werden Anweisungen in einem Programm nacheinander ausgeführt: Die erste Anweisung in einer Funktion wird zuerst ausgeführt, gefolgt von der zweiten usw. Es kann vorkommen, dass Sie einen Codeblock mehrmals ausführen müssen. Anweisungen, die eine solche Wiederholungsfunktion bereitstellen, werden aufgerufenlooping statements.

In Jython kann eine Schleife durch zwei Anweisungen gebildet werden:

  • Das while Aussage und

  • Das for Erklärung

Die WHILE-Schleife

Eine while-Schleifenanweisung in Jython ähnelt der in Java. Es führt wiederholt einen Anweisungsblock aus, solange eine bestimmte Bedingung erfüllt ist. Das folgende Flussdiagramm beschreibt das Verhalten von awhile Schleife.

Die allgemeine Syntax der while-Anweisung ist unten angegeben.

while expression:
   statement(s)

Der folgende Jython-Code verwendet die while-Schleife, um den Wert einer Variablen wiederholt zu erhöhen und zu drucken, bis er kleiner als Null ist.

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

Output - Die Ausgabe wäre wie folgt.

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

Die FOR-Schleife

Die FOR-Schleife in Jython ist keine gezählte Schleife wie in Java. Stattdessen können Elemente in einem Sequenzdatentyp wie Zeichenfolge, Liste oder Tupel durchlaufen werden. Die allgemeine Syntax der FOR-Anweisung in Jython lautet wie folgt:

for iterating_var in sequence:
   statements(s)

Wir können jedes Zeichen in einer Zeichenfolge sowie jedes Element in einer Liste oder einem Tupel anzeigen, indem wir die FOR-Anweisung verwenden, wie unten gezeigt -

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

Output - Die Ausgabe wäre wie folgt.

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

Betrachten wir eine andere Instanz wie folgt.

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

Output - Die Ausgabe erfolgt wie folgt.

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

Hier ist eine weitere zu berücksichtigende Instanz.

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

Output - Die Ausgabe des obigen Programms ist wie folgt.

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

In Jython ist die forDie Anweisung wird auch verwendet, um eine Liste von Zahlen zu durchlaufen, die von der Funktion range () generiert wurden. Die Funktion range () hat folgende Form:

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

Die Start- und Schrittparameter sind standardmäßig 0 und 1. Die zuletzt generierte Nummer ist Stop Step. Die FOR-Anweisung durchläuft die von derrange() function. Zum Beispiel -

for num in range(5):
   print num

Es erzeugt die folgende Ausgabe -

0
1
2
3
4

Eine komplexe Programmierlogik wird in einen oder mehrere unabhängige und wiederverwendbare Anweisungsblöcke unterteilt, die als Funktionen bezeichnet werden. Die Standardbibliothek von Python enthält eine große Anzahl integrierter Funktionen. Man kann auch ihre eigene Funktion mit dem definierendefStichwort. Auf den benutzerdefinierten Namen der Funktion folgt ein Anweisungsblock, der den Hauptteil bildet und mit der return-Anweisung endet.

Einmal definiert, kann es beliebig oft aus jeder Umgebung aufgerufen werden. Betrachten wir den folgenden Code, um den Punkt klar zu machen.

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

#calling the function
SayHello()

Eine Funktion kann so gestaltet sein, dass sie einen oder mehrere Parameter / Argumente von der aufrufenden Umgebung empfängt. Während Sie eine solche parametrisierte Funktion aufrufen, müssen Sie dieselbe Anzahl von Parametern mit ähnlichen Datentypen angeben, die in der Funktionsdefinition verwendet werden. Andernfalls löst der Jython-Interpreter a ausTypeError Ausnahme.

Beispiel

#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)

Das output wird wie folgt sein -

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

Nach Ausführung der darin definierten Schritte kehrt die aufgerufene Funktion zur aufrufenden Umgebung zurück. Es kann die Daten zurückgeben, wenn in der Definition der Funktion ein Ausdruck vor dem Schlüsselwort return angegeben wird.

#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

Die folgende Ausgabe wird erhalten, wenn das obige Skript über die Jython-Eingabeaufforderung ausgeführt wird.

area = 200
value returned by function : 200

Ein Modul ist ein Jython-Skript, in dem eine oder mehrere verwandte Funktionen, Klassen oder Variablen definiert sind. Dies ermöglicht eine logische Organisation des Jython-Codes. Die in einem Modul definierten Programmelemente können in einem anderen Jython-Skript verwendet werden, indem entweder das Modul oder das spezifische Element (Funktion / Klasse) daraus importiert wird.

Im folgenden Code (hello.py) eine Funktion SayHello() ist definiert.

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

Importieren Sie die Funktion SayHello () aus einem anderen Skript, um sie zu verwenden hello.py module drin.

import hello
hello.SayHello("TutorialsPoint")

Dadurch werden jedoch alle im Modul definierten Funktionen importiert. Verwenden Sie die folgende Syntax, um bestimmte Funktionen aus dem Modul zu importieren.

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

Um beispielsweise nur die Funktion SayHello () zu importieren, ändern Sie das obige Skript wie folgt.

from hello import SayHello
SayHello("TutorialsPoint")

Beim Aufrufen der Funktion muss dem Namen des Moduls kein Präfix vorangestellt werden.

Jeder Ordner, der ein oder mehrere Jython-Module enthält, wird als Paket erkannt. Es muss jedoch eine spezielle Datei namens haben__init__.py, der den Index der zu verwendenden Funktionen bereitstellt.

Lassen Sie uns nun verstehen, wie Sie ein Paket erstellen und importieren.

Step 1 - Erstellen Sie einen Ordner namens package1Erstellen und speichern Sie dann Folgendes g Module darin.

#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 - Erstellen und speichern Sie im Ordner package1 die __init__.py Datei mit folgendem Inhalt.

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

Step 3 - Erstellen Sie das folgende Jython-Skript außerhalb des Ordners package1 als 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- Führen Sie test.py an der Jython-Eingabeaufforderung aus. Die folgende Ausgabe wird erhalten.

factorial = 120
addition = 30
multiplication = 200

Herunterladen jython-standalone-2.7.0.jar - Zum Einbetten von Jython in Java-Anwendungen von der offiziellen Downloadseite: http://www.jython.org/downloads.html und fügen Sie diese JAR-Datei in die Umgebungsvariable Java CLASSPATH ein.

Diese Bibliothek enthält die PythonInterpreterKlasse. Mit dem Objekt dieser Klasse kann jedes Python-Skript mit dem ausgeführt werdenexecfile()Methode. Mit dem PythonInterpreter können Sie verwendenPyObjectsdirekt. Alle dem Jython-Laufzeitsystem bekannten Objekte werden durch eine Instanz der Klasse PyObject oder eine ihrer Unterklassen dargestellt.

Die PythonInterpreter-Klasse verfügt über einige regelmäßig verwendete Methoden, die in der folgenden Tabelle erläutert werden.

Sr.Nr. Methode & Beschreibung
1

setIn(PyObject)

Legen Sie das Python-Objekt fest, das für den Standardeingabestream verwendet werden soll
2

setIn(java.io.Reader)

Legen Sie einen java.io.Reader fest, der für den Standardeingabestream verwendet werden soll
3

setIn(java.io.InputStream)

Legen Sie einen java.io.InputStream fest, der für den Standardeingabestream verwendet werden soll
4

setOut(PyObject)

Legen Sie das Python-Objekt fest, das für den Standardausgabestream verwendet werden soll
5

setOut(java.io.Writer)

Stellen Sie den java.io.Writer so ein, dass er für den Standardausgabestream verwendet wird
6

setOut(java,io.OutputStream)

Stellen Sie den java.io.OutputStream so ein, dass er für den Standardausgabestream verwendet wird
7

setErr(PyObject)

Legen Sie ein Python-Fehlerobjekt fest, das für den Standardfehlerstrom verwendet werden soll
8

setErr(java.io.Writer

Legen Sie einen java.io.Writer fest, der für den Standardfehlerstrom verwendet werden soll
9

setErr(java.io.OutputStream)

Legen Sie einen java.io.OutputStream fest, der für den Standardfehlerstrom verwendet werden soll
10

eval(String)

Bewerten Sie eine Zeichenfolge als Python-Quelle und geben Sie das Ergebnis zurück
11

eval(PyObject)

Bewerten Sie ein Python-Codeobjekt und geben Sie das Ergebnis zurück
12

exec(String)

Führen Sie eine Python-Quellzeichenfolge im lokalen Namespace aus
13

exec(PyObject)

Führen Sie ein Python-Codeobjekt im lokalen Namespace aus
14

execfile(String filename)

Führen Sie eine Datei der Python-Quelle im lokalen Namespace aus
15

execfile(java.io.InputStream)

Führen Sie einen Eingabestream der Python-Quelle im lokalen Namespace aus
16

compile(String)

Kompilieren Sie eine Python-Quellzeichenfolge als Ausdruck oder Modul
17

compile(script, filename)

Kompilieren Sie ein Skript der Python-Quelle als Ausdruck oder Modul
18

set(String name, Object value)

Legen Sie eine Variable vom Typ Objekt im lokalen Namespace fest
19

set(String name, PyObject value)

Legen Sie eine Variable vom Typ PyObject im lokalen Namespace fest
20

get(String)

Ruft den Wert einer Variablen im lokalen Namespace ab
21

get(String name, Class javaclass

Ruft den Wert einer Variablen im lokalen Namespace ab. Der Wert wird als Instanz der angegebenen Java-Klasse zurückgegeben.

Der folgende Codeblock ist ein Java-Programm mit einem eingebetteten Jython-Skript “hello.py”.usingexecfile()Methode des PythonInterpreter-Objekts. Es zeigt auch, wie eine Python-Variable mit den Methoden set () und get () gesetzt oder gelesen werden kann.

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 ");
   }
}

Kompilieren Sie das obige Java-Programm und führen Sie es aus, um die folgende Ausgabe zu erhalten.

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

PyDev ist ein Open Source-Plugin für Eclipse IDE, mit dem Projekte in Python, Jython und IronPython entwickelt werden können. Es wird gehostet beihttps://pydev.org. Im Folgenden finden Sie eine schrittweise Anleitung zum Installieren des PyDev-Plugins in der Eclipse-IDE.

Step 1 - Öffnen Sie die Eclipse-IDE und wählen Sie die Install New Software Option aus dem Menü Hilfe.

Step 2 - Geben Sie ein http://pydev.org/updatesKlicken Sie im Textfeld vor der Arbeit mit dem Etikett auf Hinzufügen. Wählen Sie alle verfügbaren Einträge in der Liste aus und klicken Sie auf Weiter. Der Assistent benötigt einige Minuten, um die Installation abzuschließen, und fordert die IDE zum Neustart auf.

Step 3- Wählen Sie nun die Option Einstellungen aus dem Menü Fenster. Das Dialogfeld "Einstellungen" wird wie unten gezeigt geöffnet.

Step 4- Erweitern Sie den Knoten Interpreters und wählen Sie im linken Bereich Jython Interpreter aus. Klicken Sie im rechten Bereich auf Neu, um den Pfad zum anzugebenjython.jar file.

Wir sind jetzt bereit, ein Jython-Projekt mit Eclipse zu starten.

Um ein Projekt in Eclipse zu erstellen, sollten Sie die folgenden Schritte ausführen.

Step 1- Datei auswählen? Neu ? Projekt. WählenPyDevaus dem Filterdialog. Geben Sie den Projektnamen und den Projekttyp an und klicken Sie auf Fertig stellen.

Step 2- Hallo Projekt wird jetzt im Projektexplorer auf der linken Seite angezeigt. Klicken Sie mit der rechten Maustaste, um hello.py hinzuzufügen.

Step 3- Eine leere hello.py wird im Editor angezeigt. Schreiben Sie den Jython-Code und speichern Sie ihn.

Step 4- Klicken Sie in der Menüleiste auf die Schaltfläche Ausführen. Die Ausgabe wird wie unten gezeigt im Konsolenfenster angezeigt.

Python- und Jython-Unterstützung für NetBeans ist über das verfügbar nbPython plugin. Laden Sie das Plugin von folgender URL herunter -http://plugins.netbeans.org/plugin/56795. Entpacken Sie das heruntergeladene Archiv in einen Ordner. Zum Beispiel -d:\nbplugin. Führen Sie die folgenden Schritte aus, um das NetBeans-Plugin zu installieren.

Step 1 - Starten Sie die Netbeans IDEund gehen Sie dann zu Tools / Plugin, um den Plugin Manager zu öffnen. Wählen Sie die Registerkarte "Heruntergeladen" und navigieren Sie zu dem Ordner, in dem die heruntergeladene Datei entpackt wurde. Das NetBeans-Fenster wird wie folgt angezeigt.

Step 2 - Der nächste Schritt ist die Auswahl aller .nbm Dateien und klicken Sie auf Öffnen.

Step 3 - Klicken Sie auf die Schaltfläche Installieren.

Step 4 - Akzeptieren Sie die folgende Lizenzvereinbarung, um fortzufahren.

Ignorieren Sie die Warnung bezüglich der nicht vertrauenswürdigen Quelle von Plugins und starten Sie die IDE neu, um fortzufahren.

Jython-Projekt in NetBeans

Starten Sie nach dem Neustart ein neues Projekt, indem Sie Datei / Neu wählen. Die Python-Kategorie ist jetzt in der Kategorieliste verfügbar. Wählen Sie es aus, um fortzufahren.

Wenn auf dem System Python installiert ist, werden seine Version / Versionen automatisch erkannt und in der Dropdown-Liste der Python-Plattform angezeigt. Jython wird jedoch nicht aufgelistet. Klicken Sie auf die Schaltfläche Verwalten, um es hinzuzufügen.

Klicken Sie auf die Schaltfläche "Neu", um der ausführbaren Jython-Datei einen Plattformnamen und einen Pfad hinzuzufügen.

Jython wird jetzt in der Plattformliste verfügbar sein. Wählen Sie aus der Dropdown-Liste aus, wie im folgenden Screenshot gezeigt.

Wir können jetzt den Projektnamen, den Speicherort und die Hauptdatei im nächsten Fenster eingeben.

Die Projektstruktur wird im Projektfenster der NetBeans-IDE und ein Python-Vorlagencode im Editorfenster angezeigt.

Erstellen Sie das Jython-Projekt und führen Sie es aus, um das folgende Ergebnis im Ausgabefenster der NetBeans-IDE zu erhalten.

Ein Java-Servlet ist die am häufigsten verwendete Webentwicklungstechnik. Wir können Jython zum Schreiben von Servlets verwenden, und dies bietet viele weitere Vorteile, die über das Angebot von Java hinausgehen, da wir jetzt auch die Python-Sprachfunktionen nutzen können.

Wir werden die NetBeans-IDE verwenden, um eine Java-Webanwendung mit einem Jython-Servlet zu entwickeln. Stellen Sie sicher, dass dienbPython pluginwird in der NetBeans-Installation installiert. Starten Sie ein neues Projekt zum Erstellen einer Webanwendung, indem Sie den folgenden Pfad auswählen:File → New Project → Java web → New Web Application.

Geben Sie den Projektnamen und den Speicherort an. Die IDE erstellt die Projektordnerstruktur. Fügen Sie im Fenster Projekte eine Java-Servlet-Datei (ServletTest.java) unter dem Knoten Quellpakete hinzu. Dies wird hinzufügenservlet-api.jarim lib-Ordner des Projekts. Lassen Sie die IDE auch die Datei web.xml erstellendescriptor file. Fügen Sie den folgenden Code hinzuServletTest.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>"
      );
   }
}

Die von NetBeans erstellte Datei web.xml sieht wie folgt aus:

<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>

Erstellen Sie das Projekt und führen Sie es aus, um den Text zu erhalten Servlet Testwird im Browserfenster im <h1> -Tag angezeigt. Daher haben wir der Anwendung ein reguläres Java-Servlet hinzugefügt.

Nun werden wir das Jython-Servlet hinzufügen. Jython-Servlets arbeiten mit einem Java-Zwischenservlet, das auch als PyServlet bezeichnet wird. Die PyServlet.class ist in der vorhandenjython standalone.jar. Fügen Sie es in dieWEB-INF/lib Mappe.

Der nächste Schritt besteht darin, die Datei web.xml so zu konfigurieren, dass das PyServlet bei jeder Anforderung aufgerufen wird *.py filewird angehoben. Dies sollte durch Hinzufügen des folgenden XML-Codes erfolgen.

<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>

Der vollständige web.xml-Code sieht wie folgt aus.

<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>

Platzieren Sie den folgenden Jython-Code im Ordner WEB-INF im Projektordner als JythonServlet.py, was der vorherigen Datei ServletTest.java entspricht.

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>"
      )

Erstellen Sie das Projekt und öffnen Sie im Browser die folgende URL:

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

Der Browser zeigt die Servlet Test im <h1> -Tag wie bei der Java-Servlet-Ausgabe.

Jython verwendet die zxJDBC packageDies bietet einen benutzerfreundlichen Python-Wrapper für JDBC. zxJDBC verbindet zwei Standards:JDBC ist die Standardplattform für den Datenbankzugriff in Java und DBI ist die Standard-Datenbank-API für Python-Apps.

ZxJDBC bietet eine DBI 2.0-Standard-kompatible Schnittstelle zu JDBC. Für JDBC stehen über 200 Treiber zur Verfügung, die alle mit zxJDBC arbeiten. Hochleistungstreiber sind für alle wichtigen relationalen Datenbanken verfügbar, einschließlich -

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

Das ZxJDBC-Paket kann von heruntergeladen werden https://sourceforge.net/projects/zxjdbc/ oder http://www.ziclix.com/zxjdbc/. Das heruntergeladene Archiv enthält die Datei ZxJDBC.jar, die der Umgebungsvariablen CLASSPATH hinzugefügt werden sollte.

Wir beabsichtigen, eine Datenbankkonnektivität mit der MySQL-Datenbank herzustellen. Zu diesem Zweck wird der JDBC-Treiber für MySQL benötigt. Laden Sie dieMySQL J connector vom folgenden Link - https://dev.mysql.com/downloads/connector/j/ und fügen Sie den MySQL-Connector java-5.1.42-bin.jar in den CLASSPATH ein.

Melden Sie sich beim MySQL-Server an und erstellen Sie eine Schülertabelle in der Testdatenbank mit der folgenden Struktur:

Feld Art Breite
Name Varchar 10
Alter Int 3
Markierungen Int 3

Fügen Sie ein paar Datensätze hinzu.

Name Alter Markierungen
Ravi 21 78
Ashok 20 65
Anil 22 71

Erstellen Sie das folgende Jython-Skript als 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

Führen Sie das obige Skript an der Jython-Eingabeaufforderung aus. Die Aufzeichnungen in der Schülertabelle werden wie folgt aufgeführt:

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

Dies erklärt das Verfahren zum Einrichten von JDBC in Jython.

Eine der Hauptfunktionen von Jython ist die Fähigkeit, die Swing-GUI-Bibliothek in JDK zu verwenden. Die Standard-Python-Distribution (oft als CPython bezeichnet) hat dieTkinter GUI librarymit ihm verschickt. Andere GUI-Bibliotheken mögenPyQt und WxPython sind auch zur Verwendung verfügbar, aber die Swing-Bibliothek bietet ein plattformunabhängiges GUI-Toolkit.

Die Verwendung der Swing-Bibliothek in Jython ist viel einfacher als in Java. In Java müssen die anonymen Klassen verwendet werden, um eine Ereignisbindung zu erstellen. In Jython können wir einfach eine Funktion für denselben Zweck übergeben.

Das grundlegende Fenster der obersten Ebene wird durch Deklarieren eines Objekts von erstellt JFrame classund setzen Sie die sichtbare Eigenschaft auf true. Dazu muss die Jframe-Klasse aus dem Swing-Paket importiert werden.

from javax.swing import JFrame

Die JFrame-Klasse verfügt über mehrere Konstruktoren mit unterschiedlicher Anzahl von Argumenten. Wir werden diejenige verwenden, die eine Zeichenfolge als Argument verwendet und sie als Titel festlegt.

frame = JFrame(“Hello”)

Legen Sie die Größen- und Positionseigenschaften des Rahmens fest, bevor Sie die sichtbare Eigenschaft auf true setzen. Speichern Sie den folgenden Code alsframe.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)

Führen Sie das obige Skript an der Eingabeaufforderung aus. Die folgende Ausgabe zeigt ein Fenster.

Die Swing-GUI-Bibliothek wird in Form von bereitgestellt javax.swingPaket in Java. Seine Hauptcontainerklassen,JFrame und JDialogwerden jeweils von Frame- und Dialog-Klassen abgeleitet, die sich in der AWT-Bibliothek befinden. Andere GUI-Steuerelemente wieJLabel, JButton, JTextField, usw. werden von der JComponent-Klasse abgeleitet.

Die folgende Abbildung zeigt die Hierarchie der Swing-Paketklassen.

In der folgenden Tabelle sind verschiedene GUI-Steuerungsklassen in einer Swing-Bibliothek zusammengefasst.

Sr.Nr. Klasse & Beschreibung
1

JLabel

Ein JLabel-Objekt ist eine Komponente zum Platzieren von Text in einem Container.
2

JButton

Diese Klasse erstellt eine beschriftete Schaltfläche.
3

JColorChooser

Ein JColorChooser bietet einen Bereich mit Steuerelementen, mit denen ein Benutzer eine Farbe bearbeiten und auswählen kann.
4

JCheckBox

Eine JCheckBox ist eine grafische Komponente, die sich entweder in einer befinden kann on (wahr oder off (falscher) Zustand.
5

JRadioButton

Die JRadioButton-Klasse ist eine grafische Komponente, die sich entweder im Status "Ein" (wahr) oder "Aus" (falsch) befinden kann. in einer Gruppe.
6

JList

Eine JList-Komponente zeigt dem Benutzer eine Liste mit Textelementen an.
7

JComboBox

Eine JComboBox-Komponente zeigt dem Benutzer eine Dropdown-Liste mit Elementen an
8

JTextField

Ein JTextField-Objekt ist eine Textkomponente, mit der eine einzelne Textzeile bearbeitet werden kann.
9

JPasswordField

Ein JPasswordField-Objekt ist eine Textkomponente, die auf die Kennworteingabe spezialisiert ist.
10

JTextArea

Ein JTextArea-Objekt ist eine Textkomponente, mit der mehrere Textzeilen bearbeitet werden können.
11

ImageIcon

Ein ImageIcon-Steuerelement ist eine Implementierung der Symbolschnittstelle, mit der Symbole aus Bildern gezeichnet werden
12

JScrollbar

Ein Bildlaufleisten-Steuerelement stellt eine Bildlaufleisten-Komponente dar, damit der Benutzer aus einem Wertebereich auswählen kann.
13

JOptionPane

JOptionPane bietet eine Reihe von Standarddialogfeldern, in denen Benutzer zur Eingabe eines Werts aufgefordert oder über etwas informiert werden.
14

JFileChooser

Ein JFileChooser-Steuerelement stellt ein Dialogfenster dar, in dem der Benutzer eine Datei auswählen kann.
15

JProgressBar

Während die Aufgabe abgeschlossen ist, zeigt der Fortschrittsbalken den Fertigstellungsgrad der Aufgabe an.
16

JSlider

Mit einem JSlider kann der Benutzer einen Wert grafisch auswählen, indem er einen Knopf innerhalb eines begrenzten Intervalls bewegt.
17

JSpinner

Ein JSpinner ist ein einzeiliges Eingabefeld, mit dem der Benutzer eine Zahl oder einen Objektwert aus einer geordneten Sequenz auswählen kann.

Wir würden einige dieser Steuerelemente in nachfolgenden Beispielen verwenden.

Layout-Manager in Java sind Klassen, die die Platzierung von Steuerelementen in Containerobjekten wie verwalten Frame, Dialog oder Panel. Layout-Manager behalten die relative Positionierung von Steuerelementen in einem Frame bei, auch wenn sich die Auflösung ändert oder die Größe des Frames selbst geändert wird.

Diese Klassen implementieren die Layout interface. Die folgenden Layout-Manager sind in der definiertAWT library - -

  • BorderLayout
  • FlowLayout
  • GridLayout
  • CardLayout
  • GridBagLayout

Die folgenden Layout-Manager sind in der definiert Swing library - -

  • BoxLayout
  • GroupLayout
  • ScrollPaneLayout
  • SpringLayout

In den folgenden Beispielen werden sowohl AWT-Layout-Manager als auch Swing-Layout-Manager verwendet.

  • Absolutes Layout
  • Ablauflayout
  • Gitterstruktur
  • Rahmenlayout
  • Box Layout
  • Gruppenlayout

Lassen Sie uns nun jeden dieser Punkte im Detail besprechen.

Absolutes Layout

Bevor wir alle oben genannten Layout-Manager untersuchen, müssen wir uns die absolute Positionierung der Steuerelemente in einem Container ansehen. Wir müssen die Layoutmethode des Frame-Objekts auf 'None' setzen.

frame.setLayout(None)

Platzieren Sie dann das Steuerelement, indem Sie das aufrufen setBounds()Methode. Es werden vier Argumente benötigt - x-Position, y-Position, Breite und Höhe.

Zum Beispiel - Um ein Schaltflächenobjekt an der absoluten Position und mit der absoluten Größe zu platzieren.

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

In ähnlicher Weise können alle Steuerelemente platziert werden, indem Position und Größe richtig zugewiesen werden. Dieses Layout ist relativ einfach zu verwenden, behält jedoch sein Aussehen nicht bei, wenn die Fenstergröße geändert wird oder wenn das Programm ausgeführt wird, wenn sich die Bildschirmauflösung ändert.

Im folgenden Jython-Skript werden drei Jlabel-Objekte verwendet, um den Text "phy", "maths" und "Total" anzuzeigen. Vor diesen drei werden JTextField-Objekte platziert. Ein Button-Objekt wird über der Bezeichnung "Total" platziert.

Zunächst wird das JFrame-Fenster mit einem Layout erstellt, das auf none festgelegt ist.

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

Dann werden verschiedene Steuerelemente entsprechend ihrer absoluten Position und Größe hinzugefügt. Der vollständige Code ist unten angegeben -

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)

Die Ausgabe für den obigen Code lautet wie folgt.

Jython FlowLayout

Das FlowLayout ist der Standardlayoutmanager für Containerklassen. Es regelt die Steuerung von links nach rechts und dann von oben nach unten.

Im folgenden Beispiel sollen ein Jlabel-Objekt, ein JTextField-Objekt und ein JButton-Objekt mit dem FlowLayout-Manager in einem JFrame angezeigt werden. Importieren wir zunächst die erforderlichen Klassen aus demjavax.swing Paket und die java.awt Paket.

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

Erstellen Sie dann ein JFrame-Objekt und legen Sie dessen Speicherort sowie die Größeneigenschaften fest.

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())

Deklarieren Sie nun Objekte für die Klassen JLabel, JTextfield und JButton.

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

Fügen Sie diese Steuerelemente schließlich dem Frame hinzu, indem Sie das aufrufen add() Methode der JFrame-Klasse.

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

Um den Rahmen anzuzeigen, setzen Sie seine sichtbare Eigenschaft auf true. Das vollständige Jython-Skript und seine Ausgabe sind wie folgt:

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

Der Gridlayout-Manager ermöglicht die Platzierung von Steuerelementen in einem rechteckigen Raster. In jeder Zelle des Gitters befindet sich ein Steuerelement.

Im folgenden Beispiel wird das GridLayout auf ein JFrame-Objekt angewendet, das es in 4 Zeilen und 4 Spalten unterteilt. In jeder Zelle des Gitters ist ein JButton-Objekt zu platzieren.

Importieren wir zunächst die benötigten Bibliotheken -

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

Erstellen Sie dann den JFrame-Container -

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

Wenden Sie nun GridLayout an, indem Sie seine Abmessungen als 4 x 4 angeben.

frame.setLayout(GridLayout(4,4))

Wir sollten jetzt zwei FOR-Schleifen verwenden, die jeweils von 1 bis 4 reichen, damit 16 JButton-Objekte in nachfolgenden Zellen platziert werden.

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)))

Setzen Sie schließlich die Sichtbarkeit des Rahmens auf true. Der vollständige Jython-Code ist unten angegeben.

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)

Die Ausgabe des obigen Codes lautet wie folgt:

Jython BorderLayout

Der BorderLayout-Manager unterteilt den Container in fünf geografische Regionen und Orte mit einer Komponente in jeder Region. Diese Regionen werden durch definierte Konstanten wie folgt dargestellt:

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

Betrachten wir das folgende Beispiel:

Jython BoxLayout

Die BoxLayout-Klasse ist in der definiert javax.swing package. Es wird verwendet, um Komponenten im Container entweder vertikal oder horizontal anzuordnen. Die Richtung wird durch die folgenden Konstanten bestimmt -

  • X_AXIS
  • Y_AXIS
  • LINE_AXIS
  • PAGE_AXIS

Die Ganzzahlkonstante gibt die Achse an, entlang der die Komponenten des Containers angeordnet werden sollen. Wenn der Container die Standardkomponentenausrichtung hat, gibt LINE_AXIS an, dass die Komponenten von links nach rechts angeordnet werden sollen, und PAGE_AXIS gibt an, dass die Komponenten von oben nach unten angeordnet werden sollen.

Im folgenden Beispiel wird ein Panel (der JPanel-Klasse) in einem JFrame-Objekt hinzugefügt. Das vertikale BoxLayout wird darauf angewendet und zwei weitere Bedienfelder, oben und unten, werden hinzugefügt. Diese beiden internen Bedienfelder verfügen über zwei Schaltflächen, die jeweils im horizontalen Boxlayout hinzugefügt werden.

Lassen Sie uns zuerst das JFrame-Fenster der obersten Ebene erstellen.

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

Das JPanel-Objekt hat ein vertikales BoxLayout. Fügen Sie es im Rahmen der obersten Ebene hinzu.

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

In diesem Bereich werden zwei weitere Bereiche oben und unten hinzugefügt. Jedem von ihnen werden zwei JButton-Objekte horizontal hinzugefügt, wobei ein Platzhalter von 25 Pixeln sie voneinander trennt.

###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)

Ebenso ist die Bodenplatte aufgebaut.

###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())

Notiere dass der createRigidArea()Mit dieser Funktion wird ein Abstand von 25 Pixel zwischen zwei Schaltflächen erstellt. Auch dercreateVerticalGlue() Die Funktion belegt den führenden oder den hinteren Bereich im Layout.

Fügen Sie zunächst die oberen und unteren Bereiche hinzu und setzen Sie die Sichtbarkeitseigenschaft des Rahmens auf true. Der vollständige Code lautet wie folgt:

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)

Der obige Code generiert die folgende Ausgabe.

Jython GroupLayout

Der GroupLayout-Manager gruppiert die Komponenten hierarchisch. Die Gruppierung erfolgt in zwei Klassen:SequentialGroup und ParallelGroupBeide implementieren die Gruppenschnittstelle in Java.

Das Layout ist in zwei Schritte unterteilt. In einem Schritt werden die Komponenten entlang der horizontalen Achse und im zweiten Schritt entlang der vertikalen Achse platziert. Jede Komponente muss zweimal im Layout definiert werden.

Es gibt zwei Arten von Anordnungen, sequentielle und parallele. In beiden Fällen können wir Komponenten nacheinander oder parallel anordnen. In horizontaler Anordnung wird die Zeile als sequentielle Gruppe und die Spalte als parallele Gruppe bezeichnet. Andererseits ist in paralleler Anordnung die Elementzeile eine parallele Gruppe und eine Spalte, die als sequentiell bezeichnet wird.

Im folgenden Beispiel sind fünf Schaltflächen so angeordnet, dass jeweils drei in Zeile und Spalte angezeigt werden. Fügen Sie zunächst ein Jpanel-Objekt in ein JFrame-Fenster ein und legen Sie dessen Layout als Gruppenlayout fest.

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

Dann konstruieren Sie die JButton-Objekte -

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

Als nächstes erstellen wir eine SequentialGroup genannt LeftToRightzu denen buttonD und buttonY hinzugefügt werden. Dazwischen wird eine ParallelGroup ColumnMiddle (mit drei weiteren vertikal hinzugefügten Schaltflächen) platziert.

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

Nun kommt die Definition der vertikalen SequentialGroup namens TopToBottom. Fügen Sie eine ParallelGroup-Reihe mit drei Schaltflächen hinzu und legen Sie dann zwei Schaltflächen vertikal ab.

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

Setzen Sie abschließend die LeftToRight-Gruppe horizontal und die TopToBottom-Gruppe vertikal auf das Layoutobjekt. Der vollständige Code ist unten angegeben -

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)

Die Ausgabe des obigen Codes lautet wie folgt:

Für die Ereignisbehandlung in Java Swing muss das Steuerelement (wie JButton oder JList usw.) beim jeweiligen Ereignis-Listener registriert sein. Die Ereignis-Listener-Schnittstelle oder die entsprechende Adapterklasse muss entweder implementiert oder in eine Unterklasse unterteilt werden, wobei die Ereignisbehandlungsmethode überschrieben wird. In Jython ist die Ereignisbehandlung sehr einfach. Wir können jede Funktion als Eigenschaft der Ereignisbehandlungsfunktion übergeben, die dem Steuerelement entspricht.

Lassen Sie uns zunächst sehen, wie ein Klickereignis in Java behandelt wird.

Zunächst müssen wir die importieren java.awt.event package. Als Nächstes muss die Klasse, die JFrame erweitert, die ActionListener-Schnittstelle implementieren.

public class btnclick extends JFrame implements ActionListener

Dann müssen wir das JButton-Objekt deklarieren, es zum ContentPane des Frames hinzufügen und es dann mit der Methode addActionListener () bei ActionListener registrieren.

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

Jetzt muss die actionPerformed () -Methode der ActionListener-Schnittstelle überschrieben werden, um das ActionEvent zu verarbeiten.

Es folgt der gesamte Java-Code -

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);
   }
}

Jetzt schreiben wir den Jython-Code, der demselben Code entspricht.

Zunächst müssen wir weder das ActionEvent noch den ActionListener importieren, da wir durch die dynamische Typisierung von Jython vermeiden können, diese Klassen in unserem Code zu erwähnen.

Zweitens muss ActionListener nicht implementiert oder in Unterklassen unterteilt werden. Stattdessen wird jede benutzerdefinierte Funktion dem JButton-Konstruktor sofort als Wert von bereitgestelltactionPerformed Bohneneigenschaft.

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

Das clickhere() Die Funktion ist als reguläre Jython-Funktion definiert, die das Klickereignis auf der Schaltfläche behandelt.

def change_text(event):
print clicked!'

Hier ist der äquivalente Jython-Code.

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)

Die Ausgabe von Java- und Jython-Code ist identisch. Wenn Sie auf die Schaltfläche klicken, wird die Meldung "angeklickt" auf der Konsole gedruckt.

Im folgenden Jython-Code werden im JFrame-Fenster zwei JTextField-Objekte bereitgestellt, um Markierungen in 'phy' und 'maths' einzugeben. Das JButton-Objekt führt beim Klicken die Funktion add () aus.

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

Die Funktion add () liest den Inhalt von zwei Textfeldern mit der Methode getText () und analysiert sie in Ganzzahlen, damit die Addition durchgeführt werden kann. Das Ergebnis wird dann mit der Methode setText () in das dritte Textfeld eingefügt.

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

Der vollständige Code ist unten angegeben -

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)

Wenn der obige Code an der Eingabeaufforderung ausgeführt wird, wird das folgende Fenster angezeigt. Geben Sie Markierungen für 'Phy', Maths 'ein und klicken Sie auf die Schaltfläche' Add '. Das Ergebnis wird entsprechend angezeigt.

Jython JRadioButton-Ereignis

Die JRadioButton-Klasse ist in der definiert javax.swing package. Es wird eine auswählbare Umschalttaste mit Ein- oder Ausschaltzuständen erstellt. Wenn einer ButtonGroup mehrere Optionsfelder hinzugefügt werden, schließt sich deren Auswahl gegenseitig aus.

Im folgenden Beispiel werden zwei Objekte der JRadioButton-Klasse und zwei JLabels einem Jpanel-Container in einem vertikalen BoxLayout hinzugefügt. Im Konstruktor der JRadioButton-Objekte wird dieOnCheck()Die Funktion wird als Wert der actionPerformed-Eigenschaft festgelegt. Diese Funktion wird ausgeführt, wenn auf das Optionsfeld geklickt wird, um seinen Status zu ändern.

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

Beachten Sie, dass der Standardstatus von Optionsfeld falsch ist (nicht ausgewählt). Die Schaltfläche rb1 wird mit dem Startstatus True (ausgewählt) erstellt.

Die beiden Optionsfelder werden einer Optionsfeldgruppe hinzugefügt, damit sie sich gegenseitig ausschließen. Wenn eines ausgewählt ist, wird das andere automatisch abgewählt.

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

Diese beiden Optionsfelder werden zusammen mit zwei Beschriftungen einem Bedienfeldobjekt im vertikalen Layout mit einem Trennbereich von 25 Pixel in Höhen zwischen rb2 und lbl2 hinzugefügt.

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)

Dieses Bedienfeld wird einem JFrame-Objekt der obersten Ebene hinzugefügt, dessen sichtbare Eigenschaft am Ende auf 'True' gesetzt ist.

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)

Führen Sie das obige Jython-Skript aus und ändern Sie die Auswahl der Optionsfelder. Die Auswahl wird im Etikett unten angezeigt.

Jython JCheckBox-Ereignis

Wie JRadioButtonDas JCheckBox-Objekt ist auch eine auswählbare Schaltfläche mit einem rechteckigen Kontrollkästchen neben der Beschriftung. Dies wird im Allgemeinen verwendet, um dem Benutzer die Möglichkeit zu geben, mehrere Optionen aus der Liste der Elemente auszuwählen.

Im folgenden Beispiel werden einem JPanel im vertikalen BoxLayout zwei Kontrollkästchen und ein Etikett aus dem Swing-Paket hinzugefügt. Das Etikett unten zeigt den momentanen Auswahlstatus von zwei Kontrollkästchen an.

Beide Kontrollkästchen werden mit dem Konstruktor deklariert, für den die actionPerformed-Eigenschaft auf gesetzt ist OnCheck() Funktion.

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

Die Funktion OnCheck () überprüft den Auswahlstatus jedes Kontrollkästchens und zeigt die entsprechende Meldung auf dem Etikett unten an.

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"

Diese Felder und ein JLabel-Objekt werden einem JPanel mit einem Leerzeichen von 50 Pixel Höhe hinzugefügt.

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)

Das Bedienfeld selbst wird einem JFrame-Fenster der obersten Ebene hinzugefügt, dessen sichtbare Eigenschaft am Ende auf true gesetzt ist.

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

frame.setVisible(True)

Führen Sie den obigen Code aus und experimentieren Sie mit der Auswahl der Kontrollkästchen. Der momentane Status beider Kontrollkästchen wird unten angezeigt.

Jython JList-Ereignis

Das JList-Steuerelement im Swing-Paket bietet dem Benutzer eine scrollbare Liste von Elementen zur Auswahl. Die JComboBox bietet eine Dropdown-Liste mit Elementen. In Java wird das Auswahlereignis verarbeitet, indem die valueChanged () -Methode im ListSelectionListener implementiert wird. In Jython wird der valueChanged-Eigenschaft des JList-Objekts ein Ereignishandler zugewiesen.

Im folgenden Beispiel werden einem JFrame im BorderLayout ein JList-Objekt und eine Beschriftung hinzugefügt. Die JList enthält eine Sammlung von Elementen in einem Tupel. Die valueChanged-Eigenschaft ist auf die Funktion listSelect () festgelegt.

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

Die Ereignishandlerfunktion ruft den Index des ausgewählten Elements ab und ruft das entsprechende Element aus dem JList-Objekt ab, das auf dem Etikett unten angezeigt werden soll.

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

Das JList- und das JLabel-Objekt werden mithilfe von BorderLayout zum JFrame hinzugefügt.

Der gesamte Code ist unten angegeben -

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)

Die Ausgabe des folgenden Codes lautet wie folgt.

Die meisten GUI-basierten Anwendungen haben oben eine Menüleiste. Es befindet sich direkt unter der Titelleiste des Fensters der obersten Ebene. Das Paket javax.swing verfügt über umfangreiche Funktionen zum Aufbau eines effizienten Menüsystems. Es wird mit Hilfe von konstruiertJMenuBar, JMenu und JMenuItem Klassen.

Im folgenden Beispiel wird im Fenster der obersten Ebene eine Menüleiste bereitgestellt. Der Menüleiste wird ein Menü Datei hinzugefügt, das aus drei Menüelementschaltflächen besteht. Bereiten wir nun ein JFrame-Objekt mit dem Layout BorderLayout vor.

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

Jetzt wird ein JMenuBar-Objekt durch die SetJMenuBar () -Methode aktiviert.

bar = JMenuBar()
frame.setJMenuBar(bar)

Als nächstes wird ein JMenu-Objekt mit der Beschriftung 'Datei' deklariert. Dem Menü Datei werden drei JMenuItem-Schaltflächen hinzugefügt. Wenn Sie auf eines der Menüelemente klicken, wird die OnClick () -Funktion des ActionEvent-Handlers ausgeführt. Es wird mit der actionPerformed-Eigenschaft definiert.

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)

Der OnClick () - Ereignishandler ruft den Namen der JMenuItem-Schaltfläche mit der Funktion gwtActionCommand () ab und zeigt ihn im Textfeld am unteren Rand des Fensters an.

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

Das Menüobjekt Datei wird zur Menüleiste hinzugefügt. Schließlich wird am unteren Rand des JFrame-Objekts ein JTextField-Steuerelement hinzugefügt.

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

Der gesamte Code von menu.py ist unten angegeben -

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)

Wenn das obige Skript mit dem Jython-Interpreter ausgeführt wird, wird ein Fenster mit dem Menü Datei angezeigt. Klicken Sie darauf und die drei Menüpunkte werden angezeigt. Wenn Sie auf eine Schaltfläche klicken, wird deren Name im Textfeld angezeigt.

Ein Dialogobjekt ist ein Fenster, das über dem Basisfenster angezeigt wird, mit dem der Benutzer interagiert. In diesem Kapitel sehen wir die vorkonfigurierten Dialoge, die in der Swing-Bibliothek definiert sind. Sie sindMessageDialog, ConfirmDialog und InputDialog. Sie sind aufgrund der statischen Methode der JOptionPane-Klasse verfügbar.

Im folgenden Beispiel enthält das Menü Datei drei JMenu-Elemente, die den obigen drei Dialogfeldern entsprechen. jeder führt die ausOnClick Event-Handler.

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)

Die OnClick () - Handlerfunktion ruft die Beschriftung der Menüelementschaltfläche ab und ruft die entsprechende showXXXDialog () -Methode auf.

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")

Wenn die Nachrichtenoption aus dem Menü ausgewählt ist, wird eine Nachricht angezeigt. Wenn Sie auf die Option Eingabe klicken, wird ein Dialogfeld angezeigt, in dem Sie nach der Eingabe gefragt werden. Der Eingabetext wird dann im Textfeld im JFrame-Fenster angezeigt. Wenn die Option Bestätigen ausgewählt ist, wird ein Dialogfeld mit den drei Schaltflächen JA, NEIN und ABBRECHEN angezeigt. Die Auswahl des Benutzers wird im Textfeld aufgezeichnet.

Der gesamte Code ist unten angegeben -

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)

Wenn das obige Skript ausgeführt wird, wird das folgende Fenster mit drei Optionen im Menü angezeigt:

Nachrichtenbox

Eingabefeld

Dialog bestätigen

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