Jython - Guia rápido

Jython é a implementação JVM da linguagem de programação Python. Ele foi projetado para ser executado na plataforma Java. Um programa Jython pode importar e usar qualquer classe Java. Assim como Java, o programa Jython compila parabytecode. Uma das principais vantagens é que uma interface de usuário projetada em Python pode usar elementos GUI deAWT, Swing ou SWT Package.

Jython, que começou como JPython e mais tarde foi renomeado, segue de perto a implementação padrão do Python chamada CPython como criado por Guido Van Rossum. Jython foi criado em 1997 porJim Hugunin. O Jython 2.0 foi lançado em 1999. Desde então, os lançamentos do Jython 2.x correspondem aos lançamentos CPython equivalentes. Jython 2.7.0 lançado em maio de 2015, corresponde ao CPython 2.7. O desenvolvimento do Jython 3.x está em andamento.

Diferença entre Python e Java

A seguir estão as diferenças entre Python e Java -

  • Python é uma linguagem tipada dinamicamente. Portanto, a declaração de tipo da variável não é necessária. Java, por outro lado, é uma linguagem de tipo estático, o que significa que a declaração do tipo da variável é obrigatória e não pode ser alterada.

  • Python tem apenas exceções não verificadas, enquanto Java tem exceções verificadas e não verificadas.

  • Python usa recuos para escopo, enquanto Java usa chaves correspondentes.

  • Como Python é uma linguagem baseada em interpretador, ela não possui etapas de compilação separadas. Um programa Java, entretanto, precisa ser compilado para bytecode e, por sua vez, executado por uma JVM.

  • Python suporta herança múltipla, mas em Java, herança múltipla não é possível. No entanto, possui implementação de uma interface.

  • Comparado ao Java, Python tem estruturas de dados integradas mais ricas (listas, dicts, tuplas, tudo é um objeto).

Diferença entre Python e Jython

A seguir estão as diferenças entre Python e Jython -

  • A implementação de referência do Python, chamada CPython, é escrita em linguagem C. Jython, por outro lado, é totalmente escrito em Java e é uma implementação JVM.

  • O Python padrão está disponível em várias plataformas. Jython está disponível para qualquer plataforma com um JVM instalado.

  • O código Python padrão é compilado para um .pyc arquivo, enquanto o programa Jython compila para um .class Arquivo.

  • As extensões Python podem ser escritas em linguagem C. Extensões para Jython são escritas em Java.

  • Jython é verdadeiramente multi-threaded por natureza. Python, entretanto, usa oGlobal Interpreter Lock (GIL) para o efeito.

  • Ambas as implementações têm mecanismos de coleta de lixo diferentes.

No próximo capítulo, aprenderemos como importar as bibliotecas Java em Jython.

Antes da instalação do Jython 2.7, certifique-se de que o sistema tenha JDK 7ou mais instalado. Jython está disponível na forma de um arquivo jar executável. Baixe-o de -http://www.jython.org/downloads.html e clique duas vezes em seu ícone ou execute o seguinte comando -

java -jar jython_installer-2.7.0.jar

Um assistente de instalação começará com o qual as opções de instalação devem ser fornecidas. Aqui está o procedimento sistemático de instalação.

A primeira etapa do assistente pede que você selecione o idioma.

A segunda etapa solicita que você aceite o contrato de licença.

Na próxima etapa, escolha o tipo de instalação. Recomenda-se escolher a instalação padrão.

A próxima tela pede sua confirmação sobre suas opções e prossegue para completar a instalação.

O procedimento de instalação pode levar algum tempo para ser concluído.

Após a conclusão da instalação, invoque jython.exedo diretório bin dentro do diretório de destino. Supondo que o Jython esteja instalado emC:\jython27, execute o seguinte na linha de comando.

C:\jython27\bin\jython

Um prompt Python (>>>) aparecerá, na frente do qual qualquer instrução Python ou script Python pode ser executado.

Um dos recursos mais importantes do Jython é sua capacidade de importar classes Java em um programa Python. Podemos importar qualquer pacote ou classe java em Jython, assim como fazemos em um programa Java. O exemplo a seguir mostra como ojava.util os pacotes são importados no script Python (Jython) para declarar um objeto da classe Date.

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

Salve e execute o código acima como UtilDate.pyda linha de comando. A instância da data e hora atual será exibida.

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

