Jython - Guida rapida

Jython è l'implementazione JVM del linguaggio di programmazione Python. È progettato per funzionare sulla piattaforma Java. Un programma Jython può importare e utilizzare qualsiasi classe Java. Proprio come Java, il programma Jython si compila inbytecode. Uno dei principali vantaggi è che un'interfaccia utente progettata in Python può utilizzare elementi GUI diAWT, Swing o SWT Package.

Jython, che è iniziato come JPython e successivamente è stato rinominato, segue da vicino l'implementazione standard di Python chiamata CPython come creato da Guido Van Rossum. Jython è stato creato nel 1997 daJim Hugunin. Jython 2.0 è stato rilasciato nel 1999. Da allora, le versioni di Jython 2.x corrispondono alle versioni CPython equivalenti. Jython 2.7.0 rilasciato a maggio 2015, corrisponde a CPython 2.7. Lo sviluppo di Jython 3.x è in corso.

Differenza tra Python e Java

Di seguito sono riportate le differenze tra Python e Java:

  • Python è un linguaggio tipizzato dinamicamente. Quindi, la dichiarazione del tipo di variabile non è necessaria. Java d'altra parte è un linguaggio tipizzato staticamente, il che significa che la dichiarazione del tipo di variabile è obbligatoria e non può essere modificata.

  • Python ha solo eccezioni non controllate, mentre Java ha eccezioni sia selezionate che non selezionate.

  • Python utilizza i rientri per la definizione dell'ambito, mentre Java utilizza le parentesi graffe corrispondenti.

  • Poiché Python è un linguaggio basato su interpreti, non ha passaggi di compilazione separati. Tuttavia, un programma Java deve essere compilato in bytecode e viene a sua volta eseguito da una JVM.

  • Python supporta l'ereditarietà multipla, ma in Java non è possibile l'ereditarietà multipla. Tuttavia ha l'implementazione di un'interfaccia.

  • Rispetto a Java, Python ha strutture dati integrate più ricche (liste, dict, tuple, tutto è un oggetto).

Differenza tra Python e Jython

Di seguito sono riportate le differenze tra Python e Jython:

  • L'implementazione di riferimento di Python, chiamata CPython, è scritta in linguaggio C. Jython d'altra parte è completamente scritto in Java ed è un'implementazione JVM.

  • Python standard è disponibile su più piattaforme. Jython è disponibile per qualsiasi piattaforma su cui è installata una JVM.

  • Il codice Python standard viene compilato in un file .pyc file, mentre il programma Jython compila in un file .class file.

  • Le estensioni Python possono essere scritte in linguaggio C. Le estensioni per Jython sono scritte in Java.

  • Jython è veramente multi-thread in natura. Python tuttavia utilizza l'estensioneGlobal Interpreter Lock (GIL) meccanismo per lo scopo.

  • Entrambe le implementazioni hanno diversi meccanismi di garbage collection.

Nel prossimo capitolo impareremo come importare le librerie Java in Jython.

Prima dell'installazione di Jython 2.7, assicurati che il sistema abbia JDK 7o più installati. Jython è disponibile sotto forma di un file jar eseguibile. Scaricalo da -http://www.jython.org/downloads.html e fai doppio clic sulla sua icona o esegui il seguente comando:

java -jar jython_installer-2.7.0.jar

Verrà avviata una procedura guidata di installazione con le opzioni di installazione da fornire. Ecco la procedura di installazione sistematica.

Il primo passaggio della procedura guidata richiede di selezionare la lingua.

Il secondo passaggio richiede di accettare il contratto di licenza.

Nel passaggio successivo, scegli il tipo di installazione. Si consiglia di scegliere l'installazione Standard.

La schermata successiva richiede la conferma delle opzioni e procede al completamento dell'installazione.

Il completamento della procedura di installazione potrebbe richiedere del tempo.

Al termine dell'installazione, invoke jython.exedalla directory bin all'interno della directory di destinazione. Supponendo che Jython sia installato inC:\jython27, eseguire quanto segue dalla riga di comando.

C:\jython27\bin\jython

Apparirà un prompt di Python (>>>), davanti al quale è possibile eseguire qualsiasi istruzione o script Python.

Una delle caratteristiche più importanti di Jython è la sua capacità di importare classi Java in un programma Python. Possiamo importare qualsiasi pacchetto o classe java in Jython, proprio come facciamo in un programma Java. L'esempio seguente mostra come iljava.util i pacchetti vengono importati nello script Python (Jython) per dichiarare un oggetto della classe Date.

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

Salva ed esegui il codice sopra come UtilDate.pydalla riga di comando. Verrà visualizzata l'istanza della data e dell'ora correnti.

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

I seguenti pacchetti della libreria Java vengono importati più spesso in un programma Jython principalmente perché la libreria Python standard non ha i loro equivalenti o non è altrettanto buona.

  • Servlets
  • JMS
  • J2EE
  • Javadoc
  • Swing è considerato superiore ad altri toolkit GUI

Qualsiasi pacchetto Java per quella materia può essere importato in uno script Jython. Qui, il seguente programma java viene memorizzato e compilato in un pacchetto chiamatofoo.

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

Questo HelloWorld.classviene importato nel seguente script Jython. I metodi in questa classe possono essere chiamati dallo script Jythonimportex.py.

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

Salva ed esegui lo script precedente dalla riga di comando per ottenere il seguente output.

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

Le variabili sono posizioni denominate nella memoria del computer. Ogni variabile può contenere un dato al suo interno. A differenza di Java, Python è un linguaggio tipizzato dinamicamente. Quindi mentre si usa anche Jython; la dichiarazione preventiva del tipo di dati della variabile non viene eseguita. Piuttosto che il tipo di variabile che decide quali dati possono essere memorizzati in essa, i dati decidono il tipo di variabile.

