Jython - szybki przewodnik

Jython to implementacja JVM języka programowania Python. Został zaprojektowany do działania na platformie Java. Program w języku Jython może importować i używać dowolnej klasy języka Java. Podobnie jak Java, program Jython kompiluje się dobytecode. Jedną z głównych zalet jest to, że interfejs użytkownika zaprojektowany w Pythonie może używać elementów GUIAWT, Swing lub SWT Package.

Jython, który zaczynał jako JPython, a później został przemianowany, jest ściśle zgodny ze standardową implementacją Pythona o nazwie CPython utworzony przez Guido Van Rossum. Jython został stworzony w 1997 roku przezJim Hugunin. Jython 2.0 został wydany w 1999 roku. Od tego czasu wydania Jython 2.x odpowiadają równoważnym wydaniom CPythona. Jython 2.7.0 wydany w maju 2015 r. Odpowiada CPython 2.7. Rozwój Jython 3.x jest w toku.

Różnica między Pythonem a Javą

Oto różnice między Pythonem i Javą -

Python to język dynamicznie typowany. Dlatego deklaracja typu zmiennej nie jest potrzebna. Z drugiej strony Java jest językiem typowanym statycznie, co oznacza, że deklaracja typu zmiennej jest obowiązkowa i nie można jej zmienić.
Python ma tylko niezaznaczone wyjątki, podczas gdy Java ma zarówno zaznaczone, jak i niezaznaczone wyjątki.
Python używa wcięć do określania zakresu, podczas gdy Java używa pasujących nawiasów klamrowych.
Ponieważ Python jest językiem opartym na interpreterach, nie ma oddzielnych kroków kompilacji. Jednak program w języku Java musi zostać skompilowany do kodu bajtowego i jest z kolei wykonywany przez maszynę JVM.
Python obsługuje wielokrotne dziedziczenie, ale w Javie wielokrotne dziedziczenie nie jest możliwe. Ma jednak implementację interfejsu.
W porównaniu z Javą, Python ma bogatsze wbudowane struktury danych (listy, dykty, krotki, wszystko jest obiektem).

Różnica między Pythonem a Jythonem

Oto różnice między Pythonem i Jythonem -

Referencyjna implementacja Pythona, zwana CPython, została napisana w języku C. Z drugiej strony Jython jest całkowicie napisany w Javie i jest implementacją JVM.
Standard Python jest dostępny na wielu platformach. Jython jest dostępny na każdą platformę z zainstalowaną maszyną JVM.
Standardowy kod Pythona kompiluje się do pliku .pyc plik, podczas gdy program Jython kompiluje się do pliku .class plik.
Rozszerzenia Pythona można pisać w języku C. Rozszerzenia dla Jythona są napisane w Javie.
Jython jest naprawdę wielowątkowy z natury. Python używa jednak rozszerzeniaGlobal Interpreter Lock (GIL) w tym celu.
Obie implementacje mają różne mechanizmy czyszczenia pamięci.

W następnym rozdziale dowiemy się, jak importować biblioteki Java w Jythonie.

Przed instalacją Jythona 2.7 upewnij się, że system ma JDK 7lub więcej zainstalowanych. Jython jest dostępny w postaci wykonywalnego pliku jar. Pobierz z -http://www.jython.org/downloads.html i kliknij dwukrotnie jego ikonę lub uruchom następujące polecenie -

java -jar jython_installer-2.7.0.jar

Uruchomi się kreator instalacji, za pomocą którego należy podać opcje instalacji. Oto systematyczna procedura instalacji.

W pierwszym kroku kreatora zostaniesz poproszony o wybranie języka.

W drugim kroku należy zaakceptować umowę licencyjną.

W następnym kroku wybierz typ instalacji. Zaleca się wybranie instalacji standardowej.

Następny ekran prosi o potwierdzenie opcji i przechodzi do zakończenia instalacji.

Procedura instalacji może zająć trochę czasu.

Po zakończeniu instalacji wywołaj jython.exez katalogu bin wewnątrz katalogu docelowego. Zakładając, że Jython jest zainstalowany wC:\jython27wykonaj następujące czynności z wiersza poleceń.

C:\jython27\bin\jython

Pojawi się znak zachęty Pythona (>>>), przed którym można wykonać dowolną instrukcję Pythona lub skrypt Pythona.

Jedną z najważniejszych cech Jythona jest możliwość importowania klas Java do programu w języku Python. Możemy zaimportować dowolny pakiet lub klasę Java do Jythona, tak jak robimy to w programie Java. Poniższy przykład pokazuje, jakjava.util pakiety są importowane w skrypcie Python (Jython) w celu zadeklarowania obiektu klasy Date.

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

Zapisz i uruchom powyższy kod jako UtilDate.pyz wiersza poleceń. Zostanie wyświetlona instancja bieżącej daty i godziny.

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

Następujące pakiety z biblioteki Java są częściej importowane do programu w języku Jython głównie dlatego, że standardowa biblioteka Pythona albo nie ma swoich odpowiedników, albo nie jest tak dobra.

Servlets
JMS
J2EE
Javadoc
Swing jest uważany za lepszy od innych zestawów narzędzi GUI

Każdy pakiet Java w tym zakresie można zaimportować w skrypcie Jython. Tutaj następujący program Java jest przechowywany i kompilowany w pakiecie o nazwiefoo.

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

To HelloWorld.classjest importowany w następującym skrypcie Jython. Metody w tej klasie można wywołać ze skryptu Jythonimportex.py.

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

Zapisz i wykonaj powyższy skrypt z wiersza poleceń, aby uzyskać następujące dane wyjściowe.

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

Zmienne to nazwane lokalizacje w pamięci komputera. Każda zmienna może zawierać jeden element danych. W przeciwieństwie do Javy, Python jest językiem z dynamicznym typowaniem. Dlatego też podczas korzystania z Jythona; wcześniejsza deklaracja typu danych zmiennej nie jest wykonywana. Zamiast decydować o tym, które dane mogą być w niej przechowywane, typ zmiennej decyduje o rodzaju zmiennej.

W poniższym przykładzie zmiennej przypisano wartość całkowitą. Korzystając z funkcji wbudowanej type (), możemy zweryfikować, czy typ zmiennej jest liczbą całkowitą. Jeśli jednak do tej samej zmiennej zostanie przypisany łańcuch, funkcja type () będzie ciągiem znaków jako typ tej samej zmiennej.

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

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

To wyjaśnia, dlaczego Python nazywany jest językiem z dynamicznym typowaniem.

Następujące wbudowane typy danych Python mogą być również używane w Jythonie -

Number
String
List
Tuple
Dictionary

