Jython - Hướng dẫn nhanh

Jython là triển khai JVM của ngôn ngữ lập trình Python. Nó được thiết kế để chạy trên nền tảng Java. Một chương trình Jython có thể nhập và sử dụng bất kỳ lớp Java nào. Cũng giống như Java, chương trình Jython biên dịch thànhbytecode. Một trong những ưu điểm chính là giao diện người dùng được thiết kế bằng Python có thể sử dụng các phần tử GUI củaAWT, Swing hoặc là SWT Package.

Jython, bắt đầu là JPython và sau đó được đổi tên, theo sát quá trình triển khai Python tiêu chuẩn được gọi là CPython như được tạo ra bởi Guido Van Rossum. Jython được tạo ra vào năm 1997 bởiJim Hugunin. Jython 2.0 được phát hành vào năm 1999. Kể từ đó, các bản phát hành Jython 2.x tương ứng với các bản phát hành CPython tương đương. Jython 2.7.0 được phát hành vào tháng 5 năm 2015, tương ứng với CPython 2.7. Quá trình phát triển Jython 3.x đang được tiến hành.

Sự khác biệt giữa Python và Java

Sau đây là sự khác biệt giữa Python và Java:

  • Python là một ngôn ngữ được nhập động. Do đó, không cần khai báo kiểu của biến. Mặt khác, Java là một ngôn ngữ được định kiểu tĩnh, có nghĩa là việc khai báo kiểu của biến là bắt buộc và không thể thay đổi.

  • Python chỉ có các ngoại lệ không được kiểm tra, trong khi Java có cả các ngoại lệ được kiểm tra và bỏ chọn.

  • Python sử dụng thụt lề để xác định phạm vi, trong khi Java sử dụng dấu ngoặc nhọn phù hợp.

  • Vì Python là một ngôn ngữ dựa trên trình thông dịch, nó không có các bước biên dịch riêng biệt. Tuy nhiên, một chương trình Java cần được biên dịch thành bytecode và lần lượt được thực thi bởi một JVM.

  • Python hỗ trợ đa kế thừa, nhưng trong Java, đa kế thừa là không thể. Tuy nhiên, nó có triển khai một giao diện.

  • So với Java, Python có cấu trúc dữ liệu tích hợp phong phú hơn (danh sách, dict, bộ giá trị, mọi thứ đều là một đối tượng).

Sự khác biệt giữa Python và Jython

Sau đây là những khác biệt giữa Python và Jython:

  • Triển khai tham chiếu của Python, được gọi là CPython, được viết bằng ngôn ngữ C. Mặt khác, Jython được viết hoàn toàn bằng Java và là một triển khai JVM.

  • Python chuẩn có sẵn trên nhiều nền tảng. Jython có sẵn cho bất kỳ nền tảng nào có cài đặt JVM trên đó.

  • Mã Python tiêu chuẩn biên dịch thành .pyc tệp, trong khi chương trình Jython biên dịch thành .class tập tin.

  • Các phần mở rộng Python có thể được viết bằng ngôn ngữ C. Các phần mở rộng cho Jython được viết bằng Java.

  • Jython thực sự là đa luồng trong tự nhiên. Tuy nhiên, Python sử dụngGlobal Interpreter Lock (GIL) cơ chế cho mục đích.

  • Cả hai triển khai đều có các cơ chế thu gom rác khác nhau.

Trong chương tiếp theo, chúng ta sẽ học cách nhập các thư viện Java trong Jython.

Trước khi cài đặt Jython 2.7, hãy đảm bảo rằng hệ thống có JDK 7hoặc nhiều hơn được cài đặt. Jython có sẵn dưới dạng tệp jar thực thi. Tải xuống từ -http://www.jython.org/downloads.html và nhấp đúp vào biểu tượng của nó hoặc chạy lệnh sau:

java -jar jython_installer-2.7.0.jar

Một trình hướng dẫn cài đặt sẽ bắt đầu với các tùy chọn cài đặt phải được cung cấp. Đây là quy trình cài đặt có hệ thống.

Bước đầu tiên trong trình hướng dẫn yêu cầu bạn chọn ngôn ngữ.

Bước thứ hai nhắc bạn chấp nhận thỏa thuận cấp phép.

Trong bước tiếp theo, chọn kiểu cài đặt. Nên chọn cài đặt Chuẩn.

Màn hình tiếp theo yêu cầu xác nhận của bạn về các tùy chọn của bạn và tiến hành hoàn tất cài đặt.

Quy trình cài đặt có thể mất một chút thời gian để hoàn thành.