Nell'esempio seguente, a una variabile viene assegnato un valore intero. Utilizzando la funzione incorporata type (), possiamo verificare che il tipo di variabile sia un numero intero. Ma, se alla stessa variabile viene assegnata una stringa, la funzione type () verrà stringa come il tipo della stessa variabile.

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

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

Questo spiega perché Python è chiamato linguaggio tipizzato dinamicamente.

I seguenti tipi di dati incorporati in Python possono essere utilizzati anche in Jython:

  • Number
  • String
  • List
  • Tuple
  • Dictionary

Python riconosce i dati numerici come un numero, che può essere un numero intero, un numero reale con virgola mobile o un numero complesso. I tipi di dati String, List e Tuple sono chiamati sequenze.

Numeri Jython

In Python, qualsiasi numero intero con segno è detto di tipo "int". Per esprimere un numero intero lungo, viene allegata la lettera "L". Un numero con un punto decimale che separa la parte intera da una componente frazionaria è chiamato "float". La parte frazionaria può contenere un esponente espresso nella notazione scientifica utilizzando "E" o "e".

Un numero complesso è anche definito come tipo di dati numerico in Python. Un numero complesso contiene una parte reale (un numero in virgola mobile) e una parte immaginaria a cui è associata una "j".

Per esprimere un numero nella rappresentazione ottale o esadecimale, 0O o 0Xè prefisso ad esso. Il seguente blocco di codice fornisce esempi di diverse rappresentazioni di numeri 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

Stringhe Jython

Una stringa è una sequenza di caratteri racchiusa tra virgolette singole (es. "Ciao"), doppie (es. "Ciao") o triple (es. "Ciao" o "" ciao ""). Le virgolette triple sono particolarmente utili se il contenuto della stringa si estende su più righe.

I caratteri della sequenza di escape possono essere inclusi alla lettera in una stringa tripla tra virgolette. I seguenti esempi mostrano diversi modi per dichiarare una stringa in Python.

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

La terza stringa, una volta stampata, darà il seguente output.

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.

Elenchi Jython

Un elenco è un tipo di dati di sequenza. È una raccolta di elementi separati da virgole, non necessariamente dello stesso tipo, archiviati tra parentesi quadre. È possibile accedere ai singoli elementi dell'elenco utilizzando l'indice a base zero.

Il seguente blocco di codice riepiloga l'utilizzo di un elenco in Python.

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

La tabella seguente descrive alcune delle espressioni Jython più comuni relative agli elenchi Jython.

Espressione Jython Descrizione
len (Elenco) Lunghezza
Elenco [2] = 10 Aggiornamento
Del List [1] Cancellazione
List.append (20) Aggiungere
List.insert (1,15) Inserimento
List.sort () Ordinamento

Tuple Jython

Una tupla è una raccolta immutabile di elementi di dati separati da virgole archiviati tra parentesi. Non è possibile eliminare o modificare un elemento nella tupla, né è possibile aggiungere un elemento alla raccolta di tupla. Il blocco di codice seguente mostra le operazioni di tupla.

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]

Dizionario Jython

Il dizionario Jython è simile alla classe Map nel framework Java Collection. È una raccolta di coppie chiave-valore. Le coppie separate da virgola sono racchiuse tra parentesi graffe. Un oggetto Dictionary non segue un indice a base zero per recuperare gli elementi al suo interno poiché vengono archiviati mediante la tecnica di hashing.

La stessa chiave non può apparire più di una volta in un oggetto dizionario. Tuttavia, più di una chiave può avere gli stessi valori associati. Le diverse funzioni disponibili con l'oggetto Dictionary sono spiegate di seguito:

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

La tabella seguente descrive alcune delle espressioni Jython più comuni relative a Dictionary.

Espressione Jython Descrizione
dict.get ('011') Ricerca
len (dict) Lunghezza
dict ['044'] = 'Chennai' Aggiungere
del dict ['022'] Elimina
dict.keys () elenco delle chiavi
dict.values ​​() Elenco di valori
dict.clear () Rimuove tutti gli elementi

Oltre ai tipi di dati incorporati di Python, Jython ha il vantaggio di utilizzare le classi di raccolta Java importando il file java.util package. Il codice seguente descrive le classi fornite di seguito:

  • Oggetto Java ArrayList con add ()
  • remove()
  • get () e set () della classe ArrayList.
import java.util.ArrayList as ArrayList
arr = ArrayList()
arr.add(10)
arr.add(20)
print "ArrayList:",arr
arr.remove(10) #remove 10 from arraylist
arr.add(0,5) #add 5 at 0th index
print "ArrayList:",arr
print "element at index 1:",arr.get(1) #retrieve item at index 1
arr.set(0,100) #set item at 0th index to 100
print "ArrayList:",arr

Lo script Jython precedente produce il seguente output:

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

Classe Jarray

Jython implementa anche il Jarray Object, che consente la costruzione di un array Java in Python. Per lavorare con un jarray, è sufficiente definire un tipo di sequenza in Jython e passarlo all'oggetto jarray insieme al tipo di oggetto contenuto nella sequenza. Tutti i valori all'interno di un jarray devono essere dello stesso tipo.

La tabella seguente mostra i codici di tipo carattere utilizzati con un jarray.

Codice tipo di carattere Tipo Java corrispondente
Z Booleano
C char
B byte
H corto
io int
L lungo
F galleggiante
D Doppio

L'esempio seguente mostra la costruzione di 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

Qui my_seqè definito come una tupla di interi. Viene convertito in Jarray arr1. Il secondo esempio mostra che Jarray arr2 è costruito damySttr stringsequenza. L'output dello script precedentejarray.py è il seguente -

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

Le strutture decisionali hanno una o più condizioni che devono essere valutate o testate dal programma, insieme a una o più istruzioni che devono essere eseguite, se la condizione è determinata essere vera, e facoltativamente, altre istruzioni da eseguire, se la condizione è determinato a essere falso.