Python rozpoznaje dane liczbowe jako liczbę, która może być liczbą całkowitą, liczbą rzeczywistą ze zmiennoprzecinkiem lub liczbą zespoloną. Typy danych String, List i Tuple nazywane są sekwencjami.

Liczby w Jythonie

W Pythonie mówi się, że każda liczba całkowita ze znakiem jest typu „int”. Aby wyrazić długą liczbę całkowitą, dołączona jest do niej litera „L”. Liczba z kropką dziesiętną oddzielającą część całkowitą od części ułamkowej nazywana jest „liczbą zmiennoprzecinkową”. Część ułamkowa może zawierać wykładnik wyrażony w notacji naukowej za pomocą „E” lub „e”.

Liczba zespolona jest również definiowana jako numeryczny typ danych w Pythonie. Liczba zespolona zawiera część rzeczywistą (liczbę zmiennoprzecinkową) i część urojoną, do której dołączone jest „j”.

Aby wyrazić liczbę w reprezentacji ósemkowej lub szesnastkowej, 0O lub 0Xjest poprzedzony przedrostkiem. Poniższy blok kodu zawiera przykłady różnych reprezentacji liczb w Pythonie.

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

Ciągi Jython

Łańcuch to dowolna sekwencja znaków ujęta w pojedyncze (np. „Witaj”), podwójne (np. „Witaj”) lub potrójne (np. „Witaj” lub „„ witaj ””) cudzysłowy. Potrójne cudzysłowy są szczególnie przydatne, jeśli treść ciągu obejmuje wiele linii.

Znaki sekwencji ucieczki można umieścić dosłownie w łańcuchu z potrójnym cudzysłowem. Poniższe przykłady pokazują różne sposoby deklarowania ciągu znaków w Pythonie.

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

Trzeci łańcuch po wydrukowaniu da następujący wynik.

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.

Listy Jythona

Lista to typ danych sekwencyjnych. Jest to zbiór elementów oddzielonych przecinkami, niekoniecznie tego samego typu, przechowywanych w nawiasach kwadratowych. Dostęp do poszczególnych pozycji z listy można uzyskać za pomocą indeksu liczonego od zera.

Poniższy blok kodu podsumowuje użycie listy w Pythonie.

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]

W poniższej tabeli opisano niektóre z najczęściej używanych wyrażeń Jython związanych z listami Jython.

Wyrażenie Jython	Opis
len (lista)	Długość
Lista [2] = 10	Aktualizacja
Lista usunięcia [1]	Usunięcie
List.append (20)	Dodać
List.insert (1,15)	Wprowadzenie
List.sort ()	Sortowanie

Krotki Jythona

Krotka to niezmienna kolekcja oddzielonych przecinkami elementów danych przechowywanych w nawiasach. Nie można usunąć ani zmodyfikować elementu w krotce ani dodać elementu do kolekcji krotek. Poniższy blok kodu przedstawia operacje krotki.

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]

Słownik Jython

Słownik Jython jest podobny do klasy Map w środowisku Java Collection. Jest to zbiór par klucz-wartość. Pary oddzielone przecinkiem są zawarte w nawiasach klamrowych. Obiekt Dictionary nie śledzi indeksu liczonego od zera w celu pobrania elementu znajdującego się w nim, ponieważ są one przechowywane za pomocą techniki mieszania.

Ten sam klucz nie może pojawić się więcej niż raz w obiekcie słownika. Jednak więcej niż jeden klucz może mieć te same skojarzone wartości. Różne funkcje dostępne w obiekcie Dictionary są wyjaśnione poniżej -

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

W poniższej tabeli opisano niektóre z najczęściej używanych wyrażeń Jython związanych ze słownikiem.

Wyrażenie Jython	Opis
dict.get ('011')	Szukaj
len (dict)	Długość
dict ['044'] = 'Chennai'	Dodać
del dict [„022”]	Usunąć
dict.keys ()	lista kluczy
dict.values ()	Lista wartości
dict.clear ()	Usuwa wszystkie elementy

Oprócz wbudowanych typów danych Pythona, Jython ma tę zaletę, że używa klas kolekcji Java, importując java.util package. Poniższy kod opisuje klasy podane poniżej -

Obiekt Java ArrayList z funkcją add ()
remove()
get () i set () klasy 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

Powyższy skrypt Jython generuje następujące dane wyjściowe -

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

Klasa Jarray

Jython implementuje również Jarray Object, który umożliwia budowę tablicy Java w Pythonie. Aby pracować z jarrayem, wystarczy zdefiniować typ sekwencji w Jythonie i przekazać go do jarrayobject wraz z typem obiektu zawartego w sekwencji. Wszystkie wartości w jarray muszą być tego samego typu.

W poniższej tabeli przedstawiono kody typów znaków używane z jarray.

Kod typu postaci	Odpowiedni typ Java
Z	Boolean
do	zwęglać
b	bajt
H.	krótki
ja	int
L	długo
fa	pływak
re	podwójnie

Poniższy przykład przedstawia konstrukcję 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

Tutaj my_seqjest zdefiniowana jako krotka liczb całkowitych. Jest konwertowany na Jarray arr1. Drugi przykład pokazuje, że Jarray arr2 jest zbudowany zmySttr stringsekwencja. Dane wyjściowe powyższego skryptujarray.py wygląda następująco -

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

Struktury decyzyjne mają jeden lub więcej warunków, które mają być ocenione lub przetestowane przez program, wraz z instrukcją lub instrukcjami, które mają zostać wykonane, jeśli warunek zostanie określony jako prawdziwy, i opcjonalnie inne instrukcje do wykonania, jeśli warunek jest zdeterminowany, aby być fałszywy.

Poniższa ilustracja przedstawia ogólną postać typowej struktury podejmowania decyzji występującej w większości języków programowania -

Jython nie używa nawiasów klamrowych do wskazania bloków instrukcji, które mają być wykonane, gdy warunek jest prawdziwy lub fałszywy (jak ma to miejsce w Javie). Zamiast tego do utworzenia bloku instrukcji używane jest jednolite wcięcie (odstęp od lewego marginesu). Taki jednolicie wcięty blok sprawia, że kod warunkowy jest wykonywany, gdy warunek podany w instrukcji „if” jest prawdziwy.

Podobny blok może znajdować się po opcjonalnej instrukcji „else”. Jython zapewnia równieżelif statementprzy użyciu których można testować kolejne warunki. Tutajelse clausepojawi się jako ostatni i zostanie wykonany tylko wtedy, gdy wszystkie poprzednie warunki zawiodą. Ogólna składnia usingif..elif..else następująco.

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

W poniższym przykładzie if ..elif ..else Konstrukcja służy do obliczania rabatu przy różnych wartościach kwoty wprowadzonej przez użytkownika.

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