Sau khi cài đặt xong, hãy gọi jython.exetừ thư mục bin bên trong thư mục đích. Giả sử rằng Jython được cài đặt trongC:\jython27, thực hiện những điều sau từ dòng lệnh.

C:\jython27\bin\jython

Một dấu nhắc Python (>>>) sẽ xuất hiện, phía trước có thể thực thi bất kỳ câu lệnh Python nào hoặc tập lệnh Python nào.

Một trong những tính năng quan trọng nhất của Jython là khả năng nhập các lớp Java trong một chương trình Python. Chúng tôi có thể nhập bất kỳ gói hoặc lớp java nào trong Jython, giống như chúng tôi làm trong chương trình Java. Ví dụ sau đây cho thấy cáchjava.util các gói được nhập bằng script Python (Jython) để khai báo một đối tượng của lớp Date.

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

Lưu và chạy đoạn mã trên dưới dạng UtilDate.pytừ dòng lệnh. Phiên bản của ngày và giờ hiện tại sẽ được hiển thị.

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

Các gói sau từ thư viện Java thường được nhập trong một chương trình Jython chủ yếu là do thư viện Python chuẩn hoặc không có các gói tương đương hoặc không tốt.

  • Servlets
  • JMS
  • J2EE
  • Javadoc
  • Swing được coi là vượt trội so với các bộ công cụ GUI khác

Bất kỳ gói Java nào cho vấn đề đó đều có thể được nhập trong một tập lệnh Jython. Ở đây, chương trình java sau được lưu trữ và biên dịch trong một gói có tênfoo.

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

Điều này HelloWorld.classđược nhập trong Tập lệnh Jython sau. Các phương thức trong lớp này có thể được gọi từ tập lệnh Jythonimportex.py.

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

Lưu và thực thi tập lệnh trên từ dòng lệnh để có kết quả sau.

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

Các biến là vị trí được đặt tên trong bộ nhớ của máy tính. Mỗi biến có thể chứa một phần dữ liệu trong đó. Không giống như Java, Python là một ngôn ngữ được gõ động. Do đó trong khi sử dụng Jython cũng vậy; việc khai báo trước kiểu dữ liệu của biến không được thực hiện. Thay vì loại biến quyết định dữ liệu nào có thể được lưu trữ trong nó, dữ liệu quyết định loại biến.

Trong ví dụ sau, một biến được gán một giá trị nguyên. Sử dụng hàm tích hợp kiểu (), chúng ta có thể xác minh rằng kiểu của biến là một số nguyên. Nhưng, nếu cùng một biến được gán một chuỗi, thì hàm type () sẽ chuỗi là kiểu của cùng một biến.

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

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

Điều này giải thích tại sao Python được gọi là một ngôn ngữ được gõ động.

Các kiểu dữ liệu tích hợp sẵn trong Python sau đây cũng có thể được sử dụng trong Jython:

  • Number
  • String
  • List
  • Tuple
  • Dictionary

Python nhận dạng dữ liệu số là một số, có thể là số nguyên, số thực với dấu phẩy động hoặc số phức. Các kiểu dữ liệu String, List và Tuple được gọi là chuỗi.

Số Jython

Trong Python, bất kỳ số nguyên có dấu nào được cho là thuộc loại 'int'. Để biểu thị một số nguyên dài, chữ cái 'L' được gắn vào nó. Một số có dấu thập phân tách phần nguyên khỏi thành phần phân số được gọi là 'float'. Phần phân số có thể chứa một số mũ được biểu thị trong ký hiệu khoa học bằng cách sử dụng 'E' hoặc 'e'.

Số phức cũng được định nghĩa là kiểu dữ liệu số trong Python. Một số phức chứa một phần thực (số phẩy động) và một phần ảo có gắn 'j' vào nó.

Để thể hiện một số ở dạng biểu diễn Bát phân hoặc Thập lục phân, 0O hoặc là 0Xlà tiền tố cho nó. Khối mã sau đây đưa ra các ví dụ về các cách biểu diễn số khác nhau trong Python.

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

Jython Strings