L'illustrazione seguente mostra la forma generale di una tipica struttura decisionale presente nella maggior parte dei linguaggi di programmazione:

Jython non utilizza parentesi graffe per indicare blocchi di istruzioni da eseguire quando la condizione è vera o falsa (come nel caso di Java). Invece, il rientro uniforme (spazio bianco dal margine sinistro) viene utilizzato per formare un blocco di istruzioni. Un blocco così rientrato uniformemente fa sì che il codice condizionale venga eseguito quando una condizione data nell'istruzione "if" è vera.

Un blocco simile può essere presente dopo un'istruzione "else" opzionale. Jython fornisce anche ilelif statementutilizzando quali condizioni successive possono essere testate. Qui, ilelse clauseapparirà per ultimo e verrà eseguito solo quando tutte le condizioni precedenti falliscono. La sintassi generale dell'utilizzo diif..elif..else è come segue.

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

Nell'esempio seguente, if ..elif ..else viene utilizzato per calcolare lo sconto su diversi valori di importo immesso dall'utente.

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

L'output del codice precedente sarà come mostrato di seguito.

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

In generale, le istruzioni in un programma vengono eseguite sequenzialmente: la prima istruzione in una funzione viene eseguita per prima, seguita dalla seconda e così via. Potrebbe esserci una situazione in cui è necessario eseguire un blocco di codice più volte. Vengono chiamate dichiarazioni che forniscono tale capacità di ripetizionelooping statements.

In Jython, un ciclo può essere formato da due istruzioni, che sono:

  • Il while dichiarazione e

  • Il for dichiarazione

Il ciclo WHILE

Un'istruzione del ciclo while in Jython è simile a quella in Java. Esegue ripetutamente un blocco di istruzioni finché una data condizione è vera. Il seguente diagramma di flusso descrive il comportamento di un filewhile ciclo continuo.

La sintassi generale dell'istruzione while è fornita di seguito.

while expression:
   statement(s)

Il seguente codice Jython utilizza il ciclo while per incrementare e stampare ripetutamente il valore di una variabile finché non è minore di zero.

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

Output - L'output sarebbe il seguente.

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

Il ciclo FOR

Il ciclo FOR in Jython non è un ciclo conteggiato come in Java. Invece, ha la capacità di attraversare gli elementi in un tipo di dati di sequenza come stringa, elenco o tupla. La sintassi generale dell'istruzione FOR in Jython è mostrata di seguito:

for iterating_var in sequence:
   statements(s)

Possiamo visualizzare ogni carattere in una stringa, così come ogni elemento in una lista o tupla utilizzando l'istruzione FOR come mostrato di seguito -

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

Output - L'output sarebbe il seguente.

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

Consideriamo un altro esempio come segue.

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

Output - L'output sarà il seguente.

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

Ecco un altro esempio da considerare.

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

Output - L'output del programma di cui sopra è il seguente.

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

In Jython, il forè anche usata per iterare su un elenco di numeri generati dalla funzione range (). La funzione range () assume la forma seguente:

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

I parametri start e step sono 0 e 1 per impostazione predefinita. L'ultimo numero generato è stop step. L'istruzione FOR attraversa l'elenco formato darange() function. Ad esempio:

for num in range(5):
   print num

Produce il seguente output:

0
1
2
3
4

Una logica di programmazione complessa è suddivisa in uno o più blocchi di istruzioni indipendenti e riutilizzabili chiamati come funzioni. La libreria standard di Python contiene un gran numero di funzioni integrate. Si può anche definire la propria funzione utilizzando ildefparola chiave. Il nome della funzione definito dall'utente è seguito da un blocco di istruzioni che ne forma il corpo, che termina con l'istruzione return.

Una volta definito, può essere richiamato da qualsiasi ambiente un numero qualsiasi di volte. Consideriamo il codice seguente per chiarire il punto.

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

#calling the function
SayHello()

Una funzione può essere progettata per ricevere uno o più parametri / argomenti dall'ambiente chiamante. Durante la chiamata a una tale funzione parametrizzata, è necessario fornire lo stesso numero di parametri con tipi di dati simili utilizzati nella definizione della funzione, altrimenti l'interprete Jython lancia unTypeError eccezione.

Esempio

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

Il output sarà il seguente -

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

Dopo aver eseguito i passaggi in esso definiti, la funzione chiamata ritorna nell'ambiente chiamante. Può restituire i dati, se viene menzionata un'espressione davanti alla parola chiave return all'interno della definizione della funzione.

#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

Il seguente output si ottiene se lo script precedente viene eseguito dal prompt di Jython.

area = 200
value returned by function : 200

Un modulo è uno script Jython in cui sono definite una o più funzioni, classi o variabili correlate. Ciò consente un'organizzazione logica del codice Jython. Gli elementi del programma definiti in un modulo possono essere utilizzati in un altro script Jython importando da esso il modulo o l'elemento specifico (funzione / classe).

Nel codice seguente (hello.py) una funzione SayHello() è definito.

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

Per utilizzare la funzione SayHello () da un altro script, importa il file hello.py module dentro.

import hello
hello.SayHello("TutorialsPoint")

Tuttavia, questo importerà tutte le funzioni definite nel modulo. Per importare una funzione specifica dal modulo, utilizzare la seguente sintassi.

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

Ad esempio, per importare solo la funzione SayHello (), modificare lo script precedente come segue.

from hello import SayHello
SayHello("TutorialsPoint")

Non è necessario aggiungere un prefisso al nome del modulo durante la chiamata alla funzione.

Qualsiasi cartella contenente uno o più moduli Jython viene riconosciuta come un pacchetto. Tuttavia, deve avere un file speciale chiamato__init__.py, che fornisce l'indice delle funzioni da utilizzare.

Vediamo ora come creare e importare il pacchetto.

Step 1 - Crea una cartella chiamata package1, quindi crea e salva quanto segue g moduli in esso.