Wynik powyższego kodu będzie taki, jak pokazano poniżej.

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

Na ogół instrukcje w programie są wykonywane sekwencyjnie: pierwsza instrukcja funkcji jest wykonywana jako pierwsza, po niej następuje druga i tak dalej. Może zaistnieć sytuacja, w której trzeba będzie kilkakrotnie wykonać blok kodu. Nazywa się instrukcje, które zapewniają taką możliwość powtarzanialooping statements.

W Jythonie pętlę można utworzyć za pomocą dwóch instrukcji, którymi są -

Plik while oświadczenie i
Plik for komunikat

Pętla WHILE

Instrukcja while loop w Jythonie jest podobna do tej w Javie. Wielokrotnie wykonuje blok instrukcji, o ile dany warunek jest prawdziwy. Poniższy schemat blokowy opisuje zachowaniewhile pętla.

Ogólna składnia instrukcji while jest podana poniżej.

while expression:
   statement(s)

Poniższy kod Jython używa pętli while do wielokrotnego zwiększania i drukowania wartości zmiennej, aż będzie mniejsza niż zero.

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

Output - Wynik byłby następujący.

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

Pętla FOR

Pętla FOR w Jythonie nie jest pętlą liczoną, jak w Javie. Zamiast tego ma możliwość przechodzenia przez elementy w sekwencyjnym typie danych, takim jak łańcuch, lista lub krotka. Ogólna składnia instrukcji FOR w języku Jython jest przedstawiona poniżej -

for iterating_var in sequence:
   statements(s)

Możemy wyświetlić każdy znak w ciągu, a także każdy element listy lub krotki, używając instrukcji FOR, jak pokazano poniżej -

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

Output - Wynik byłby następujący.

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

Rozważmy inny przykład, jak następuje.

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

Output - Wynik będzie następujący.

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

Oto inny przykład do rozważenia.

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

Output - Wynik powyższego programu jest następujący.

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

W Jythonie forInstrukcja służy również do iteracji po liście liczb wygenerowanej przez funkcję range (). Funkcja range () przyjmuje następującą postać -

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

Domyślnie parametry startu i kroku to 0 i 1. Ostatnia wygenerowana liczba to krok zatrzymania. Instrukcja FOR przechodzi przez listę utworzoną przezrange() function. Na przykład -

for num in range(5):
   print num

Generuje następujący wynik -

Złożona logika programowania jest podzielona na jeden lub więcej niezależnych bloków instrukcji wielokrotnego użytku nazywanych funkcjami. Biblioteka standardowa Pythona zawiera dużą liczbę wbudowanych funkcji. Można również zdefiniować własną funkcję za pomocądefsłowo kluczowe. Po nazwie funkcji zdefiniowanej przez użytkownika następuje blok instrukcji, który tworzy jej treść i kończy się instrukcją return.

Po zdefiniowaniu można go wywoływać z dowolnego środowiska dowolną liczbę razy. Rozważmy następujący kod, aby wyjaśnić sprawę.

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

#calling the function
SayHello()

Funkcja może być zaprojektowana tak, aby otrzymywać jeden lub więcej parametrów / argumentów ze środowiska wywołującego. Wywołując taką sparametryzowaną funkcję należy podać taką samą liczbę parametrów z podobnymi typami danych użytymi w definicji funkcji, w przeciwnym razie interpreter JythonaTypeError wyjątek.

Przykład

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

Plik output będzie następująca -

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

Po wykonaniu zdefiniowanych w nim czynności wywoływana funkcja powraca do środowiska wywołującego. Może zwrócić dane, jeśli przed słowem kluczowym return w definicji funkcji znajduje się wyrażenie.

#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

Poniższe dane wyjściowe są uzyskiwane, jeśli powyższy skrypt jest wykonywany z zachęty języka Jython.

area = 200
value returned by function : 200

Moduł to skrypt w języku Jython, w którym zdefiniowano jedną lub więcej powiązanych funkcji, klas lub zmiennych. Pozwala to na logiczną organizację kodu Jython. Elementy programu zdefiniowane w module można wykorzystać w innym skrypcie Jython, importując z niego moduł lub określony element (funkcję / klasę).

W poniższym kodzie (hello.py) funkcja SayHello() definiuje.

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

Aby użyć funkcji SayHello () z innego skryptu, zaimportuj plik hello.py module w tym.

import hello
hello.SayHello("TutorialsPoint")

Jednak spowoduje to zaimportowanie wszystkich funkcji zdefiniowanych w module. Aby zaimportować określoną funkcję z modułu, użyj następującej składni.

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

Na przykład, aby zaimportować tylko funkcję SayHello (), zmień powyższy skrypt w następujący sposób.

from hello import SayHello
SayHello("TutorialsPoint")

Nie ma potrzeby poprzedzania nazwy modułu podczas wywoływania funkcji.

Każdy folder zawierający jeden lub więcej modułów Jythona jest rozpoznawany jako pakiet. Jednak musi mieć specjalny plik o nazwie__init__.py, który zawiera indeks funkcji do użycia.

Zrozummy teraz, jak stworzyć i zaimportować pakiet.

Step 1 - Utwórz folder o nazwie package1, a następnie utwórz i zapisz następujące g moduły w nim.

#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 - W folderze package1 utwórz i zapisz plik __init__.py plik z następującą zawartością.

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

Step 3 - Utwórz następujący skrypt Jython poza folderem pakiet1 jako 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- Uruchom test.py z zachęty Jythona. Zostanie uzyskany następujący wynik.

factorial = 120
addition = 30
multiplication = 200

Pobieranie jython-standalone-2.7.0.jar - Do osadzania Jythona w aplikacjach Java z ich oficjalnej strony pobierania: http://www.jython.org/downloads.html i dołącz ten plik jar do zmiennej środowiskowej Java CLASSPATH.

Ta biblioteka zawiera PythonInterpreterklasa. Korzystając z obiektu tej klasy, można wykonać dowolny skrypt w języku Python przy użyciu rozszerzeniaexecfile()metoda. PythonInterpreter umożliwia korzystanie zPyObjectsbezpośrednio. Wszystkie obiekty znane systemowi wykonawczemu Jython są reprezentowane przez instancję klasy PyObject lub jedną z jej podklas.

Klasa PythonInterpreter zawiera kilka regularnie używanych metod, które zostały wyjaśnione w poniższej tabeli.