Os seguintes pacotes da biblioteca Java são importados com mais frequência em um programa Jython, principalmente porque a biblioteca Python padrão não tem seus equivalentes ou não são tão bons.

  • Servlets
  • JMS
  • J2EE
  • Javadoc
  • O Swing é considerado superior a outros kits de ferramentas GUI

Qualquer pacote Java para esse assunto pode ser importado em um script Jython. Aqui, o seguinte programa java é armazenado e compilado em um pacote chamadofoo.

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

este HelloWorld.classé importado no seguinte script Jython. Os métodos nesta classe podem ser chamados a partir do script Jythonimportex.py.

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

Salve e execute o script acima a partir da linha de comando para obter a seguinte saída.

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

Variáveis ​​são localizações nomeadas na memória do computador. Cada variável pode conter um dado nela. Ao contrário do Java, Python é uma linguagem tipada dinamicamente. Portanto, ao usar Jython também; declaração prévia do tipo de dados da variável não é feita. Em vez do tipo de variável que decide quais dados podem ser armazenados nela, os dados decidem o tipo de variável.

No exemplo a seguir, uma variável é atribuída a um valor inteiro. Usando a função interna type (), podemos verificar se o tipo de variável é um inteiro. Mas, se a mesma variável for atribuída a uma string, a função type () irá string como o tipo da mesma variável.

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

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

Isso explica por que o Python é chamado de linguagem de tipo dinâmico.

Os seguintes tipos de dados integrados Python também podem ser usados ​​em Jython -

  • Number
  • String
  • List
  • Tuple
  • Dictionary

Python reconhece dados numéricos como um número, que pode ser um inteiro, um número real com ponto flutuante ou um número complexo. Os tipos de dados String, List e Tuple são chamados de sequências.

Números Jython

Em Python, qualquer número inteiro assinado é considerado do tipo 'int'. Para expressar um inteiro longo, a letra 'L' é anexada a ele. Um número com um ponto decimal separando a parte inteira de um componente fracionário é chamado de 'float'. A parte fracionária pode conter um expoente expresso na notação científica usando 'E' ou 'e'.

Um número complexo também é definido como tipo de dados numéricos em Python. Um número complexo contém uma parte real (um número de ponto flutuante) e uma parte imaginária com 'j' anexado a ele.

Para expressar um número na representação Octal ou Hexadecimal, 0O ou 0Xé prefixado a ele. O bloco de código a seguir fornece exemplos de diferentes representações de números em 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

Strings Jython

Uma string é qualquer sequência de caracteres colocados entre aspas simples (por exemplo, 'hello'), duplas (por exemplo, “hello”) ou triplas (por exemplo, '“hello'” o ““ “hello” ””). As aspas triplas são especialmente úteis se o conteúdo da string se estender por várias linhas.