#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 - Nella cartella package1 creare e salvare il file __init__.py file con il seguente contenuto.

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

Step 3 - Crea il seguente script Jython fuori dalla cartella package1 come 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- Esegui test.py dal prompt di Jython. Si otterrà il seguente output.

factorial = 120
addition = 30
multiplication = 200

Scarica jython-standalone-2.7.0.jar - Per incorporare Jython nelle applicazioni Java dalla loro pagina di download ufficiale: http://www.jython.org/downloads.html e includere questo file jar nella variabile d'ambiente Java CLASSPATH.

Questa libreria contiene il file PythonInterpreterclasse. Utilizzando l'oggetto di questa classe, qualsiasi script Python può essere eseguito utilizzando ilexecfile()metodo. PythonInterpreter ti consente di utilizzarePyObjectsdirettamente. Tutti gli oggetti noti al sistema runtime Jython sono rappresentati da un'istanza della classe PyObject o da una delle sue sottoclassi.

La classe PythonInterpreter ha alcuni metodi usati regolarmente, che sono spiegati nella tabella riportata di seguito.

Sr.No. Metodo e descrizione
1

setIn(PyObject)

Imposta l'oggetto Python da utilizzare per il flusso di input standard
2

setIn(java.io.Reader)

Imposta un java.io.Reader da utilizzare per il flusso di input standard
3

setIn(java.io.InputStream)

Imposta un java.io.InputStream da utilizzare per il flusso di input standard
4

setOut(PyObject)

Imposta l'oggetto Python da utilizzare per il flusso di output standard
5

setOut(java.io.Writer)

Impostare java.io.Writer da utilizzare per il flusso di output standard
6

setOut(java,io.OutputStream)

Impostare java.io.OutputStream da utilizzare per il flusso di output standard
7

setErr(PyObject)

Imposta un oggetto di errore Python da utilizzare per il flusso di errore standard
8

setErr(java.io.Writer

Imposta un java.io.Writer da utilizzare per il flusso di errore standard
9

setErr(java.io.OutputStream)

Impostare un java.io.OutputStream da utilizzare per il flusso di errore standard
10

eval(String)

Valuta una stringa come sorgente Python e restituisci il risultato
11

eval(PyObject)

Valuta un oggetto codice Python e restituisci il risultato
12

exec(String)

Esegui una stringa sorgente Python nello spazio dei nomi locale
13

exec(PyObject)

Esegui un oggetto codice Python nello spazio dei nomi locale
14

execfile(String filename)

Esegui un file di origine Python nello spazio dei nomi locale
15

execfile(java.io.InputStream)

Esegui un flusso di input dell'origine Python nello spazio dei nomi locale
16

compile(String)

Compila una stringa sorgente Python come espressione o modulo
17

compile(script, filename)

Compila uno script del sorgente Python come espressione o modulo
18

set(String name, Object value)

Imposta una variabile di tipo Object nello spazio dei nomi locale
19

set(String name, PyObject value)

Imposta una variabile di tipo PyObject nello spazio dei nomi locale
20

get(String)

Ottieni il valore di una variabile nello spazio dei nomi locale
21

get(String name, Class javaclass

Ottieni il valore di una variabile nello spazio dei nomi locale. Il valore verrà restituito come istanza della classe Java specificata.

Il seguente blocco di codice è un programma Java con uno script Jython incorporato “hello.py”.usingexecfile()metodo dell'oggetto PythonInterpreter. Mostra anche come una variabile Python può essere impostata o letta usando i metodi set () e 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 ");
   }
}

Compilare ed eseguire il programma Java sopra per ottenere il seguente output.

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

PyDev è un plugin open source per Eclipse IDE per consentire lo sviluppo di progetti in Python, Jython e IronPython. È ospitato inhttps://pydev.org. Di seguito viene fornita una procedura dettagliata per installare il plug-in PyDev in Eclipse IDE.

Step 1 - Apri Eclipse IDE e scegli il file Install New Software opzione dal menu Guida.

Step 2 - Entra http://pydev.org/updatesnella casella di testo davanti a lavora con l'etichetta e fai clic su aggiungi. Scegli tutte le voci disponibili nell'elenco e fai clic su Avanti. La procedura guidata impiegherà alcuni minuti per completare l'installazione e richiederà il riavvio dell'IDE.

Step 3- Ora scegli l'opzione delle preferenze dal menu Finestra. La finestra di dialogo Preferenze si aprirà come mostrato di seguito.

Step 4- Espandi il nodo Interpreters e seleziona Jython Interpreter nel riquadro di sinistra. Nel riquadro di destra, fare clic su nuovo per dare il percorso al filejython.jar file.

Ora siamo pronti per avviare un progetto Jython utilizzando Eclipse.

Per realizzare un progetto in Eclipse, dovremmo seguire i passaggi indicati di seguito.

Step 1- Scegli file? Nuovo? Progetto. SceglierePyDevdalla finestra di dialogo del filtro. Dare il nome del progetto, il tipo di progetto e fare clic su Fine.

Step 2- Hello project apparirà ora nel project explorer a sinistra. Fai clic con il tasto destro per aggiungere hello.py al suo interno.

Step 3- Un hello.py vuoto apparirà nell'editor. Scrivi il codice Jython e salva.

Step 4- Fare clic sul pulsante Esegui nella barra dei menu. L'output apparirà nella finestra della console come mostrato di seguito.

Il supporto Python e Jython per NetBeans è disponibile tramite il nbPython plugin. Scarica il plug-in dal seguente URL -http://plugins.netbeans.org/plugin/56795. Decomprimere l'archivio scaricato in una cartella. Per esempio -d:\nbplugin. To install the NetBeans Plugin, let us follow the steps given below.

Step 1 − Start the Netbeans IDE and then go to Tools/Plugin to open the Plugin Manager. Choose ‘Downloaded’ tab and browse to the folder in which the downloaded file has been unzipped. The NetBeans window will appear as shown below.