Sr.No.	Metoda i opis
1	setIn(PyObject) Ustaw obiekt Pythona, który ma być używany jako standardowy strumień wejściowy
2	setIn(java.io.Reader) Ustaw java.io.Reader do użycia dla standardowego strumienia wejściowego
3	setIn(java.io.InputStream) Ustaw java.io.InputStream do użycia dla standardowego strumienia wejściowego
4	setOut(PyObject) Ustaw obiekt Pythona, który ma być używany jako standardowy strumień wyjściowy
5	setOut(java.io.Writer) Ustaw java.io.Writer do użycia dla standardowego strumienia wyjściowego
6	setOut(java,io.OutputStream) Ustaw java.io.OutputStream do użycia dla standardowego strumienia wyjściowego
7	setErr(PyObject) Ustaw obiekt błędu Pythona, który ma być używany dla standardowego strumienia błędów
8	setErr(java.io.Writer Ustaw java.io.Writer, który będzie używany dla standardowego strumienia błędów
9	setErr(java.io.OutputStream) Ustaw java.io.OutputStream do użycia dla standardowego strumienia błędów
10	eval(String) Oceń ciąg jako źródło Pythona i zwróć wynik
11	eval(PyObject) Oceń obiekt kodu Python i zwróć wynik
12	exec(String) Wykonaj łańcuch źródłowy języka Python w lokalnej przestrzeni nazw
13	exec(PyObject) Wykonaj obiekt kodu Pythona w lokalnej przestrzeni nazw
14	execfile(String filename) Wykonaj plik źródła Pythona w lokalnej przestrzeni nazw
15	execfile(java.io.InputStream) Wykonaj strumień wejściowy źródła języka Python w lokalnej przestrzeni nazw
16	compile(String) Skompiluj ciąg źródłowy języka Python jako wyrażenie lub moduł
17	compile(script, filename) Skompiluj skrypt źródła Pythona jako wyrażenie lub moduł
18	set(String name, Object value) Ustaw zmienną typu Object w lokalnej przestrzeni nazw
19	set(String name, PyObject value) Ustaw zmienną typu PyObject w lokalnej przestrzeni nazw
20	get(String) Uzyskaj wartość zmiennej w lokalnej przestrzeni nazw
21	get(String name, Class javaclass Uzyskaj wartość zmiennej w lokalnej przestrzeni nazw. Wartość zostanie zwrócona jako instancja danej klasy Java.

Poniższy blok kodu to program w języku Java z wbudowanym skryptem Jython “hello.py”.usingexecfile()metoda obiektu PythonInterpreter. Pokazuje również, jak zmienną Pythona można ustawić lub odczytać za pomocą metod set () i 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 ");
   }
}

Skompiluj i uruchom powyższy program Java, aby uzyskać następujące dane wyjściowe.

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

PyDev to wtyczka typu open source do środowiska Eclipse IDE, która umożliwia tworzenie projektów w językach Python, Jython i IronPython. Jest hostowany pod adresemhttps://pydev.org. Poniżej przedstawiono szczegółową procedurę instalacji wtyczki PyDev w środowisku Eclipse IDE.

Step 1 - Otwórz Eclipse IDE i wybierz plik Install New Software opcję z menu Pomoc.

Step 2 - Wejdź http://pydev.org/updatesw polu tekstowym przed pracą z etykietą i kliknij dodaj. Wybierz wszystkie dostępne wpisy na liście i kliknij Dalej. Kreator zajmie kilka minut, aby zakończyć instalację i poprosi o ponowne uruchomienie IDE.

Step 3- Teraz wybierz opcję preferencji z menu Okno. Otworzy się okno dialogowe Preferencje, jak pokazano poniżej.

Step 4- Rozwiń węzeł Interpreters i wybierz Jython Interpreter w lewym okienku. W prawym okienku kliknij nowy, aby podać ścieżkę do plikujython.jar file.

Jesteśmy teraz gotowi do rozpoczęcia projektu Jython przy użyciu Eclipse.

Aby wykonać projekt w zaćmieniu, powinniśmy wykonać poniższe czynności.

Step 1- Wybierz plik? Nowy ? Projekt. WybieraćPyDevz okna filtru. Podaj nazwę projektu, typ projektu i kliknij Zakończ.

Step 2- Projekt Hello pojawi się teraz w eksploratorze projektów po lewej stronie. Kliknij prawym przyciskiem myszy, aby dodać do niego hello.py.

Step 3- W edytorze pojawi się pusty hello.py. Napisz kod Jython i zapisz.

Step 4- Kliknij przycisk Uruchom na pasku menu. Dane wyjściowe pojawią się w oknie konsoli, jak pokazano poniżej.

Obsługa języków Python i Jython dla NetBeans jest dostępna za pośrednictwem nbPython plugin. Pobierz wtyczkę z następującego adresu URL -http://plugins.netbeans.org/plugin/56795. Rozpakuj pobrane archiwum w jakimś folderze. Na przykład -d:\nbplugin. Aby zainstalować wtyczkę NetBeans, wykonajmy kroki podane poniżej.

Step 1 - Uruchom Netbeans IDEa następnie przejdź do Narzędzia / Wtyczka, aby otworzyć Menedżera wtyczek. Wybierz zakładkę „Pobrane” i przejdź do folderu, w którym pobrany plik został rozpakowany. Pojawi się okno NetBeans, jak pokazano poniżej.

Step 2 - Następnym krokiem jest wybranie wszystkich plików .nbm pliki i kliknij Otwórz.

Step 3 - Kliknij przycisk Instaluj.

Step 4 - Zaakceptuj następującą umowę licencyjną, aby kontynuować.

Zignoruj ostrzeżenie o niezaufanym źródle wtyczek i uruchom ponownie IDE, aby kontynuować.

Projekt Jython w NetBeans

Po ponownym uruchomieniu rozpocznij nowy projekt, wybierając Plik / Nowy. Kategoria Python będzie teraz dostępna na liście kategorii. Wybierz, aby kontynuować.

Jeśli system ma zainstalowany Python, jego wersja / wersje zostaną automatycznie wykryte i wyświetlone na liście rozwijanej platformy Python. Jednak język Jython nie zostanie wymieniony. Kliknij przycisk Zarządzaj, aby go dodać.

Kliknij przycisk „Nowy”, aby dodać nazwę platformy i ścieżkę do pliku wykonywalnego Jython.

Jython będzie teraz dostępny na liście platform. Wybierz z listy rozwijanej, jak pokazano na poniższym zrzucie ekranu.

Możemy teraz w następnym oknie wpisać nazwę projektu, lokalizację i plik główny.

Struktura projektu pojawi się w oknie projektów środowiska NetBeans IDE, a szablon kodu w języku Python w oknie edytora.

Skompiluj i uruchom projekt w języku Jython, aby uzyskać następujący wynik w oknie wyjściowym środowiska NetBeans IDE.