Os caracteres da sequência de Escape podem ser incluídos literalmente na string entre aspas triplas. Os exemplos a seguir mostram maneiras diferentes de declarar uma string em 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.
"""

A terceira string, quando impressa, dará a seguinte saída.

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.

Listas Jython

Uma lista é um tipo de dados de sequência. É uma coleção de itens separados por vírgulas, não necessariamente do mesmo tipo, armazenados entre colchetes. O item individual da lista pode ser acessado usando o índice baseado em zero.

O bloco de código a seguir resume o uso de uma lista em 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]

A tabela a seguir descreve algumas das Expressões Jython mais comuns relacionadas às Listas Jython.

Expressão Jython Descrição
len (lista) comprimento
Lista [2] = 10 Atualização
Del List [1] Eliminação
List.append (20) Acrescentar
List.insert (1,15) Inserção
List.sort () Ordenação

Tuplas Jython

Uma tupla é uma coleção imutável de itens de dados separados por vírgulas armazenados entre parênteses. Não é possível excluir ou modificar um elemento na tupla, nem é possível adicionar um elemento à coleção de tupla. O bloco de código a seguir mostra as operações de 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]

Dicionário Jython

O Jython Dictionary é semelhante à classe Map na estrutura Java Collection. É uma coleção de pares de valores-chave. Pares separados por vírgula são colocados entre colchetes. Um objeto Dicionário não segue um índice baseado em zero para recuperar os elementos dentro dele, pois eles são armazenados pela técnica de hash.

A mesma chave não pode aparecer mais de uma vez em um objeto de dicionário. No entanto, mais de uma chave pode ter os mesmos valores associados. Diferentes funções disponíveis com o objeto Dicionário são explicadas abaixo -

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

A tabela a seguir descreve algumas das expressões Jython mais comuns relacionadas ao Dicionário.

Expressão Jython Descrição
dict.get ('011') Pesquisa
len (dict) comprimento
dict ['044'] = 'Chennai' Acrescentar
del dict ['022'] Excluir
dict.keys () lista de chaves
dict.values ​​() Lista de valores
dict.clear () Remove todos os elementos

Além dos tipos de dados integrados do Python, Jython tem o benefício de usar classes de coleção Java importando o java.util package. O código a seguir descreve as classes fornecidas abaixo -

  • Objeto Java ArrayList com add ()
  • remove()
  • métodos get () e set () da 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

O script Jython acima produz a seguinte saída -

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

Jarray Class

Jython também implementa o Jarray Object, que permite a construção de um array Java em Python. Para trabalhar com um jarray, basta definir um tipo de sequência em Jython e passá-lo para o jarrayobject junto com o tipo de objeto contido na sequência. Todos os valores em um jarray devem ser do mesmo tipo.

A tabela a seguir mostra os códigos de tipo de caractere usados ​​com um jarray.

Character Typecode Tipo Java Correspondente
Z boleano
C Caracteres
B byte
H baixo
Eu int
eu grandes
F flutuador
D em dobro

O exemplo a seguir mostra a construção de jarray.

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

Aqui my_seqé definido como uma tupla de inteiros. Ele é convertido em Jarray arr1. O segundo exemplo mostra que Jarray arr2 é construído a partir demySttr stringseqüência. A saída do script acimajarray.py é o seguinte -

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

As estruturas de tomada de decisão têm uma ou mais condições a serem avaliadas ou testadas pelo programa, juntamente com uma declaração ou declarações que devem ser executadas, se a condição for determinada como verdadeira, e, opcionalmente, outras declarações a serem executadas, se a condição está determinado a ser falso.

A ilustração a seguir mostra a forma geral de uma estrutura típica de tomada de decisão encontrada na maioria das linguagens de programação -

Jython não usa chaves para indicar blocos de instruções a serem executados quando a condição é verdadeira ou falsa (como é o caso em Java). Em vez disso, o recuo uniforme (espaço em branco da margem esquerda) é usado para formar o bloco de instruções. Tal bloco uniformemente indentado faz com que o código condicional seja executado quando uma condição fornecida na instrução 'if' for verdadeira.

Um bloco semelhante pode estar presente após uma instrução opcional 'else'. Jython também fornece oelif statementusando quais condições sucessivas podem ser testadas. Aqui oelse clauseaparecerá por último e será executado apenas quando todas as condições anteriores falharem. A sintaxe geral de usoif..elif..else é o seguinte.

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

No exemplo a seguir, se ..elif ..else A construção é usada para calcular o desconto em diferentes valores da quantidade inserida pelo usuário.

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

A saída do código acima será conforme mostrado abaixo.

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

Em geral, as instruções em um programa são executadas sequencialmente: a primeira instrução em uma função é executada primeiro, seguida pela segunda e assim por diante. Pode haver uma situação em que você precise executar um bloco de código várias vezes. As declarações que fornecem tal capacidade de repetição são chamadaslooping statements.

Em Jython, um loop pode ser formado por duas instruções, que são -

  • o while declaração e

  • o for declaração

O loop WHILE

Uma instrução de loop while em Jython é semelhante àquela em Java. Ele executa repetidamente um bloco de instruções, desde que uma determinada condição seja verdadeira. O fluxograma a seguir descreve o comportamento de umwhile ciclo.

A sintaxe geral da instrução while é fornecida abaixo.

while expression:
   statement(s)

O código Jython a seguir usa o loop while para incrementar e imprimir repetidamente o valor de uma variável até que seja menor que zero.

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

Output - A saída seria a seguinte.

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

O Loop FOR

O loop FOR em Jython não é um loop contado como em Java. Em vez disso, ele tem a capacidade de percorrer elementos em um tipo de dados de sequência, como string, lista ou tupla. A sintaxe geral da instrução FOR em Jython é mostrada abaixo -

for iterating_var in sequence:
   statements(s)

Podemos exibir cada caractere em uma string, bem como cada item em uma lista ou tupla usando a instrução FOR conforme mostrado abaixo -

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

Output - A saída seria a seguinte.

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

Vamos considerar outro exemplo como segue.

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

Output - A saída será a seguinte.

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

Aqui está outro exemplo a considerar.

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

Output - O resultado do programa acima é o seguinte.

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

Em Jython, o forinstrução também é usada para iterar sobre uma lista de números gerada pela função range (). A função range () assume a seguinte forma -

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

Os parâmetros de início e etapa são 0 e 1 por padrão. O último número gerado é a etapa de parada. A instrução FOR percorre a lista formada pelorange() function. Por exemplo -

for num in range(5):
   print num

Ele produz a seguinte saída -

0
1
2
3
4

Uma lógica de programação complexa é dividida em um ou mais blocos de instruções independentes e reutilizáveis ​​chamados de funções. A biblioteca padrão do Python contém um grande número de funções integradas. Também se pode definir sua própria função usando odefpalavra-chave. O nome da função definido pelo usuário é seguido por um bloco de instruções que forma seu corpo, que termina com a instrução return.

Uma vez definido, ele pode ser chamado de qualquer ambiente qualquer número de vezes. Vamos considerar o código a seguir para deixar o ponto claro.

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

#calling the function
SayHello()

Uma função pode ser projetada para receber um ou mais parâmetros / argumentos do ambiente de chamada. Ao chamar essa função parametrizada, você precisa fornecer o mesmo número de parâmetros com tipos de dados semelhantes usados ​​na definição da função, caso contrário, o interpretador Jython emitirá umTypeError exceção.

Exemplo

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

o output será o seguinte -

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

Após realizar as etapas nele definidas, a função chamada retorna ao ambiente de chamada. Ele pode retornar os dados, se uma expressão for mencionada na frente da palavra-chave return dentro da definição da função.

#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

A seguinte saída é obtida se o script acima for executado a partir do prompt Jython.

area = 200
value returned by function : 200

Um módulo é um script Jython no qual uma ou mais funções, classes ou variáveis ​​relacionadas são definidas. Isso permite uma organização lógica do código Jython. Os elementos do Programa definidos em um módulo podem ser usados ​​em outro script Jython importando o módulo ou o elemento específico (função / classe) dele.

No código a seguir (hello.py) uma função SayHello() é definido.

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

Para usar a função SayHello () de outro script, importe o hello.py module iniciar.

import hello
hello.SayHello("TutorialsPoint")

No entanto, isso importará todas as funções definidas no módulo. Para importar funções específicas do módulo, use a seguinte sintaxe.

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

Por exemplo, para importar apenas a função SayHello (), altere o script acima como segue.

from hello import SayHello
SayHello("TutorialsPoint")

Não há necessidade de prefixar o nome do módulo ao chamar a função.

Qualquer pasta contendo um ou mais módulos Jython é reconhecida como um pacote. No entanto, deve haver um arquivo especial chamado__init__.py, que fornece o índice de funções a serem usadas.

Vamos agora entender como criar e importar um pacote.

Step 1 - Crie uma pasta chamada package1, em seguida, crie e salve o seguinte g módulos nele.

#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 - Na pasta package1, crie e salve o __init__.py arquivo com o seguinte conteúdo.

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

Step 3 - Crie o seguinte script Jython fora da pasta package1 como 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- Execute test.py no prompt Jython. A seguinte saída será obtida.

factorial = 120
addition = 30
multiplication = 200

Baixar jython-standalone-2.7.0.jar - Para incorporar Jython em aplicativos Java de sua página oficial de downloads: http://www.jython.org/downloads.html e inclua este arquivo jar na variável de ambiente Java CLASSPATH.

Esta biblioteca contém o PythonInterpreterclasse. Usando o objeto desta classe, qualquer script Python pode ser executado usando oexecfile()método. O PythonInterpreter permite que você faça uso dePyObjectsdiretamente. Todos os objetos conhecidos pelo sistema de tempo de execução Jython são representados por uma instância da classe PyObject ou uma de suas subclasses.

A classe PythonInterpreter tem alguns métodos usados ​​regularmente, que são explicados na tabela abaixo.

Sr. Não. Método e Descrição
1

setIn(PyObject)

Defina o objeto Python a ser usado para o fluxo de entrada padrão
2

setIn(java.io.Reader)

Defina um java.io.Reader a ser usado para o fluxo de entrada padrão
3

setIn(java.io.InputStream)

Defina um java.io.InputStream a ser usado para o fluxo de entrada padrão
4

setOut(PyObject)

Defina o objeto Python a ser usado para o fluxo de saída padrão
5

setOut(java.io.Writer)

Defina o java.io.Writer a ser usado para o fluxo de saída padrão
6

setOut(java,io.OutputStream)

Defina o java.io.OutputStream a ser usado para o fluxo de saída padrão
7

setErr(PyObject)

Defina um objeto de erro Python a ser usado para o fluxo de erro padrão
8

setErr(java.io.Writer

Defina um java.io.Writer a ser usado para o fluxo de erro padrão
9

setErr(java.io.OutputStream)

Defina um java.io.OutputStream a ser usado para o fluxo de erro padrão
10

eval(String)

Avalie uma string como fonte Python e retorne o resultado
11

eval(PyObject)

Avalie um objeto de código Python e retorne o resultado
12

exec(String)

Execute uma string de origem Python no namespace local
13

exec(PyObject)

Execute um objeto de código Python no namespace local
14

execfile(String filename)

Execute um arquivo de origem Python no namespace local
15

execfile(java.io.InputStream)

Execute um fluxo de entrada do código-fonte Python no namespace local
16

compile(String)

Compile uma string de origem Python como uma expressão ou módulo
17

compile(script, filename)

Compile um script de fonte Python como uma expressão ou módulo
18

set(String name, Object value)

Defina uma variável do tipo de objeto no namespace local
19

set(String name, PyObject value)

Defina uma variável do tipo PyObject no namespace local
20

get(String)

Obtenha o valor de uma variável no namespace local
21

get(String name, Class javaclass

Obtenha o valor de uma variável no namespace local. O valor será retornado como uma instância da classe Java fornecida.

O seguinte bloco de código é um programa Java com um script Jython embutido “hello.py”.usingexecfile()método do objeto PythonInterpreter. Ele também mostra como uma variável Python pode ser definida ou lida usando os métodos 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 ");
   }
}

Compile e execute o programa Java acima para obter a seguinte saída.

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

PyDev é um plugin de código aberto para Eclipse IDE para permitir o desenvolvimento de projetos em Python, Jython e IronPython. Está hospedado emhttps://pydev.org. Um procedimento passo a passo para instalar o plugin PyDev no Eclipse IDE é fornecido abaixo.

Step 1 - Abra Eclipse IDE e escolha o Install New Software opção no menu Ajuda.

Step 2 - Entre http://pydev.org/updatesna caixa de texto na frente do trabalho com etiqueta e clique em adicionar. Escolha todas as entradas disponíveis na lista e clique em Avançar. O assistente levará alguns minutos para concluir a instalação e solicitará que o IDE seja reiniciado.

Step 3- Agora escolha a opção de preferências no menu Janela. A caixa de diálogo Preferências será aberta conforme mostrado abaixo.

Step 4 − Expand the Interpreters node and select Jython Interpreter in the left pane. On the right pane, click on new to give path to the jython.jar file.

We are now ready to start a Jython project using Eclipse.

To make a project in eclipse, we should follow the steps given below.

Step 1 − Choose File ? New ? Project. Choose PyDev from the filter dialog. Give project name, project type and click on Finish.

Step 2 − Hello project will now appear in the project explorer on the left. Right click to add hello.py in it.

Step 3 − An empty hello.py will appear in the editor. Write the Jython code and save.

Step 4 − Click on the Run button on the menu bar. The output will appear in the console window as shown below.

Python and Jython support for NetBeans is available via the nbPython plugin. Download the plugin from following URL - http://plugins.netbeans.org/plugin/56795. Unzip the downloaded archive in some folder. For example - 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)

Em seguida, controles diferentes são adicionados de acordo com sua posição e tamanho absolutos. O código completo é fornecido abaixo -

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)

A saída para o código acima é a seguinte.

Jython FlowLayout

O FlowLayout é o gerenciador de layout padrão para classes de contêiner. Ele organiza o controle da esquerda para a direita e, em seguida, de cima para baixo.

No exemplo a seguir, um objeto Jlabel, um objeto JTextField e um objeto JButton devem ser exibidos em um JFrame usando o gerenciador FlowLayout. Para começar, vamos importar as classes necessárias dojavax.swing pacote e o java.awt pacote.

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

Em seguida, crie um objeto JFrame e defina seu Local, bem como as propriedades de tamanho.

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

Agora declare objetos para as classes JLabel, JTextfield e JButton.

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

Por fim, adicione esses controles no quadro chamando o add() método da classe JFrame.

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

Para exibir o quadro, defina sua propriedade visible como true. O script Jython completo e sua saída são fornecidos abaixo -

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

O gerenciador Gridlayout permite a colocação de controles em uma grade retangular. Um controle é colocado em cada célula da grade.

No exemplo a seguir, o GridLayout é aplicado a um objeto JFrame, dividindo-o em 4 linhas e 4 colunas. Um objeto JButton deve ser colocado em cada célula da grade.

Vamos primeiro importar as bibliotecas necessárias -

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

Em seguida, crie o contêiner JFrame -

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

Agora, aplique GridLayout especificando suas dimensões como 4 por 4.

frame.setLayout(GridLayout(4,4))

Devemos agora usar dois loops FOR, cada um indo de 1 a 4, então dezesseis objetos JButton são colocados nas células subsequentes.

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

Por fim, defina a visibilidade do quadro como verdadeira. O código Jython completo é fornecido abaixo.

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)

A saída do código acima é a seguinte -

Jython BorderLayout

O gerenciador BorderLayout divide o contêiner em cinco regiões geográficas e locais com um componente em cada região. Essas regiões são representadas por constantes definidas como segue -

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

Vamos considerar o seguinte exemplo -

Jython BoxLayout

A classe BoxLayout é definida no javax.swing package. Ele é usado para organizar os componentes no contêiner vertical ou horizontalmente. A direção é determinada pelas seguintes constantes -

  • X_AXIS
  • Y_AXIS
  • LINE_AXIS
  • PAGE_AXIS

A constante inteira especifica o eixo ao longo do qual os componentes do contêiner devem ser dispostos. Quando o contêiner tem a orientação de componente padrão, LINE_AXIS especifica que os componentes sejam dispostos da esquerda para a direita e PAGE_AXIS especifica que os componentes sejam dispostos de cima para baixo.

No exemplo a seguir, o painel (da classe JPanel) é adicionado a um objeto JFrame. BoxLayout vertical é aplicado a ele e mais dois painéis, superior e inferior, são adicionados a ele. Esses dois painéis internos possuem dois botões cada um adicionado no Boxlayout horizontal.

Vamos primeiro criar a janela JFrame de nível superior.

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

O objeto JPanel é declarado como tendo um BoxLayout vertical. Adicione-o no quadro de nível superior.

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

Neste painel, mais dois painéis superior e inferior são adicionados a ele. Cada um deles tem dois objetos JButton adicionados a eles horizontalmente com um suporte de espaço de 25 pixels separando-os.

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

Da mesma forma, o painel inferior é construído.

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

Observe que o createRigidArea()A função é usada para criar um espaço de 25 pixels entre dois botões. Também ocreateVerticalGlue() A função ocupa o espaço inicial ou final no layout.

Para começar, adicione os painéis superior e inferior e defina a propriedade de visibilidade do quadro como true. O código completo é o seguinte -

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)

O código acima irá gerar a seguinte saída.

Jython GroupLayout

O gerenciador GroupLayout agrupa os componentes de maneira hierárquica. O agrupamento é feito por duas classes,SequentialGroup e ParallelGroup, ambos implementam a interface de Grupo em Java.

O procedimento de layout é dividido em duas etapas. Em uma etapa, os componentes são colocados ao longo do eixo horizontal e, em segundo lugar, ao longo do eixo vertical. Cada componente deve ser definido duas vezes no layout.

Existem dois tipos de arranjos, sequenciais e paralelos. Em ambos, podemos organizar os componentes sequencialmente ou em paralelo. No arranjo horizontal, a linha é chamada de grupo sequencial e a coluna é chamada de grupo paralelo. Por outro lado, na disposição paralela, linha de elemento é um grupo paralelo e uma coluna, que é chamada de sequencial.

No exemplo a seguir, cinco botões são organizados de forma que três cada um apareça em linha e coluna. Para começar, adicione um objeto Jpanel em uma janela JFrame e defina seu layout como Grouplayout.

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

Em seguida, construa os objetos JButton -

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

Em seguida, criamos um SequentialGroup nomeado LeftToRightao qual buttonD e buttonY são adicionados. Entre eles, um ParallelGroup ColumnMiddle (com outros três botões adicionados verticalmente) é colocado.

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

Agora vem a definição de SequentialGroup vertical chamado TopToBottom. Adicione uma linha ParallelGroup de três botões e, em seguida, coloque dois botões 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)

Por fim, defina o grupo LeftToRight horizontalmente e o grupo TopToBottom verticalmente para o objeto de layout. O código completo é fornecido abaixo -

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)

A saída do código acima é a seguinte -

O tratamento de eventos no Java swing requer que o controle (como JButton ou JList etc.) seja registrado com o respectivo ouvinte de evento. A interface do ouvinte de evento ou a classe do adaptador correspondente precisa ser implementada ou subclassificada com seu método de tratamento de eventos substituído. Em Jython, o tratamento de eventos é muito simples. Podemos passar qualquer função como propriedade da função de tratamento de eventos correspondente ao controle.

Vamos primeiro ver como um evento de clique é tratado em Java.

Para começar, temos que importar o java.awt.event package. Em seguida, a classe que estende JFrame deve implementar a interface ActionListener.

public class btnclick extends JFrame implements ActionListener

Então, temos que declarar o objeto JButton, adicioná-lo ao ContentPane do frame e então registrá-lo com ActionListener pelo método addActionListener ().

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

Agora, o método actionPerformed () da interface ActionListener deve ser substituído para manipular o ActionEvent.

A seguir está todo o código 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);
   }
}

Agora, vamos escrever o código Jython equivalente ao mesmo código.

Para começar, não precisamos importar o ActionEvent ou o ActionListener, uma vez que a tipagem dinâmica do Jython nos permite evitar a menção dessas classes em nosso código.

Em segundo lugar, não há necessidade de implementar ou criar uma subclasse de ActionListener. Em vez disso, qualquer função definida pelo usuário é fornecida imediatamente ao construtor JButton como um valor deactionPerformed propriedade do feijão.

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

o clickhere() function é definida como uma função Jython regular, que lida com o evento click no botão.

def change_text(event):
print clicked!'

Aqui está o código equivalente do 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)

A saída do código Java e Jython é idêntica. Quando o botão for clicado, ele imprimirá a mensagem 'clicado' no console.

No código Jython a seguir, dois objetos JTextField são fornecidos na janela JFrame para inserir marcas em 'phy' e 'maths'. O objeto JButton executa a função add () quando clicado.

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

A função add () lê o conteúdo de dois campos de texto pelo método getText () e os analisa em inteiros, para que a adição possa ser realizada. O resultado é então colocado no terceiro campo de texto pelo método setText ().

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

O código completo é fornecido abaixo -

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 o código acima é executado a partir do prompt de comando, a seguinte janela é exibida. Insira marcas para 'Phy', Maths 'e clique no botão' Add '. O resultado será exibido de acordo.

Evento Jython JRadioButton

A classe JRadioButton é definida na javax.swing package. Ele cria um botão de alternância selecionável com estados ligado ou desligado. Se vários botões de opção forem adicionados a um ButtonGroup, sua seleção será mutuamente exclusiva.

No exemplo a seguir, dois objetos da classe JRadioButton e dois JLabels são adicionados a um contêiner Jpanel em um BoxLayout vertical. No construtor dos objetos JRadioButton, oOnCheck()função é definida como o valor da propriedade actionPerformed. Esta função é executada quando o botão de rádio é clicado para alterar seu estado.

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

Observe que o estado padrão do botão de rádio é falso (não selecionado). O botão rb1 é criado com seu estado inicial como True (selecionado).

Os dois botões de opção são adicionados a um ButtonGroup de rádio para torná-los mutuamente exclusivos, de forma que, se um for selecionado, o outro será desmarcado automaticamente.

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

Esses dois botões de opção junto com dois rótulos são adicionados a um objeto de painel no layout vertical com uma área separadora de 25 pixels em alturas entre 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)

Este painel é adicionado a um objeto JFrame de nível superior, cuja propriedade visible é definida como 'True' no final.

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)

Execute o script Jython acima e altere a seleção do botão de rádio. A seleção aparecerá na etiqueta na parte inferior.

Evento Jython JCheckBox

Como o JRadioButton, O objeto JCheckBox também é um botão selecionável com uma caixa de seleção retangular ao lado de sua legenda. Isso geralmente é usado para fornecer ao usuário a oportunidade de selecionar várias opções da lista de itens.

No exemplo a seguir, duas caixas de seleção e um rótulo do pacote swing são adicionados a um JPanel no BoxLayout vertical. O rótulo na parte inferior exibe o estado de seleção instantânea de duas caixas de seleção.

Ambas as caixas de seleção são declaradas com o construtor tendo a propriedade actionPerformed definida para o OnCheck() função.

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

A função OnCheck () verifica o estado de seleção de cada caixa de seleção e exibe a mensagem correspondente na etiqueta na parte inferior.

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"

Essas caixas e um objeto JLabel são adicionados a um JPanel com um espaço reservado de 50 pixels de altura adicionado entre eles.

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)

O próprio painel é adicionado a uma janela JFrame de nível superior, cuja propriedade visible é definida como true no final.

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

frame.setVisible(True)

Execute o código acima e experimente selecionar as caixas de seleção. O estado instantâneo de ambas as caixas de seleção é exibido na parte inferior.

Evento Jython JList

O controle JList no pacote swing fornece ao usuário uma lista rolável de itens para escolher. O JComboBox fornece uma lista suspensa de itens. Em Java, o evento de seleção é processado implementando o método valueChanged () no ListSelectionListener. Em Jython, um manipulador de eventos é atribuído à propriedade valueChanged do objeto JList.

No exemplo a seguir, um objeto JList e um rótulo são adicionados a um JFrame no BorderLayout. O JList é preenchido com uma coleção de itens em uma tupla. Sua propriedade valueChanged é definida para a função listSelect ().

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

A função de manipulador de eventos obtém o índice do item selecionado e busca o item correspondente do objeto JList a ser exibido no rótulo na parte inferior.

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

O objeto JList e JLabel são adicionados ao JFrame usando BorderLayout.

Todo o código é fornecido abaixo -

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)

A saída do código a seguir é a seguinte.

A maioria dos aplicativos baseados em GUI tem uma barra de menus na parte superior. Ele é encontrado logo abaixo da barra de título da janela de nível superior. O pacote javax.swing possui recursos elaborados para construir um sistema de menu eficiente. É construído com a ajuda deJMenuBar, JMenu e JMenuItem Aulas.

No exemplo a seguir, uma barra de menu é fornecida na janela de nível superior. Um menu Arquivo que consiste em três botões de item de menu é adicionado à barra de menus. Vamos agora preparar um objeto JFrame com o layout definido como BorderLayout.

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

Agora, um objeto JMenuBar é ativado pelo método SetJMenuBar ().

bar = JMenuBar()
frame.setJMenuBar(bar)

Em seguida, um objeto JMenu com a legenda 'Arquivo' é declarado. Três botões JMenuItem são adicionados ao menu Arquivo. Quando qualquer um dos itens de menu é clicado, a função OnClick () do manipulador ActionEvent é executada. É definido com a propriedade 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)

O manipulador de eventos OnClick () recupera o nome do botão JMenuItem pela função gwtActionCommand () e o exibe na caixa de texto na parte inferior da janela.

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

O objeto de menu Arquivo é adicionado à barra de menus. Finalmente, um controle JTextField é adicionado na parte inferior do objeto JFrame.

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

Todo o código de menu.py é fornecido abaixo -

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 o script acima é executado usando o interpretador Jython, uma janela com o menu Arquivo é exibida. Clique nele e seus três itens de menu aparecerão. Se algum botão for clicado, seu nome será exibido no controle da caixa de texto.

Um objeto de diálogo é uma janela que aparece no topo da janela base com a qual o usuário interage. Neste capítulo, veremos os diálogos pré-configurados definidos na biblioteca swing. Eles sãoMessageDialog, ConfirmDialog e InputDialog. Eles estão disponíveis devido ao método estático da classe JOptionPane.

No exemplo a seguir, o menu Arquivo possui três itens JMenu correspondentes aos três diálogos acima; cada um executa oOnClick manipulador de eventos.

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)

A função de manipulador OnClick () recupera a legenda do botão Item de menu e invoca o respectivo método 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 a opção de mensagem do menu for escolhida, uma mensagem aparecerá. Se a opção de entrada for clicada, uma caixa de diálogo solicitando a entrada é exibida. O texto de entrada é então exibido na caixa de texto na janela JFrame. Se a opção Confirmar for selecionada, uma caixa de diálogo com três botões, SIM, NÃO e CANCELAR será exibida. A escolha do usuário é registrada na caixa de texto.

Todo o código é fornecido abaixo -

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 o script acima é executado, a seguinte janela é exibida com três opções no menu -

Caixa de mensagem

Caixa de entrada

Confirmar diálogo

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