Step 2 − The next step is to select all the .nbm files and click open.

Step 3 − Click on the Install button.

Step 4 − Accept the following license agreement to continue.

Ignore the warning about untrusted source of plugins and restart the IDE to proceed.

Jython Project in NetBeans

Once restarted, start a new project by choosing File/New. Python category will now be available in the categories list. Choose it to proceed.

If the system has Python installed, its version/versions will be automatically detected and shown in the Python platform dropdown list. However, Jython will not be listed. Click on the Manage button to add it.

Click on the ‘New’ button to add a platform name and path to Jython executable.

Jython will now be available in the platform list. Select from the dropdown list as shown in the following screenshot.

We can now fill in the project name, location and main file in the next window.

The project structure will appear in the projects window of the NetBeans IDE and a template Python code in the editor window.

Build and execute the Jython project to obtain the following result in the output window of the NetBeans IDE.

A Java servlet is the most widely used web development technique. We can use Jython to write servlets and this adds many more advantages beyond what Java has to offer because now we can make use of the Python language features as well.

We shall use the NetBeans IDE to develop a Java web application with a Jython servlet. Ensure that the nbPython plugin is installed in the NetBeans installation. Start a new project to build a web application by choosing the following path - File → New Project → Java web → New Web Application.

Provide the Project name and location. The IDE will create the project folder structure. Add a Java servlet file (ServletTest.java) under the source packages node in the Projects window. This will add servlet-api.jar in the lib folder of the project. Also, let the IDE create the web.xml descriptor file. Add the following code in ServletTest.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>"
      );
   }
}

The web.xml file created by NetBeans will be as shown below −

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

Build and run the project to obtain the text Servlet Test appearing in <h1> tag in the browser window. Thus, we have added a regular Java servlet in the application.

Now, we shall add the Jython Servlet. Jython servlets work by means of an intermediate Java servlet is also known as PyServlet. The PyServlet.class is present in the jython standalone.jar. Add it in the WEB-INF/lib folder.

The next step is to configure the web.xml to invoke the PyServlet, whenever a request for any *.py file is raised. This should be done by adding the following xml code in it.

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

The full web.xml code will look as shown below.

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

Place the following Jython code in the WEB-INF folder inside the project folder as JythonServlet.py, which is equivalent to the previous 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>"
      )

Build the project and in the browser open the following URL −

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

The browser will show the Servlet Test in <h1> tag as in case of Java Servlet output.

Jython uses the zxJDBC package that provides an easy-to-use Python wrapper around JDBC. zxJDBC bridges two standards: JDBC is the standard platform for database access in Java, and DBI is the standard database API for Python apps.

ZxJDBC provides a DBI 2.0 standard compliant interface to JDBC. Over 200 drivers are available for JDBC and they all work with zxJDBC. High performance drivers are available for all major relational databases, including −

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

The ZxJDBC package can be downloaded from https://sourceforge.net/projects/zxjdbc/ or http://www.ziclix.com/zxjdbc/. The downloaded archive contains the ZxJDBC.jar, which should be added to the CLASSPATH environment variable.

We intend to establish database connectivity with MySQL database. For this purpose, the JDBC driver for MySQL is required. Download the MySQL J connector from the following link - https://dev.mysql.com/downloads/connector/j/ and include the mysql connector java-5.1.42-bin.jar in the CLASSPATH.

Login to the MySQL server and create a student table in the test database with the following structure −

Field Type Width
Name Varchar 10
Age Int 3
Marks Int 3

Add a few records in it.

Name Age Marks
Ravi 21 78
Ashok 20 65
Anil 22 71

Create the following Jython script as 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

Execute the above script from the Jython prompt. Records in the student table will be listed as shown below −

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

This explains the procedure of establishing JDBC in Jython.

One of the major features of Jython is its ability to use the Swing GUI library in JDK. The Standard Python distribution (often called as CPython) has the Tkinter GUI library shipped with it. Other GUI libraries like PyQt and WxPython are also available for use with it, but the swing library offers a platform independent GUI toolkit.

Using the swing library in Jython is much easier compared to using it in Java. In Java the anonymous classes have to be used to create event binding. In Jython, we can simply pass a function for the same purpose.

The basic top-level window is created by declaring an object of the JFrame class and set its visible property to true. For that, the Jframe class needs to be imported from the swing package.

from javax.swing import JFrame

The JFrame class has multiple constructors with varying number of arguments. We shall use the one, which takes a string as argument and sets it as the title.

frame = JFrame(“Hello”)

Set the frame’s size and location properties before setting its visible property to true. Store the following code as frame.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)

Run the above script from the command prompt. It will display the following output showing a window.

The swing GUI library is provided in the form of javax.swing package in Java. Its main container classes, JFrame and JDialog are respectively derived from Frame and Dialog classes, which are in the AWT library. Other GUI controls like JLabel, JButton, JTextField, etc., are derived from the JComponent class.

The following illustration shows the Swing Package Class hierarchy.

The following table summarizes different GUI control classes in a swing library −

Sr.No. Class & Description
1

JLabel

A JLabel object is a component for placing text in a container.
2

JButton

This class creates a labeled button.
3

JColorChooser

A JColorChooser provides a pane of controls designed to allow a user to manipulate and select a color.
4

JCheckBox

A JCheckBox is a graphical component that can be in either an on (true) or off (false) state.
5

JRadioButton

The JRadioButton class is a graphical component that can be either in an on (true) or off (false) state. in a group.
6

JList

A JList component presents the user with a scrolling list of text items.
7

JComboBox

A JComboBox component presents the user with drop down list of items
8

JTextField

A JTextField object is a text component that allows for the editing of a single line of text.
9

JPasswordField

A JPasswordField object is a text component specialized for password entry.
10

JTextArea

A JTextArea object is a text component that allows editing of a multiple lines of text.
11