Serwlet Java jest najczęściej używaną techniką tworzenia stron internetowych. Możemy używać Jythona do pisania serwletów, a to dodaje wiele innych korzyści poza tym, co ma do zaoferowania Java, ponieważ teraz możemy również korzystać z funkcji języka Python.

Będziemy używać NetBeans IDE do tworzenia aplikacji internetowych w języku Java z serwletem Jython. Upewnij się, żenbPython pluginjest zainstalowany w instalacji NetBeans. Rozpocznij nowy projekt, aby zbudować aplikację internetową, wybierając następującą ścieżkę -File → New Project → Java web → New Web Application.

Podaj nazwę i lokalizację projektu. Środowisko IDE utworzy strukturę folderów projektu. Dodaj plik serwletu Java (ServletTest.java) w węźle pakietów źródłowych w oknie Projekty. To dodaservlet-api.jarw folderze lib projektu. Niech IDE utworzy również plik web.xmldescriptor file. Dodaj następujący kod wServletTest.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>"
      );
   }
}

Plik web.xml utworzony przez NetBeans będzie wyglądał tak, jak pokazano poniżej -

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

Skompiluj i uruchom projekt, aby uzyskać tekst Servlet Testpojawiające się w tagu <h1> w oknie przeglądarki. Dlatego dodaliśmy do aplikacji zwykły serwlet Java.

Teraz dodamy serwlet Jython. Serwlety Jython działają za pośrednictwem pośredniego serwletu Java, znanego również jako PyServlet. Klasa PyServlet.class znajduje się w plikujython standalone.jar. Dodaj go wWEB-INF/lib teczka.

Następnym krokiem jest skonfigurowanie web.xml do wywoływania PyServlet, gdy tylko pojawi się żądanie *.py filejest podniesiony. Należy to zrobić, dodając w nim następujący kod xml.

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

Pełny kod web.xml będzie wyglądał tak, jak pokazano poniżej.

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

Umieść następujący kod Jython w folderze WEB-INF wewnątrz folderu projektu jako JythonServlet.py, co jest odpowiednikiem poprzedniego ServletTest.java.

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

Zbuduj projekt i otwórz w przeglądarce następujący adres URL -

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

Przeglądarka pokaże plik Servlet Test w tagu <h1> tak jak w przypadku wyjścia Java Servlet.

Jython używa zxJDBC packagektóry zapewnia łatwe w użyciu opakowanie Pythona wokół JDBC. zxJDBC łączy dwa standardy:JDBC to standardowa platforma dostępu do baz danych w Javie, a DBI to standardowy interfejs API bazy danych dla aplikacji w języku Python.

ZxJDBC zapewnia interfejs zgodny ze standardem DBI 2.0 dla JDBC. Ponad 200 sterowników jest dostępnych dla JDBC i wszystkie współpracują z zxJDBC. Wysokowydajne sterowniki są dostępne dla wszystkich głównych relacyjnych baz danych, w tym -

DB2
Derby
MySQL
Oracle
PostgreSQL
SQLite
SQL Server i
Sybase.

Pakiet ZxJDBC można pobrać z witryny https://sourceforge.net/projects/zxjdbc/ lub http://www.ziclix.com/zxjdbc/. Pobrane archiwum zawiera plik ZxJDBC.jar, który należy dodać do zmiennej środowiskowej CLASSPATH.

Zamierzamy nawiązać połączenie bazy danych z bazą danych MySQL. W tym celu wymagany jest sterownik JDBC dla MySQL. PobierzMySQL J connector z poniższego linku - https://dev.mysql.com/downloads/connector/j/ i dołącz łącznik mysql java-5.1.42-bin.jar do CLASSPATH.

Zaloguj się do serwera MySQL i utwórz tabelę uczniów w testowej bazie danych o następującej strukturze -

Pole	Rodzaj	Szerokość
Nazwa	Varchar	10
Wiek	Int	3
Znaki	Int	3

Dodaj w nim kilka rekordów.

Nazwa	Wiek	Znaki
Ravi	21	78
Ashok	20	65
Indygowiec	22	71

Utwórz następujący skrypt Jython jako 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

Wykonaj powyższy skrypt z wiersza poleceń Jython. Rekordy w tabeli uczniów zostaną wyświetlone, jak pokazano poniżej -

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

To wyjaśnia procedurę tworzenia JDBC w Jythonie.

Jedną z głównych cech Jythona jest możliwość korzystania z biblioteki Swing GUI w JDK. Standardowa dystrybucja Pythona (często nazywana CPython) ma rozszerzenieTkinter GUI librarywysłane z nim. Inne biblioteki GUI, takie jakPyQt i WxPython są również dostępne do użytku z nim, ale biblioteka swing oferuje niezależny od platformy zestaw narzędzi GUI.

Korzystanie z biblioteki swing w Jythonie jest znacznie łatwiejsze w porównaniu do używania jej w Javie. W Javie do tworzenia powiązań zdarzeń muszą być używane klasy anonimowe. W Jythonie możemy po prostu przekazać funkcję w tym samym celu.

Podstawowe okno najwyższego poziomu jest tworzone przez zadeklarowanie obiektu klasy JFrame classi ustaw jego właściwość visible na true. W tym celu należy zaimportować klasę Jframe z pakietu swing.

from javax.swing import JFrame

Klasa JFrame ma wiele konstruktorów z różną liczbą argumentów. Użyjemy tego, który przyjmuje ciąg jako argument i ustawia go jako tytuł.

frame = JFrame(“Hello”)

Ustaw właściwości rozmiaru i położenia ramki przed ustawieniem jej właściwości visible na true. Zapisz następujący kod jakoframe.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)

Uruchom powyższy skrypt z wiersza polecenia. Wyświetli następujące dane wyjściowe pokazujące okno.

Biblioteka Swing GUI jest dostarczana w postaci javax.swingpakiet w Javie. Główne klasy kontenerów,JFrame i JDialogpochodzą odpowiednio z klas Frame i Dialog, które znajdują się w bibliotece AWT. Inne kontrolki GUI, takie jakJLabel, JButton, JTextField, itp. pochodzą z klasy JComponent.

Na poniższej ilustracji przedstawiono hierarchię klas pakietu Swing.

Poniższa tabela podsumowuje różne klasy sterowania GUI w bibliotece swing -