Chuỗi là bất kỳ chuỗi ký tự nào được đặt trong dấu ngoặc kép đơn (ví dụ: 'xin chào'), kép (ví dụ: "xin chào") hoặc ba (ví dụ: "" xin chào "" o "" "xin chào" "). Dấu ngoặc kép đặc biệt hữu ích nếu nội dung của chuỗi kéo dài trên nhiều dòng.

Các ký tự của chuỗi Escape có thể được bao gồm nguyên văn trong chuỗi ba dấu ngoặc kép. Các ví dụ sau đây cho thấy các cách khác nhau để khai báo một chuỗi trong 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.
"""

Chuỗi thứ ba khi được in ra sẽ cho kết quả như sau.

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.

Danh sách Jython

Danh sách là một kiểu dữ liệu trình tự. Nó là một tập hợp các mục được phân tách bằng dấu phẩy, không nhất thiết phải cùng loại, được lưu trữ trong dấu ngoặc vuông. Mục riêng lẻ từ Danh sách có thể được truy cập bằng chỉ mục dựa trên số không.

Khối mã sau đây tóm tắt cách sử dụng Danh sách trong 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]

Bảng sau đây mô tả một số Biểu thức Jython phổ biến nhất liên quan đến Danh sách Jython.

Biểu thức Jython Description
len(List) Length
List[2]=10 Updation
Del List[1] Deletion
List.append(20) Append
List.insert(1,15) Insertion
List.sort() Sorting

Jython Tuples

A tuple is an immutable collection of comma-separated data items stored in parentheses. It is not possible to delete or modify an element in tuple, nor is it possible to add an element to the tuple collection. The following code block shows Tuple operations.

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

Jython Dictionary

The Jython Dictionary is similar to Map class in Java Collection framework. It is a collection of key-value pairs. Pairs separated by comma are enclosed in curly brackets. A Dictionary object does not follow zero based index to retrieve element inside it as they are stored by hashing technique.

The same key cannot appear more than once in a dictionary object. However, more than one key can have same associated values. Different functions available with Dictionary object are explained below −

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

The following table describes some of the most common Jython Expressions related to Dictionary.

Jython Expression Description
dict.get(‘011’) Search
len(dict) Length
dict[‘044’] = ‘Chennai’ Append
del dict[‘022’] Delete
dict.keys() list of keys
dict.values() List of values
dict.clear() Removes all elements

In addition to Python’s built-in data types, Jython has the benefit of using Java collection classes by importing the java.util package. The following code describes the classes given below −

  • Java ArrayList object with add()
  • remove()
  • get() and set() methods of the ArrayList class.
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

The above Jython script produces the following output −

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

Jarray Class

Jython also implements the Jarray Object, which allows construction of a Java array in Python. In order to work with a jarray, simply define a sequence type in Jython and pass it to the jarrayobject along with the type of object contained within the sequence. All values within a jarray must be of the same type.

The following table shows the character typecodes used with a jarray.

Character Typecode Corresponding Java Type
Z Boolean
C char
B byte
H short
I int
L long
F float
D double

The following example shows construction of 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

Here my_seq is defined as a tuple of integers. It is converted to Jarray arr1. The second example shows that Jarray arr2 is constructed from mySttr string sequence. The output of the above script jarray.py is as follows −

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

Decision making structures have one or more conditions to be evaluated or tested by the program, along with a statement or statements that are to be executed, if the condition is determined to be true, and optionally, other statements to be executed, if the condition is determined to be false.

The following illustration shows the general form of a typical decision making structure found in most of the programming languages −

Jython does not use curly brackets to indicate blocks of statements to be executed when the condition is true or false (as is the case in Java). Instead, uniform indent (white space from left margin) is used to form block of statements. Such a uniformly indented block makes the conditional code to be executed when a condition given in ‘if’ statement is true.

A similar block may be present after an optional ‘else’ statement. Jython also provides the elif statement using which successive conditions can be tested. Here, the else clause will appear last and will be executed only when all the preceding conditions fail. The general syntax of using if..elif..else is as follows.

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

In the following example, if ..elif ..else construct is used to calculate discount on different values of amount input by user.

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

The output of above code will be as shown below.

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 general, statements in a program are executed sequentially: The first statement in a function is executed first, followed by the second, and so on. There may be a situation when you need to execute a block of code several number of times. Statements that provide such repetition capability are called looping statements.

In Jython, a loop can be formed by two statements, which are −

  • The while statement and

  • The for statement

The WHILE Loop

A while loop statement in Jython is similar to that in Java. It repeatedly executes a block of statements as long as a given condition is true. The following flowchart describes the behavior of a while loop.

The general syntax of the while statement is given below.

while expression:
   statement(s)

The following Jython code uses the while loop to repeatedly increment and print value of a variable until it is less than zero.

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

Output − The output would be as follows.

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

The FOR Loop

The FOR loop in Jython is not a counted loop as in Java. Instead, it has the ability to traverse elements in a sequence data type such as string, list or tuple. The general syntax of the FOR statement in Jython is as shown below −

for iterating_var in sequence:
   statements(s)

We can display each character in a string, as well as each item in a List or Tuple by using the FOR statement as shown below −

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

Output − The output would be as follows.

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

Let us consider another instance as follows.

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

Output − The output will be as follows.

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

Here is another instance to consider.

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

Output − The output of the above program is as follows.

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

In Jython, the for statement is also used to iterate over a list of numbers generated by range() function. The range() function takes following form −

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

The start and step parameters are 0 and 1 by default. The last number generated is stop step. The FOR statement traverses the list formed by the range() function. For example −

for num in range(5):
   print num

It produces the following output −

0
1
2
3
4

A complex programming logic is broken into one or more independent and reusable blocks of statements called as functions. Python’s standard library contains large numbers of built-in functions. One can also define their own function using the def keyword. User defined name of the function is followed by a block of statements that forms its body, which ends with the return statement.

Once defined, it can be called from any environment any number of times. Let us consider the following code to make the point clear.

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

#calling the function
SayHello()

A function can be designed to receive one or more parameters / arguments from the calling environment. While calling such a parameterized function, you need to provide the same number of parameters with similar data types used in the function definition, otherwise Jython interpreter throws a TypeError exception.

Example

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

The output will be as follows −

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

After performing the steps defined in it, the called function returns to the calling environment. It can return the data, if an expression is mentioned in front of the return keyword inside the definition of the function.

#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

The following output is obtained if the above script is executed from the Jython prompt.

area = 200
value returned by function : 200

A module is a Jython script in which one or more related functions, classes or variables are defined. This allows a logical organization of the Jython code. The Program elements defined in a module can be used in another Jython script by importing either the module or the specific element (function/class) from it.

In the following code (hello.py) a function SayHello() is defined.

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

To use the SayHello() function from another script, import the hello.py module in it.

import hello
hello.SayHello("TutorialsPoint")

However, this will import all functions defined in the module. In order to import specific function from module use following syntax.

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

For example, to import only the SayHello() function, change the above script as follows.

from hello import SayHello
SayHello("TutorialsPoint")

There is no need to prefix the name of the module while calling the function.

Any folder containing one or more Jython modules is recognized as a package. However, it must have a special file called __init__.py, which provides the index of functions to be used.

Let us now understand, how to create and import package.

Step 1 − Create a folder called package1, then create and save the following g modules in it.

#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 − In the package1 folder create and save the __init__.py file with the following content.

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

Step 3 − Create the following Jython script outside the package1 folder as 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 from Jython prompt. The following output will be obtained.

factorial = 120
addition = 30
multiplication = 200

Download jython-standalone-2.7.0.jar - For embedding Jython in Java applications from their official downloads page: http://www.jython.org/downloads.html and include this jar file in Java CLASSPATH environment variable.

This library contains the PythonInterpreter class. Using the object of this class, any Python script can be executed using the execfile() method. The PythonInterpreter enables you to make use of PyObjects directly. All objects known to the Jython runtime system are represented by an instance of the class PyObject or one of its subclasses.

The PythonInterpreter class has some regularly used methods, which are explained in the table given below.

Sr.No. Method & Description
1

setIn(PyObject)

Set the Python object to use for the standard input stream
2

setIn(java.io.Reader)

Set a java.io.Reader to use for the standard input stream
3

setIn(java.io.InputStream)

Set a java.io.InputStream to use for the standard input stream
4

setOut(PyObject)

Set the Python object to use for the standard output stream
5

setOut(java.io.Writer)

Set the java.io.Writer to use for the standard output stream
6

setOut(java,io.OutputStream)

Set the java.io.OutputStream to use for the standard output stream
7

setErr(PyObject)

Set a Python error object to use for the standard error stream
8

setErr(java.io.Writer

Set a java.io.Writer to use for the standard error stream
9

setErr(java.io.OutputStream)

Set a java.io.OutputStream to use for the standard error stream
10

eval(String)

Evaluate a string as Python source and return the result
11

eval(PyObject)

Evaluate a Python code object and return the result
12

exec(String)

Execute a Python source string in the local namespace
13

exec(PyObject)

Execute a Python code object in the local namespace
14

execfile(String filename)

Execute a file of Python source in the local namespace
15

execfile(java.io.InputStream)

Execute an input stream of Python source in the local namespace
16

compile(String)

Compile a Python source string as an expression or module
17

compile(script, filename)

Compile a script of Python source as an expression or module
18

set(String name, Object value)

Set a variable of Object type in the local namespace
19

set(String name, PyObject value)

Set a variable of PyObject type in the local namespace
20

get(String)

Get the value of a variable in the local namespace
21

get(String name, Class javaclass

Get the value of a variable in the local namespace. The value will be returned as an instance of the given Java class.

The following code block is a Java program having an embedded Jython script “hello.py”.usingexecfile() method of the PythonInterpreter object. It also shows how a Python variable can be set or read using set() and get() methods.

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 and run the above Java program to obtain the following output.

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

PyDev is an open source plugin for Eclipse IDE to enable development of projects in Python, Jython as well as IronPython. It is hosted at https://pydev.org. A step-by-step procedure to install PyDev plugin in Eclipse IDE is given below.

Step 1 − Open Eclipse IDE and choose the Install New Software option from the Help menu.

Step 2 − Enter http://pydev.org/updates in the textbox in front of work with label and click add. Choose all available entries in the list and click on Next. The Wizard will take a few minutes to complete the installation and it will prompt the IDE to be restarted.

Step 3 − Now choose the preferences option from the Window menu. The Preferences dialog will open as shown below.

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)

Sau đó, các điều khiển khác nhau được thêm vào tùy theo vị trí và kích thước tuyệt đối của chúng. Mã hoàn chỉnh được cung cấp bên dưới -

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)

Đầu ra cho đoạn mã trên như sau.

Jython FlowLayout

FlowLayout là trình quản lý bố cục mặc định cho các lớp vùng chứa. Nó sắp xếp điều khiển từ trái sang phải và sau đó theo hướng từ trên xuống dưới.

Trong ví dụ sau, một đối tượng Jlabel, một đối tượng JTextField và một đối tượng JButton sẽ được hiển thị trong JFrame bằng trình quản lý FlowLayout. Để bắt đầu, hãy để chúng tôi nhập các lớp bắt buộc từjavax.swing gói và java.awt gói hàng.

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

Sau đó, tạo một đối tượng JFrame và đặt Vị trí của nó cũng như các thuộc tính kích thước.

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

Bây giờ khai báo các đối tượng cho các lớp JLabel, JTextfield và JButton.

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

Cuối cùng, thêm các điều khiển này vào khung bằng cách gọi add() phương thức của lớp JFrame.

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

Để hiển thị khung, hãy đặt thuộc tính hiển thị của nó thành true. Tập lệnh Jython hoàn chỉnh và đầu ra của nó như dưới đây:

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

Trình quản lý Gridlayout cho phép đặt các điều khiển trong một lưới hình chữ nhật. Một điều khiển được đặt trong mỗi ô của lưới.

Trong ví dụ sau, GridLayout được áp dụng cho một đối tượng JFrame chia nó thành 4 hàng và 4 cột. Một đối tượng JButton sẽ được đặt trong mỗi ô của lưới.

Trước tiên, hãy để chúng tôi nhập các thư viện cần thiết -

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

Sau đó, tạo vùng chứa JFrame -

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

Bây giờ, hãy áp dụng GridLayout bằng cách chỉ định các kích thước của nó là 4 x 4.

frame.setLayout(GridLayout(4,4))

Bây giờ chúng ta nên sử dụng hai vòng lặp FOR, mỗi vòng từ 1 đến 4, vì vậy mười sáu đối tượng JButton được đặt trong các ô tiếp theo.

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

Cuối cùng đặt khả năng hiển thị của khung thành true. Mã Jython hoàn chỉnh được đưa ra bên dưới.

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)

Đầu ra của đoạn mã trên như sau:

Jython BorderLayout

Trình quản lý BorderLayout chia vùng chứa theo năm khu vực địa lý và các vị trí với một thành phần trong mỗi khu vực. Các vùng này được biểu diễn bằng các hằng số xác định như sau:

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

Chúng ta hãy xem xét ví dụ sau:

Jython BoxLayout

Lớp BoxLayout được định nghĩa trong javax.swing package. Nó được sử dụng để sắp xếp các thành phần trong container theo chiều dọc hoặc chiều ngang. Hướng được xác định bởi các hằng số sau:

  • X_AXIS
  • Y_AXIS
  • LINE_AXIS
  • PAGE_AXIS

Hằng số nguyên chỉ định trục mà các thành phần của vùng chứa sẽ được bố trí dọc theo. Khi vùng chứa có hướng thành phần mặc định, LINE_AXIS chỉ định rằng các thành phần được bố trí từ trái sang phải và PAGE_AXIS chỉ định rằng các thành phần được bố trí từ trên xuống dưới.

Trong ví dụ sau, bảng điều khiển (thuộc lớp JPanel) được thêm vào một đối tượng JFrame. BoxLayout dọc được áp dụng cho nó và hai bảng khác, trên cùng và dưới cùng, được thêm vào nó. Hai bảng bên trong này có hai nút, mỗi bảng được thêm vào trong Boxlayout nằm ngang.

Đầu tiên chúng ta hãy tạo cửa sổ JFrame cấp cao nhất.

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

Đối tượng JPanel được khai báo có BoxLayout dọc. Thêm nó vào khung cấp cao nhất.

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

Trong bảng điều khiển này, hai bảng khác trên và dưới được thêm vào. Mỗi người trong số họ có hai đối tượng JButton được thêm vào chúng theo chiều ngang với một ngăn chứa 25 pixel ngăn cách chúng.

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

Tương tự, bảng điều khiển dưới cùng được xây dựng.

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

Lưu ý rằng createRigidArea()được sử dụng để tạo một khoảng trống 25 pixel giữa hai nút. Ngoài racreateVerticalGlue() chức năng chiếm đầu hoặc không gian cuối trong bố cục.

Để bắt đầu, hãy thêm các bảng trên cùng và dưới cùng và đặt thuộc tính khả năng hiển thị của khung thành true. Mã hoàn chỉnh như sau:

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ạn mã trên sẽ tạo ra kết quả sau.

Jython GroupLayout

Trình quản lý GroupLayout nhóm các thành phần theo cách phân cấp. Việc nhóm được thực hiện bởi hai lớp,SequentialGroup và ParallelGroup, cả hai đều triển khai giao diện Nhóm trong Java.

Quy trình bố trí được chia thành hai bước. Trong một bước, các thành phần được đặt dọc theo trục hoành và ở bước thứ hai dọc theo trục tung. Mỗi thành phần phải được xác định hai lần trong bố cục.

Có hai kiểu sắp xếp, tuần tự và song song. Trong cả hai, chúng ta có thể sắp xếp các thành phần tuần tự hoặc song song. Trong sắp xếp theo chiều ngang, hàng được gọi là nhóm tuần tự và cột được gọi là nhóm song song. Mặt khác, trong sự sắp xếp song song, hàng của phần tử là một nhóm song song và một cột, được gọi là tuần tự.

Trong ví dụ sau, năm nút được sắp xếp theo cách mà ba nút xuất hiện trong hàng và cột. Để bắt đầu, hãy thêm một đối tượng Jpanel trong cửa sổ JFrame và đặt bố cục của nó là Grouplayout.

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

Sau đó, xây dựng các đối tượng JButton -

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

Tiếp theo, chúng tôi tạo một SequentialGroup được đặt tên LeftToRightbuttonD và buttonY được thêm vào. Ở giữa chúng, một ParallelGroup ColumnMiddle (với ba nút khác được thêm theo chiều dọc) được đặ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)

Bây giờ đến định nghĩa của SequentialGroup dọc được gọi là TopToBottom. Thêm một hàng ParallelGroup gồm ba nút và sau đó đặt hai nút theo chiều dọc.

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

Cuối cùng, đặt nhóm LeftToRight theo chiều ngang và nhóm TopToBottom theo chiều dọc đối tượng bố cục. Mã hoàn chỉnh được cung cấp bên dưới -

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)

Đầu ra của đoạn mã trên như sau:

Xử lý sự kiện trong Java swing yêu cầu điều khiển (như JButton hoặc JList, v.v.) phải được đăng ký với trình nghe sự kiện tương ứng. Giao diện trình xử lý sự kiện hoặc lớp Bộ điều hợp tương ứng cần được triển khai hoặc phân lớp với phương thức xử lý sự kiện của nó được ghi đè. Trong Jython, việc xử lý sự kiện rất đơn giản. Chúng ta có thể chuyển bất kỳ hàm nào làm thuộc tính của hàm xử lý sự kiện tương ứng với điều khiển.

Đầu tiên chúng ta hãy xem cách một sự kiện nhấp chuột được xử lý trong Java.

Để bắt đầu, chúng ta phải nhập java.awt.event package. Tiếp theo, lớp mở rộng JFrame phải triển khai giao diện ActionListener.

public class btnclick extends JFrame implements ActionListener

Sau đó, chúng ta phải khai báo đối tượng JButton, thêm nó vào khung ContentPane và sau đó đăng ký nó với ActionListener bằng phương thức addActionListener ().

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

Bây giờ, phương thức actionPerformed () của giao diện ActionListener phải được ghi đè để xử lý ActionEvent.

Sau đây là toàn bộ mã 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);
   }
}

Bây giờ, chúng ta sẽ viết mã Jython tương đương với mã tương tự.

Để bắt đầu, chúng ta không cần nhập ActionEvent hoặc ActionListener, vì kiểu gõ động của Jython cho phép chúng ta tránh đề cập đến các lớp này trong mã của mình.

Thứ hai, không cần phải triển khai hoặc phân lớp ActionListener. Thay vào đó, bất kỳ hàm nào do người dùng xác định đều được cung cấp ngay lập tức cho hàm tạo JButton dưới dạng giá trị củaactionPerformed tính chất đậu.

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

Các clickhere() hàm được định nghĩa là một hàm Jython thông thường, hàm này xử lý sự kiện bấm vào nút.

def change_text(event):
print clicked!'

Đây là mã tương đương 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)

Đầu ra của mã Java và Jython giống hệt nhau. Khi nút được nhấp, nó sẽ in thông báo 'đã nhấp' trên bảng điều khiển.

Trong đoạn mã Jython sau, hai đối tượng JTextField được cung cấp trên cửa sổ JFrame để nhập dấu trong 'phy' và 'maths'. Đối tượng JButton thực thi hàm add () khi được nhấp vào.

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

Hàm add () đọc nội dung của hai trường văn bản bằng phương thức getText () và phân tích cú pháp chúng thành các số nguyên để có thể thực hiện phép cộng. Kết quả sau đó được đưa vào trường văn bản thứ ba bằng phương thức setText ().

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

Mã hoàn chỉnh được cung cấp bên dưới -

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)

Khi đoạn mã trên được thực thi từ dấu nhắc lệnh, cửa sổ sau sẽ xuất hiện. Nhập điểm cho 'Phy', Maths, và nhấp vào nút 'Thêm'. Kết quả sẽ được hiển thị tương ứng.

Sự kiện Jython JRadioButton

Lớp JRadioButton được định nghĩa trong javax.swing package. Nó tạo ra một nút chuyển đổi có thể lựa chọn với các trạng thái bật hoặc tắt. Nếu nhiều nút radio được thêm vào một Nhóm nút, lựa chọn của chúng là loại trừ lẫn nhau.

Trong ví dụ sau, hai đối tượng của lớp JRadioButton và hai JLabels được thêm vào vùng chứa Jpanel trong BoxLayout dọc. Trong hàm tạo của các đối tượng JRadioButton,OnCheck()hàm được đặt làm giá trị của thuộc tính actionPerformed. Chức năng này được thực hiện khi nút radio được nhấp để thay đổi trạng thái của nó.

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

Lưu ý rằng trạng thái mặc định của Radio Button là false (không được chọn). Nút rb1 được tạo với trạng thái bắt đầu là True (đã chọn).

Hai nút radio được thêm vào một Nhóm nút radio để làm cho chúng loại trừ lẫn nhau, để nếu một nút được chọn, nút kia sẽ tự động được bỏ chọn.

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

Hai nút radio này cùng với hai nhãn được thêm vào một đối tượng bảng điều khiển trong bố cục dọc với vùng phân cách 25 pixel chiều cao giữa rb2 và 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)

Bảng điều khiển này được thêm vào đối tượng JFrame cấp cao nhất, cuối cùng thuộc tính hiển thị được đặt thành 'Đúng'.

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)

Chạy tập lệnh Jython ở trên và thay đổi lựa chọn nút radio. Lựa chọn sẽ xuất hiện trong nhãn ở dưới cùng.

Sự kiện Jython JCheckBox

Giống như JRadioButton, Đối tượng JCheckBox cũng là một nút có thể chọn với hộp kiểm hình chữ nhật bên cạnh chú thích của nó. Điều này thường được sử dụng để cung cấp cho người dùng cơ hội chọn nhiều tùy chọn từ danh sách các mục.

Trong ví dụ sau, hai hộp kiểm và nhãn từ gói swing được thêm vào JPanel trong BoxLayout dọc. Nhãn ở dưới cùng hiển thị trạng thái lựa chọn tức thời của hai hộp kiểm.

Cả hai hộp kiểm đều được khai báo với hàm tạo có thuộc tính actionPerformed được đặt thành OnCheck() chức năng.

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

Hàm OnCheck () xác minh trạng thái lựa chọn của từng hộp kiểm và hiển thị thông báo tương ứng trên nhãn ở phía dưới.

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"

Các hộp này và một đối tượng JLabel được thêm vào JPanel với một khoảng trắng có chiều cao 50 pixel được thêm vào giữa chúng.

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)

Bản thân bảng điều khiển được thêm vào cửa sổ JFrame cấp cao nhất, cuối cùng thuộc tính hiển thị được đặt thành true.

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

frame.setVisible(True)

Chạy mã trên và thử nghiệm với việc lựa chọn các hộp kiểm. Trạng thái tức thời của cả hai hộp kiểm được hiển thị ở dưới cùng.

Sự kiện Jython JList

Điều khiển JList trong gói swing cung cấp cho người dùng một danh sách các mục có thể cuộn để chọn. JComboBox cung cấp danh sách các mục thả xuống. Trong Java, sự kiện lựa chọn được xử lý bằng cách triển khai phương thức valueChanged () trong ListSelectionListener. Trong Jython, một trình xử lý sự kiện được gán cho thuộc tính valueChanged của đối tượng JList.

Trong ví dụ sau, một đối tượng JList và một nhãn được thêm vào JFrame trong BorderLayout. JList chứa một bộ sưu tập các mục trong một bộ. Thuộc tính valueChanged của nó được đặt thành hàm listSelect ().

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

Hàm xử lý sự kiện lấy chỉ mục của mục đã chọn và tìm nạp mục tương ứng từ đối tượng JList sẽ được hiển thị trên nhãn ở phía dưới.

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

Đối tượng JList và JLabel được thêm vào JFrame bằng cách sử dụng BorderLayout.

Toàn bộ mã được đưa ra bên dưới -

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)

Đầu ra của đoạn mã sau như sau.

Hầu hết các ứng dụng dựa trên GUI đều có thanh Menu ở trên cùng. Nó được tìm thấy ngay bên dưới thanh tiêu đề của cửa sổ cấp cao nhất. Gói javax.swing có cơ sở phức tạp để xây dựng một hệ thống menu hiệu quả. Nó được xây dựng với sự trợ giúp củaJMenuBar, JMenu và JMenuItem các lớp học.

Trong ví dụ sau, một thanh menu được cung cấp trong cửa sổ cấp cao nhất. Menu Tệp bao gồm ba nút mục menu được thêm vào thanh menu. Bây giờ chúng ta hãy chuẩn bị một đối tượng JFrame với bố cục được đặt thành BorderLayout.

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

Bây giờ, một đối tượng JMenuBar được kích hoạt bởi phương thức SetJMenuBar ().

bar = JMenuBar()
frame.setJMenuBar(bar)

Tiếp theo, một đối tượng JMenu có chú thích 'Tệp' được khai báo. Ba nút JMenuItem được thêm vào menu Tệp. Khi bất kỳ mục nào trong menu được nhấp, hàm OnClick () của trình xử lý ActionEvent được thực thi. Nó được định nghĩa với thuộc tính 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)

Trình xử lý sự kiện OnClick () truy xuất tên của nút JMenuItem bằng hàm gwtActionCommand () và hiển thị nó trong hộp văn bản ở cuối cửa sổ.

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

Đối tượng menu Tệp được thêm vào thanh menu. Cuối cùng, một điều khiển JTextField được thêm vào ở cuối đối tượng JFrame.

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

Toàn bộ mã của menu.py được cung cấp bên dưới -

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)

Khi tập lệnh trên được thực thi bằng trình thông dịch Jython, một cửa sổ có menu Tệp sẽ xuất hiện. Nhấp vào nó và ba mục menu của nó sẽ thả xuống. Nếu bất kỳ nút nào được nhấp, tên của nút đó sẽ được hiển thị trong điều khiển hộp văn bản.

Đối tượng Hộp thoại là một cửa sổ xuất hiện trên đầu cửa sổ cơ sở mà người dùng tương tác. Trong chương này, chúng ta sẽ thấy các hộp thoại được cấu hình sẵn được xác định trong thư viện swing. họ đangMessageDialog, ConfirmDialog và InputDialog. Chúng khả dụng vì phương thức tĩnh của lớp JOptionPane.

Trong ví dụ sau, menu Tệp có ba mục JMenu tương ứng với ba hộp thoại trên; mỗi người thực hiệnOnClick xử lý sự kiện.

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)

Hàm xử lý OnClick () truy xuất chú thích của nút Menu Item và gọi phương thức showXXXDialog () tương ứng.

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

Nếu tùy chọn tin nhắn từ menu được chọn, một thông báo sẽ bật lên. Nếu tùy chọn Đầu vào được nhấp, hộp thoại yêu cầu đầu vào sẽ bật lên. Văn bản đầu vào sau đó được hiển thị trong hộp văn bản trong cửa sổ JFrame. Nếu tùy chọn Xác nhận được chọn, một hộp thoại có ba nút, CÓ, KHÔNG và HỦY sẽ xuất hiện. Lựa chọn của người dùng được ghi lại trong hộp văn bản.

Toàn bộ mã được đưa ra bên dưới -

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)

Khi tập lệnh trên được thực thi, cửa sổ sau được hiển thị với ba tùy chọn trong menu:

Hộp tin nhắn

Hộp đầu vào

Hộp thoại xác nhận

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