ImageIcon

A ImageIcon control is an implementation of the Icon interface that paints Icons from Images
12

JScrollbar

A Scrollbar control represents a scroll bar component in order to enable the user to select from range of values.
13

JOptionPane

JOptionPane provides set of standard dialog boxes that prompt users for a value or informs them of something.
14

JFileChooser

A JFileChooser control represents a dialog window from which the user can select a file.
15

JProgressBar

As the task progresses towards completion, the progress bar displays the task's percentage of completion.
16

JSlider

A JSlider lets the user graphically select a value by sliding a knob within a bounded interval.
17

JSpinner

A JSpinner is a single line input field that lets the user select a number or an object value from an ordered sequence.

We would be using some of these controls in subsequent examples.

Layout managers in Java are classes those, which manage the placement of controls in the container objects like Frame, Dialog or Panel. Layout managers maintain the relative positioning of controls in a frame, even if the resolution changes or the frame itself is resized.

These classes implement the Layout interface. The following Layout managers are defined in the AWT library −

  • BorderLayout
  • FlowLayout
  • GridLayout
  • CardLayout
  • GridBagLayout

The following Layout Managers are defined in the Swing library −

  • BoxLayout
  • GroupLayout
  • ScrollPaneLayout
  • SpringLayout

We shall use AWT layout managers as well as swing layout managers in the following examples.

  • Absolute Layout
  • Flow Layout
  • Grid Layout
  • Border Layout
  • Box Layout
  • Group Layout

Let us now discuss each of these in detail.

Absolute Layout

Before we explore all the above Layout managers, we must look at absolute positioning of the controls in a container. We have to set the layout method of the frame object to ‘None’.

frame.setLayout(None)

Then place the control by calling the setBounds() method. It takes four arguments - x position, y position, width and height.

For example - To place a button object at the absolute position and with the absolute size.

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

Similarly, all controls can be placed by properly allocating position and size. This layout is relatively easy to use, but fails to retain its appearance when the window either is resized, or if the program is executed when screen resolution changes.

In the following Jython script, three Jlabel objects are used to display text “phy”, “maths” and “Total” respectively. In front of these three - JTextField objects are placed. A Button object is placed above the “Total” label.

First of all the JFrame window is created with a layout set to none.

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

Quindi vengono aggiunti diversi controlli in base alla loro posizione e dimensione assoluta. Il codice completo è dato di seguito -

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)

L'output per il codice precedente è il seguente.

Jython FlowLayout

FlowLayout è il gestore layout predefinito per le classi contenitore. Organizza il controllo da sinistra a destra e quindi dall'alto verso il basso.

Nel seguente esempio, un oggetto Jlabel, un oggetto JTextField e un oggetto JButton devono essere visualizzati in un JFrame utilizzando FlowLayout manager. Per cominciare, importiamo le classi richieste dal filejavax.swing pacchetto e il java.awt pacchetto.

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

Quindi crea un oggetto JFrame e imposta la sua posizione e le proprietà della dimensione.

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

Ora dichiara gli oggetti per le classi JLabel, JTextfield e JButton.

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

Infine aggiungi questi controlli nel frame chiamando il file add() metodo della classe JFrame.

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

Per visualizzare il frame, impostare la sua proprietà visible su true. Lo script Jython completo e il suo output sono i seguenti:

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

Il gestore Gridlayout consente il posizionamento dei controlli in una griglia rettangolare. Un controllo viene inserito in ogni cella della griglia.

Nell'esempio seguente, GridLayout viene applicato a un oggetto JFrame dividendolo in 4 righe e 4 colonne. Un oggetto JButton deve essere posizionato in ogni cella della griglia.

Per prima cosa importiamo le librerie richieste -

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

Quindi crea il contenitore JFrame -

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

Ora applica GridLayout specificando le sue dimensioni come 4 per 4.

frame.setLayout(GridLayout(4,4))

Ora dovremmo usare due cicli FOR, ciascuno da 1 a 4, quindi sedici oggetti JButton vengono inseriti nelle celle successive.

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

Infine imposta la visibilità del frame su true. Il codice Jython completo è fornito di seguito.

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)

L'output del codice sopra è il seguente:

Jython BorderLayout

Il gestore BorderLayout divide il contenitore in cinque aree geografiche e luoghi con un componente in ciascuna regione. Queste regioni sono rappresentate da costanti definite come segue:

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

Consideriamo il seguente esempio:

Jython BoxLayout

La classe BoxLayout è definita nel file javax.swing package. Viene utilizzato per disporre i componenti nel contenitore verticalmente o orizzontalmente. La direzione è determinata dalle seguenti costanti:

  • X_AXIS
  • Y_AXIS
  • LINE_AXIS
  • PAGE_AXIS

La costante intera specifica l'asse lungo il quale devono essere disposti i componenti del contenitore. Quando il contenitore ha l'orientamento predefinito dei componenti, LINE_AXIS specifica che i componenti devono essere disposti da sinistra a destra e PAGE_AXIS specifica che i componenti devono essere disposti dall'alto verso il basso.

Nell'esempio seguente, pannello (della classe JPanel) viene aggiunto in un oggetto JFrame. Viene applicato il BoxLayout verticale e vengono aggiunti altri due pannelli, superiore e inferiore. Questi due pannelli interni hanno due pulsanti aggiunti ciascuno nel Boxlayout orizzontale.

Creiamo prima la finestra JFrame di primo livello.

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

L'oggetto JPanel è dichiarato con un BoxLayout verticale. Aggiungilo nella cornice di primo livello.

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

In questo pannello, vengono aggiunti altri due pannelli superiore e inferiore. Ognuno di essi ha due oggetti JButton aggiunti orizzontalmente con uno spazio di 25 pixel che li separa.

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

Allo stesso modo, viene costruito il pannello inferiore.

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