Sr.No.	Klasa i opis
1	JLabel Obiekt JLabel to komponent służący do umieszczania tekstu w kontenerze.
2	JButton Ta klasa tworzy przycisk z etykietą.
3	JColorChooser JColorChooser udostępnia panel kontrolek zaprojektowany, aby umożliwić użytkownikowi manipulowanie i wybieranie koloru.
4	JCheckBox JCheckBox to składnik graficzny, który może znajdować się w pliku on (prawda lub off (fałszywy) stan.
5	JRadioButton Klasa JRadioButton to komponent graficzny, który może znajdować się w stanie włączenia (prawda) lub wyłączenia (fałsz). w grupie.
6	JList Komponent JList przedstawia użytkownikowi przewijaną listę elementów tekstowych.
7	JComboBox Komponent JComboBox przedstawia użytkownikowi rozwijaną listę elementów
8	JTextField Obiekt JTextField to komponent tekstowy, który umożliwia edycję pojedynczego wiersza tekstu.
9	JPasswordField Obiekt JPasswordField to składnik tekstowy przeznaczony do wprowadzania hasła.
10	JTextArea Obiekt JTextArea jest składnikiem tekstowym, który umożliwia edycję wielu wierszy tekstu.
11	ImageIcon Formant ImageIcon jest implementacją interfejsu Icon, który maluje ikony z obrazów
12	JScrollbar Element sterujący Scrollbar reprezentuje składnik paska przewijania umożliwiający użytkownikowi wybór z zakresu wartości.
13	JOptionPane JOptionPane zapewnia zestaw standardowych okien dialogowych, które monitują użytkowników o podanie wartości lub informują ich o czymś.
14	JFileChooser Kontrolka JFileChooser reprezentuje okno dialogowe, w którym użytkownik może wybrać plik.
15	JProgressBar W miarę postępu zadania w kierunku ukończenia pasek postępu wyświetla procent wykonania zadania.
16	JSlider JSlider pozwala użytkownikowi graficznie wybrać wartość, przesuwając gałkę w określonym przedziale.
17	JSpinner JSpinner to jednowierszowe pole wejściowe, które pozwala użytkownikowi wybrać liczbę lub wartość obiektu z uporządkowanej sekwencji.

W kolejnych przykładach będziemy używać niektórych z tych kontrolek.

Menedżerowie układu w Javie to klasy, które zarządzają rozmieszczeniem elementów sterujących w obiektach kontenera, takich jak Frame, Dialog lub Panel. Menedżerowie układu zachowują względne położenie elementów sterujących w klatce, nawet jeśli zmieni się rozdzielczość lub rozmiar samej klatki.

Te klasy implementują Layout interface. Następujące menedżery układu są zdefiniowane wAWT library -

BorderLayout
FlowLayout
GridLayout
CardLayout
GridBagLayout

Następujący menedżerowie układu są zdefiniowani w Swing library -

BoxLayout
GroupLayout
ScrollPaneLayout
SpringLayout

W poniższych przykładach będziemy używać menedżerów układów AWT, a także menedżerów układów swing.

Układ absolutny
Układ przepływu
Układ siatki
Układ obramowania
Układ pudełka
Układ grupowy

Omówmy teraz szczegółowo każdą z nich.

Układ absolutny

Zanim przejdziemy do wszystkich powyższych menedżerów układu, musimy przyjrzeć się bezwzględnemu położeniu kontrolek w kontenerze. Musimy ustawić metodę układu obiektu ramki na „Brak”.

frame.setLayout(None)

Następnie umieść formant, wywołując metodę setBounds()metoda. Wymaga czterech argumentów - pozycji x, pozycji y, szerokości i wysokości.

Na przykład - Aby umieścić obiekt przycisku w pozycji bezwzględnej i wielkości bezwzględnej.

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

Podobnie, wszystkie kontrolki można umieścić, odpowiednio przydzielając pozycję i rozmiar. Ten układ jest stosunkowo łatwy w użyciu, ale nie zachowuje swojego wyglądu, gdy zmienia się rozmiar okna lub gdy program jest wykonywany, gdy zmienia się rozdzielczość ekranu.

W poniższym skrypcie Jython trzy obiekty Jlabel są używane do wyświetlania tekstu odpowiednio „phy”, „matematyka” i „suma”. Przed tymi trzema - obiekty JTextField są umieszczone. Obiekt przycisku jest umieszczany nad etykietą „Suma”.

Przede wszystkim tworzone jest okno JFrame z układem ustawionym na brak.

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

Następnie dodawane są różne kontrolki w zależności od ich bezwzględnej pozycji i rozmiaru. Pełny kod znajduje się poniżej -

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)

Dane wyjściowe dla powyższego kodu są następujące.

Jython FlowLayout

FlowLayout to domyślny menedżer układu dla klas kontenerów. Układa sterowanie od lewej do prawej, a następnie od góry do dołu.

W poniższym przykładzie obiekt Jlabel, obiekt JTextField i obiekt JButton mają być wyświetlane w JFrame przy użyciu menedżera FlowLayout. Na początek zaimportujmy wymagane klasy z plikujavax.swing pakiet i java.awt pakiet.

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

Następnie utwórz obiekt JFrame i ustaw jego lokalizację oraz właściwości rozmiaru.

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

Teraz zadeklaruj obiekty dla klas JLabel, JTextfield i JButton.

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

Na koniec dodaj te kontrolki w ramce, wywołując metodę add() metoda klasy JFrame.

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

Aby wyświetlić ramkę, ustaw jej właściwość visible na true. Kompletny skrypt Jython i jego dane wyjściowe są podane poniżej -

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

Menedżer Gridlayout umożliwia umieszczenie kontrolek w prostokątnej siatce. W każdej komórce siatki umieszczana jest jedna kontrolka.

W poniższym przykładzie GridLayout jest stosowany do obiektu JFrame, dzieląc go na 4 wiersze i 4 kolumny. Obiekt JButton należy umieścić w każdej komórce siatki.

Najpierw zaimportujmy wymagane biblioteki -

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

Następnie utwórz kontener JFrame -

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

Teraz zastosuj GridLayout, określając jego wymiary jako 4 na 4.

frame.setLayout(GridLayout(4,4))

Powinniśmy teraz użyć dwóch pętli FOR, z których każda przechodzi od 1 do 4, więc szesnaście obiektów JButton jest umieszczanych w kolejnych komórkach.

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

Na koniec ustaw widoczność ramki na true. Pełny kod Jythona znajduje się poniżej.

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)

Dane wyjściowe powyższego kodu są następujące -

Jython BorderLayout

Menedżer BorderLayout dzieli kontener na pięć regionów i miejsc geograficznych, z jednym komponentem w każdym regionie. Regiony te są reprezentowane przez zdefiniowane stałe w następujący sposób -

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

Rozważmy następujący przykład -

Jython BoxLayout

Klasa BoxLayout jest zdefiniowana w javax.swing package. Służy do układania elementów w pojemniku w pionie lub w poziomie. Kierunek jest określany przez następujące stałe -