Nota che il file createRigidArea()viene utilizzata per creare uno spazio di 25 pixel tra due pulsanti. Anche ilcreateVerticalGlue() la funzione occupa lo spazio iniziale o finale nel layout.

Per cominciare, aggiungi i pannelli superiore e inferiore e imposta la proprietà di visibilità del frame su true. Il codice completo è il seguente:

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)

Il codice precedente genererà il seguente output.

Jython GroupLayout

Il manager GroupLayout raggruppa i componenti in modo gerarchico. Il raggruppamento è fatto da due classi,SequentialGroup e ParallelGroup, entrambi implementano l'interfaccia di gruppo in Java.

La procedura di layout è divisa in due fasi. In una fase, i componenti vengono posizionati lungo l'asse orizzontale e nella seconda lungo l'asse verticale. Ogni componente deve essere definito due volte nel layout.

Esistono due tipi di arrangiamenti, sequenziali e paralleli. In entrambi possiamo disporre i componenti in sequenza o in parallelo. Nella disposizione orizzontale, la riga è chiamata gruppo sequenziale e la colonna è chiamata gruppo parallelo. D'altra parte, in disposizione parallela, la riga dell'elemento è un gruppo parallelo e una colonna, che è chiamata sequenziale.

Nell'esempio seguente, cinque pulsanti sono disposti in modo tale che tre appaiano ciascuno in riga e colonna. Per cominciare, aggiungi un oggetto Jpanel in una finestra JFrame e imposta il suo layout come Grouplayout.

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

Quindi costruisci gli oggetti JButton -

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

Successivamente, creiamo un file SequentialGroup di nome LeftToRighta cui vengono aggiunti buttonD e buttonY. Tra di loro, viene posizionato un ParallelGroup ColumnMiddle (con altri tre pulsanti aggiunti verticalmente).

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

Ora arriva la definizione di SequentialGroup verticale chiamato TopToBottom. Aggiungere una riga ParallelGroup di tre pulsanti e quindi posizionare due pulsanti verticalmente.

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

Infine, imposta il gruppo LeftToRight orizzontalmente e il gruppo TopToBottom verticalmente sull'oggetto formato. Il codice completo è dato di seguito -

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)

L'output del codice sopra è il seguente:

La gestione degli eventi in Java swing richiede che il controllo (come JButton o JList ecc.) Venga registrato con il rispettivo listener di eventi. L'interfaccia del listener di eventi o la classe Adapter corrispondente deve essere implementata o sottoclasse con il relativo metodo di gestione degli eventi sovrascritto. In Jython, la gestione degli eventi è molto semplice. Possiamo passare qualsiasi funzione come proprietà della funzione di gestione degli eventi corrispondente al controllo.

Vediamo prima come viene gestito un evento clic in Java.

Per cominciare, dobbiamo importare il file java.awt.event package. Successivamente, la classe che estende JFrame deve implementare l'interfaccia ActionListener.

public class btnclick extends JFrame implements ActionListener

Quindi, dobbiamo dichiarare l'oggetto JButton, aggiungerlo al ContentPane del frame e quindi registrarlo con ActionListener tramite il metodo addActionListener ().

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

Ora, il metodo actionPerformed () dell'interfaccia ActionListener deve essere sovrascritto per gestire ActionEvent.

Di seguito è riportato l'intero codice 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);
   }
}

Ora scriveremo il codice Jython equivalente allo stesso codice.

Per cominciare, non abbiamo bisogno di importare ActionEvent o ActionListener, poiché la digitazione dinamica di Jython ci consente di evitare di menzionare queste classi nel nostro codice.

In secondo luogo, non è necessario implementare o creare una sottoclasse di ActionListener. Al contrario, qualsiasi funzione definita dall'utente viene immediatamente fornita al costruttore JButton come valore diactionPerformed proprietà del fagiolo.

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

Il clickhere() è definita come una normale funzione Jython, che gestisce l'evento clic sul pulsante.

def change_text(event):
print clicked!'

Ecco il codice equivalente a 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)

L'output del codice Java e Jython è identico. Quando si fa clic sul pulsante, verrà stampato il messaggio "cliccato" sulla console.

Nel seguente codice Jython, due oggetti JTextField sono forniti nella finestra JFrame per inserire i contrassegni in "phy" e "maths". L'oggetto JButton esegue la funzione add () quando viene cliccato.

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

La funzione add () legge il contenuto di due campi di testo con il metodo getText () e li analizza in numeri interi, in modo che sia possibile eseguire l'addizione. Il risultato viene quindi inserito nel terzo campo di testo dal metodo setText ().

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

Il codice completo è dato di seguito -

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)

Quando il codice precedente viene eseguito dal prompt dei comandi, viene visualizzata la seguente finestra. Immettere i segni per "Phy", Maths "e fare clic sul pulsante" Aggiungi ". Il risultato verrà visualizzato di conseguenza.

Evento Jython JRadioButton

La classe JRadioButton è definita nel file javax.swing package. Crea un pulsante di attivazione / disattivazione selezionabile con stati di attivazione o disattivazione. Se più pulsanti di opzione vengono aggiunti in un ButtonGroup, la loro selezione si esclude a vicenda.

Nell'esempio seguente, due oggetti della classe JRadioButton e due JLabel vengono aggiunti a un contenitore Jpanel in un BoxLayout verticale. Nel costruttore degli oggetti JRadioButton, ilOnCheck()function è impostata come valore della proprietà actionPerformed. Questa funzione viene eseguita quando si fa clic sul pulsante di opzione per modificarne lo stato.

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

Nota che lo stato predefinito del pulsante di opzione è falso (non selezionato). Il pulsante rb1 viene creato con lo stato iniziale True (selezionato).

I due pulsanti di opzione vengono aggiunti a un ButtonGroup di opzione per renderli mutuamente esclusivi, in modo che se uno è selezionato, l'altro viene deselezionato automaticamente.

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

Questi due pulsanti di opzione insieme a due etichette vengono aggiunti a un oggetto pannello nel layout verticale con un'area di separazione di 25 pixel di altezza compresa tra rb2 e 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)

Questo pannello viene aggiunto a un oggetto JFrame di primo livello, la cui proprietà visible è impostata su "True" alla fine.

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)

Esegui lo script Jython sopra e cambia la selezione del pulsante di opzione. La selezione apparirà nell'etichetta in basso.

Evento Jython JCheckBox

Come il JRadioButton, L'oggetto JCheckBox è anche un pulsante selezionabile con una casella rettangolare selezionabile oltre alla sua didascalia. Viene generalmente utilizzato per fornire all'utente l'opportunità di selezionare più opzioni dall'elenco di elementi.

Nell'esempio seguente, due caselle di controllo e un'etichetta dal pacchetto swing vengono aggiunte a un JPanel in BoxLayout verticale. L'etichetta in basso mostra lo stato di selezione istantanea di due caselle di controllo.

Entrambe le caselle di controllo vengono dichiarate con il costruttore con la proprietà actionPerformed impostata su OnCheck() funzione.

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

La funzione OnCheck () verifica lo stato di selezione di ciascuna casella di controllo e visualizza il messaggio corrispondente sull'etichetta in basso.

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"

Queste caselle e un oggetto JLabel vengono aggiunti a un JPanel con un segnaposto di 50 pixel di altezza aggiunto tra di loro.

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)

Il pannello stesso viene aggiunto a una finestra JFrame di primo livello, la cui proprietà visible è impostata su true alla fine.

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

frame.setVisible(True)

Esegui il codice sopra e sperimenta con la selezione delle caselle di controllo. Lo stato istantaneo di entrambe le caselle di controllo viene visualizzato in basso.

Evento Jython JList

Il controllo JList nel pacchetto swing fornisce all'utente un elenco scorrevole di elementi tra cui scegliere. JComboBox fornisce un elenco a discesa di elementi. In Java, l'evento di selezione viene elaborato implementando il metodo valueChanged () in ListSelectionListener. In Jython, un gestore di eventi viene assegnato alla proprietà valueChanged dell'oggetto JList.

Nell'esempio seguente, un oggetto JList e un'etichetta vengono aggiunti a un JFrame in BorderLayout. Il JList viene popolato con una raccolta di elementi in una tupla. La sua proprietà valueChanged è impostata sulla funzione listSelect ().

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

La funzione del gestore eventi ottiene l'indice dell'elemento selezionato e preleva l'elemento corrispondente dall'oggetto JList da visualizzare sull'etichetta in basso.

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

Gli oggetti JList e JLabel vengono aggiunti a JFrame utilizzando BorderLayout.

L'intero codice è dato di seguito -

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)

L'output del codice seguente è il seguente.

La maggior parte delle applicazioni basate su GUI hanno una barra dei menu in alto. Si trova appena sotto la barra del titolo della finestra di primo livello. Il pacchetto javax.swing ha una struttura elaborata per costruire un efficiente sistema di menu. È costruito con l'aiuto diJMenuBar, JMenu e JMenuItem classi.

Nell'esempio seguente, viene fornita una barra dei menu nella finestra di primo livello. Alla barra dei menu viene aggiunto un menu File composto da tre pulsanti di voci di menu. Prepariamo ora un oggetto JFrame con il layout impostato su BorderLayout.

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

Ora, un oggetto JMenuBar viene attivato dal metodo SetJMenuBar ().

bar = JMenuBar()
frame.setJMenuBar(bar)

Successivamente, viene dichiarato un oggetto JMenu con didascalia "File". Tre pulsanti JMenuItem vengono aggiunti al menu File. Quando si fa clic su una delle voci di menu, viene eseguita la funzione OnClick () del gestore ActionEvent. È definito con la proprietà 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)

Il gestore di eventi OnClick () recupera il nome del pulsante JMenuItem dalla funzione gwtActionCommand () e lo visualizza nella casella di testo nella parte inferiore della finestra.

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

L'oggetto menu File viene aggiunto alla barra dei menu. Infine, un controllo JTextField viene aggiunto nella parte inferiore dell'oggetto JFrame.

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

L'intero codice di menu.py è riportato di seguito:

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)

Quando lo script precedente viene eseguito utilizzando l'interprete Jython, viene visualizzata una finestra con il menu File. Fare clic su di esso e le sue tre voci di menu verranno visualizzate. Se si fa clic su qualsiasi pulsante, il suo nome verrà visualizzato nel controllo della casella di testo.

Un oggetto Dialog è una finestra che appare sopra la finestra di base con la quale l'utente interagisce. In questo capitolo vedremo le finestre di dialogo preconfigurate definite nella libreria swing. Loro sonoMessageDialog, ConfirmDialog e InputDialog. Sono disponibili grazie al metodo statico della classe JOptionPane.

Nell'esempio seguente, il menu File ha tre voci JMenu corrispondenti alle tre finestre di dialogo precedenti; ognuno esegue il fileOnClick gestore di eventi.

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

La funzione del gestore OnClick () recupera la didascalia del pulsante della voce di menu e richiama il rispettivo metodo 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")

Se viene scelta l'opzione messaggio dal menu, viene visualizzato un messaggio. Se si fa clic sull'opzione di input, viene visualizzata una finestra di dialogo che richiede l'input. Il testo di input viene quindi visualizzato nella casella di testo nella finestra JFrame. Se è selezionata l'opzione Conferma, viene visualizzata una finestra di dialogo con tre pulsanti, SI, NO e ANNULLA. La scelta dell'utente viene registrata nella casella di testo.

L'intero codice è dato di seguito -

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)

Quando viene eseguito lo script precedente, viene visualizzata la seguente finestra con tre opzioni nel menu:

Casella dei messaggi

Casella di input

Conferma la finestra di dialogo

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