X_AXIS
Y_AXIS
LINE_AXIS
PAGE_AXIS

Stała całkowita określa oś, wzdłuż której należy rozłożyć komponenty kontenera. Gdy kontener ma domyślną orientację komponentów, LINE_AXIS określa, że komponenty mają być rozłożone od lewej do prawej, a PAGE_AXIS określa, że komponenty mają być rozłożone od góry do dołu.

W poniższym przykładzie panel (klasy JPanel) jest dodany do obiektu JFrame. Zastosowano do niego pionowy układ BoxLayout i dodano do niego dwa dodatkowe panele, górny i dolny. Te dwa wewnętrzne panele mają po dwa przyciski, każdy dodany w poziomym Boxlayout.

Najpierw utwórzmy okno JFrame najwyższego poziomu.

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

Zadeklarowano obiekt JPanel mający pionowy układ BoxLayout. Dodaj go w ramce najwyższego poziomu.

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

W tym panelu dodawane są do niego jeszcze dwa panele, góra i dół. Każdy z nich ma dwa obiekty JButton dodane do nich poziomo z separatorem 25 pikseli.

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

Podobnie skonstruowany jest panel dolny.

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

Zwróć uwagę, że createRigidArea()Funkcja służy do tworzenia odstępu 25 pikseli między dwoma przyciskami. RównieżcreateVerticalGlue() funkcja zajmuje początkową lub końcową spację w układzie.

Na początek dodaj górny i dolny panel i ustaw właściwość visibility ramki na true. Kompletny kod wygląda następująco -

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)

Powyższy kod wygeneruje następujące dane wyjściowe.

Jython GroupLayout

Menedżer GroupLayout grupuje komponenty w sposób hierarchiczny. Grupowanie odbywa się według dwóch klas,SequentialGroup i ParallelGroup, oba implementują interfejs grupowy w Javie.

Procedura układu jest podzielona na dwa etapy. W jednym kroku elementy są umieszczane wzdłuż osi poziomej, aw drugim wzdłuż osi pionowej. Każdy komponent należy zdefiniować dwukrotnie w układzie.

Istnieją dwa rodzaje aranżacji, sekwencyjne i równoległe. W obu możemy układać elementy sekwencyjnie lub równolegle. W układzie poziomym wiersz nazywany jest grupą sekwencyjną, a kolumna - grupą równoległą. Z kolei w układzie równoległym rząd elementu jest grupą równoległą i kolumną, co nazywa się sekwencyjnym.

W poniższym przykładzie pięć przycisków jest ułożonych w taki sposób, że po trzy pojawiają się w wierszu i kolumnie. Na początek dodaj obiekt Jpanel w oknie JFrame i ustaw jego układ jako Grouplayout.

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

Następnie skonstruuj obiekty JButton -

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

Następnie tworzymy plik SequentialGroup o imieniu LeftToRightdo którego buttonD i buttonY zostały dodane. Pomiędzy nimi znajduje się ParallelGroup ColumnMiddle (z innymi trzema przyciskami dodanymi pionowo).

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

Teraz pojawia się definicja pionowej grupy SequentialGroup o nazwie TopToBottom. Dodaj wiersz ParallelGroup trzech przycisków, a następnie odłóż dwa przyciski pionowo.

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

Na koniec ustaw grupę LeftToRight w poziomie i grupę TopToBottom pionowo do obiektu układu. Pełny kod znajduje się poniżej -

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)

Dane wyjściowe powyższego kodu są następujące -

Obsługa zdarzeń w Java Swing wymaga, aby formant (taki jak JButton lub JList itp.) Był zarejestrowany w odpowiednim detektorze zdarzeń. Interfejs nasłuchiwania zdarzeń lub odpowiadająca mu klasa adaptera musi zostać zaimplementowana lub poddana podklasie z przesłonięciem metody obsługi zdarzeń. W Jythonie obsługa zdarzeń jest bardzo prosta. Możemy przekazać dowolną funkcję jako właściwość funkcji obsługi zdarzenia odpowiadającej sterowaniu.

Zobaczmy najpierw, jak obsługiwane jest zdarzenie kliknięcia w Javie.

Na początek musimy zaimportować plik java.awt.event package. Następnie klasa rozszerzająca JFrame musi implementować interfejs ActionListener.

public class btnclick extends JFrame implements ActionListener

Następnie musimy zadeklarować obiekt JButton, dodać go do ContentPane ramki, a następnie zarejestrować w ActionListener za pomocą metody addActionListener ().

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

Teraz metoda actionPerformed () interfejsu ActionListener musi zostać przesłonięta, aby obsłużyć zdarzenie ActionEvent.

Poniżej znajduje się cały kod 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);
   }
}

Teraz napiszemy kod Jython odpowiadający temu samemu kodowi.

Na początek nie musimy importować ActionEvent ani ActionListener, ponieważ dynamiczne pisanie w języku Jython pozwala nam uniknąć wspominania o tych klasach w naszym kodzie.

Po drugie, nie ma potrzeby implementowania lub tworzenia podklasy ActionListener. Zamiast tego każda funkcja zdefiniowana przez użytkownika jest od razu dostarczana do konstruktora JButton jako wartośćactionPerformed własność fasoli.

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

Plik clickhere() funkcja jest zdefiniowana jako zwykła funkcja Jythona, która obsługuje zdarzenie kliknięcia przycisku.

def change_text(event):
print clicked!'

Oto odpowiednik kodu w języku 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)

Dane wyjściowe kodu Java i Jython są identyczne. Kliknięcie przycisku spowoduje wydrukowanie komunikatu „klikniętego” na konsoli.

W poniższym kodzie Jython w oknie JFrame znajdują się dwa obiekty JTextField służące do wprowadzania znaków w „phy” i „maths”. Po kliknięciu obiekt JButton wykonuje funkcję add ().

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

Funkcja add () odczytuje zawartość dwóch pól tekstowych za pomocą metody getText () i analizuje je na liczby całkowite, aby można było wykonać dodawanie. Wynik jest następnie umieszczany w trzecim polu tekstowym za pomocą metody setText ().

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

Pełny kod znajduje się poniżej -

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)

Gdy powyższy kod jest wykonywany z wiersza polecenia, pojawia się następujące okno. Wpisz oceny dla „Phy”, Maths ”i kliknij przycisk„ Add ”. Wynik zostanie odpowiednio wyświetlony.

Jython JRadioButton Event

Klasa JRadioButton jest zdefiniowana w javax.swing package. Tworzy wybieralny przycisk przełączania ze stanami włączenia lub wyłączenia. Jeśli w ButtonGroup dodano wiele przycisków opcji, ich wybór wyklucza się wzajemnie.

W poniższym przykładzie dwa obiekty klasy JRadioButton i dwa JLabels są dodawane do kontenera Jpanel w pionowym BoxLayout. W konstruktorze obiektów JRadioButton plikOnCheck()function jest ustawiana jako wartość właściwości actionPerformed. Ta funkcja jest wykonywana po kliknięciu przycisku opcji w celu zmiany jej stanu.

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

Zauważ, że domyślny stan przycisku radiowego to fałsz (nie wybrano). Zostanie utworzony przycisk rb1 ze stanem początkowym True (zaznaczony).

Dwa przyciski opcji są dodawane do grupy ButtonGroup, aby wzajemnie się wykluczały, więc jeśli jeden zostanie wybrany, drugi zostanie automatycznie odznaczony.

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

Te dwa przyciski opcji wraz z dwiema etykietami są dodawane do obiektu panelu w układzie pionowym z obszarem separatora 25 pikseli o wysokości między rb2 i 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)

Ten panel jest dodawany do obiektu JFrame najwyższego poziomu, którego właściwość visible jest ostatecznie ustawiona na „True”.

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)

Uruchom powyższy skrypt Jython i zmień wybór przycisku opcji. Wybór pojawi się na etykiecie u dołu.

Jython JCheckBox Event

Jak JRadioButton, Obiekt JCheckBox jest również przyciskiem do wyboru z prostokątnym polem do zaznaczania obok podpisu. Zwykle jest to używane, aby zapewnić użytkownikowi możliwość wyboru wielu opcji z listy elementów.

W poniższym przykładzie dwa pola wyboru i etykieta z pakietu swing są dodawane do pliku JPanel w układzie pionowym BoxLayout. Etykieta na dole wyświetla natychmiastowy stan wyboru dwóch pól wyboru.

Oba pola wyboru są zadeklarowane za pomocą konstruktora, którego właściwość actionPerformed została ustawiona na OnCheck() funkcjonować.

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

Funkcja OnCheck () weryfikuje stan wyboru każdego pola wyboru i wyświetla odpowiedni komunikat na etykiecie u dołu.

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"

Te pola i obiekt JLabel są dodawane do JPanel z dodanym spacją o wysokości 50 pikseli między nimi.

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)

Sam panel jest dodawany do okna JFrame najwyższego poziomu, którego właściwość visible jest na końcu ustawiona na true.

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

frame.setVisible(True)

Uruchom powyższy kod i eksperymentuj z zaznaczaniem pól wyboru. Natychmiastowy stan obu pól wyboru jest wyświetlany u dołu.

Jython JList Event

Kontrolka JList w pakiecie swing zapewnia użytkownikowi przewijaną listę elementów do wyboru. JComboBox udostępnia rozwijaną listę elementów. W Javie zdarzenie selekcji jest przetwarzane poprzez implementację metody valueChanged () w ListSelectionListener. W języku Jython procedura obsługi zdarzeń jest przypisana do właściwości valueChanged obiektu JList.

W poniższym przykładzie obiekt JList i etykieta są dodawane do JFrame w BorderLayout. JList jest wypełniana kolekcją elementów w krotce. Jego właściwość valueChanged jest ustawiona na funkcję listSelect ().

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

Funkcja obsługi zdarzeń uzyskuje indeks wybranego elementu i pobiera odpowiedni element z obiektu JList do wyświetlenia na etykiecie na dole.

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

Obiekty JList i JLabel są dodawane do JFrame przy użyciu BorderLayout.

Cały kod jest podany poniżej -

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)

Dane wyjściowe następującego kodu są następujące.

Większość aplikacji opartych na GUI ma pasek menu u góry. Znajduje się tuż pod paskiem tytułu okna najwyższego poziomu. Pakiet javax.swing zawiera rozbudowane narzędzie do tworzenia wydajnego systemu menu. Jest zbudowany za pomocąJMenuBar, JMenu i JMenuItem zajęcia.

W poniższym przykładzie pasek menu znajduje się w oknie najwyższego poziomu. Do paska menu zostanie dodane menu Plik składające się z trzech przycisków pozycji menu. Przygotujmy teraz obiekt JFrame z układem ustawionym na BorderLayout.

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

Teraz obiekt JMenuBar jest aktywowany przez metodę SetJMenuBar ().

bar = JMenuBar()
frame.setJMenuBar(bar)

Następnie deklarowany jest obiekt JMenu z podpisem „Plik”. Do menu Plik dodano trzy przyciski JMenuItem. Kliknięcie dowolnego elementu menu powoduje wykonanie funkcji OnClick () obsługi zdarzenia ActionEvent. Jest definiowany za pomocą właściwości 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)

Procedura obsługi zdarzeń OnClick () pobiera nazwę przycisku JMenuItem za pomocą funkcji gwtActionCommand () i wyświetla ją w polu tekstowym u dołu okna.

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

Obiekt menu Plik zostanie dodany do paska menu. Na koniec kontrolka JTextField jest dodawana u dołu obiektu JFrame.

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

Cały kod menu.py jest podany poniżej -

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)

Kiedy powyższy skrypt jest wykonywany przy użyciu interpretera Jythona, pojawia się okno z menu Plik. Kliknij go, a pojawią się trzy elementy menu. Jeśli zostanie kliknięty dowolny przycisk, jego nazwa zostanie wyświetlona w kontrolce pola tekstowego.

Obiekt Dialog to okno, które pojawia się w górnej części okna podstawowego, z którym współdziała użytkownik. W tym rozdziale zobaczymy wstępnie skonfigurowane okna dialogowe zdefiniowane w bibliotece swing. Oni sąMessageDialog, ConfirmDialog i InputDialog. Są one dostępne dzięki statycznej metodzie klasy JOptionPane.

W poniższym przykładzie menu Plik zawiera trzy elementy JMenu odpowiadające trzem powyższym oknom; każdy wykonujeOnClick moduł obsługi zdarzeń.

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)

Funkcja obsługi OnClick () pobiera podpis przycisku Element menu i wywołuje odpowiednią metodę showXXXDialog ().

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

Jeśli wybierzesz opcję wiadomości z menu, pojawi się komunikat. Jeśli kliknięto opcję Wejście, pojawi się okno dialogowe z prośbą o wprowadzenie danych. Wprowadzony tekst jest następnie wyświetlany w polu tekstowym w oknie JFrame. Jeśli wybrana jest opcja Potwierdź, pojawi się okno dialogowe z trzema przyciskami TAK, NIE i ANULUJ. Wybór użytkownika jest zapisywany w polu tekstowym.

Cały kod jest podany poniżej -

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)

Po wykonaniu powyższego skryptu zostanie wyświetlone następujące okno z trzema opcjami w menu -