Jython Essentials

Chapter 1. Introduction to Jython

Botanists know that if you cross-pollinate two different strains of plants, you create a hybrid; a new plant that exhibits the strengths of both its parents. Jython is a programming hybrid. It is an implementation of the Python scripting language written in 100% pure Java that runs under any compliant Java Virtual Machine (JVM). Using Jython, you can write Python programs that interact with any Java code. The Jython interpreter supports a number of shortcuts, which make using Java libraries as easy as using your own Python code.

Jython, then, combines a scripting language of unparalleled ease of development with an operating environment for which many powerful tools have been written. The combination can be immensely valuable for programmers, enabling you to cut development time significantly while still retaining the ability to use existing Java tools, such as applets and servlets. Just as Python was originally conceived as glue to bind together other programs, Jython acts as glue to help you get the most out of Java-based tools. In particular, Jython excels at simplifying the use of complex Java programming libraries and APIs, such as the Swing graphical interface toolkit or the JDBC database connectivity API.

This chapter is your road map to the rest of the book. We’ll start with an extended example of using Jython to interactively develop a small graphical interface. Then we’ll discuss why Jython will make it easier for you to get things done. Finally, we’ll walk through the rest of the chapters.

Jython Requirements

To run the examples in this chapter and in the rest of the book, you need to have both Jython and a JVM installed. You can get Jython at http://www.jython.org; see Appendix A for full details. Unless otherwise specified, all Jython examples will run under Jython Version 2.0 or higher, and a fully compliant JVM running Java Version 1.2 or higher. For the examples in this book, we used Sun Microsystem’s Java Development Kit, Version 1.3, but other JVMs should work as well.

Welcome to Jython

Before we offer arguments for why you should be using Jython, let’s first show you what Jython looks like. For your first look at Jython we’re going to do a five-finger exercise from the Jython interactive prompt, which will show off many of Jython’s features. The goal here is to give you a sense of how the integration of Jython and Java libraries works, and how easy it is to play with running code using Jython. In the interest of ease of display, we’re going to be a little looser with good Jython style than we’ll be in the longer examples later in the book—this is just a demonstration, but we hope you’ll find it fun and productive. You may find it useful to type along with this exercise to really get the feel.

Starting Jython

Start by running Jython. You should see an interactive prompt.

Jython 2.1a3 on java1.3.0 (JIT: null)
Type "copyright", "credits" or "license" for more information.
>>>

From this prompt you can type any Jython code and see the result. We’re going to type in some Swing GUI code, so the first thing we need to do is import Swing:

>>> import javax.swing as swing
>>>

Whether you are a Java or Python programmer already, that line probably looks a little odd to you. We have told Jython to import the Java package javax.swing and refer to it using the identifier swing. Unlike a Java import, we don’t need to tell Jython which classes to import, and unlike an ordinary Python import, this is importing Java code that was not specifically written to interact with Jython.

Tip

Throughout this book, we’ll use the word “Python” for things that are common to both Jython and the original implementation of Python. Using the name “Jython” is usually a signal that the concept is applicable only to Jython. Information relevant only to the C-language implementation is referred to using the word “CPython.” For example, “Python uses indentation to determine block boundaries, Jython lets you subclass Java classes, and CPython compiles to .pyc files.”

Next, we can create a window object:

>>> win = swing.JFrame("Welcome to Jython")
>>>

Nothing has happened visibly, but we can confirm that the object has been created by typing the identifier name at the prompt.

>>> win
javax.swing.JFrame[frame0,0,0,0x0,invalid,hidden,layout=java.awt.
BorderLayout,resizable,title=Welcome to Jython,defaultCloseOperation=HIDE_
ON_CLOSE,rootPane=javax.swing.JRootPane[,0,0,0x0,invalid,layout=javax.swing.
JRootPane$RootLayout,alignmentX=null,alignmentY=null,border=,flags=1538,maxi
mumSize=,minimumSize=,preferredSize=],rootPaneCheckingEnabled=true]

(The output probably won’t be bold on your machine, we’re just doing that here for emphasis.) What we’ve done here is use the Python syntax for instance creation to trigger a call to a Java class constructor. Also notice what we did not have to do—namely, declare win as a variable or specify a type for it in any way. The second line uses the Python interpreter to trigger the Java toString( ) method on the win object.

Now, we didn’t set the size of the window. The first line of code will do the actual set, and the second will get the value and print it to confirm.

>>> win.size = (200, 200)
>>> win.size
java.awt.Dimension[width=200,height=200]

If you are a Java programmer, that code probably looks a little too simple to be true, because size is a private field of the window. In fact, Jython is using introspection to infer that win.size on the left side of the assignment refers to the size property, and automatically triggers a Java call to win.setSize( ). On the right side of the assignment, Jython is performing a similar inference. Taking the sequence (200, 200), and knowing that size is of type Dimension, Jython converts the sequence to a Java Dimension object (by calling the appropriate Dimension constructor) before making the assignment. Similarly, the win.size standing alone in the second line triggers a call to the Java method win.getSize( ). So, Jython allows you to write code that retains Python’s simplicity and type flexibility, but still allows the objects to behave like Java objects.

Let’s get that window on the screen.

>>> win.show( )
>>>

Nothing happens on the command prompt, but a blank window with a Welcome to Jython title, and size 200 by 200 should show up on your monitor. If you accidentally close it, just type win.show( ) again. Being able to interact with concrete objects can be of immense help in debugging.

Adding Items to the Window

The window seems rather dull, so let’s do something for it.

>>> field = swing.JTextField(preferredSize=(200,20))
>>> win.contentPane.add(field)
javax.swing.JTextField[,0,0,200x20,. . .
>>> win.pack( )

We cut off the output for clarity. At the end of this sequence, the window should have a text field in it (and probably resize itself as well). This time, we put the preferred size setting in the call to the constructor. As you may know, JTextFields in Java don’t take preferred size as an argument to the constructor. Again, Jython infers the correct property call when the object is constructed.

Type something in the text box. Then go back to the Jython prompt to type:

>>> field.text
'Neat!'

Of course, you’ll get whatever you typed into the box, not what we typed. This shows off the fact that Jython is interacting with the Java objects in both directions—again, excellent for debugging.

Now, let’s put some buttons in.

>>> names = ["Groucho", "Chico", "Harpo"]
>>>

First, a list of names is created by enclosing the names inside brackets. In Python, a list is similar to Java’s ArrayList class, but with more functionality and tighter integration to the core language. This line shows one example of that integration—the ability to type new lists directly without calling functions or explicit constructors. In this example, names is set to a list containing three strings. The assignment returns no value—in Python, an assignment is a statement, not an expression. Python’s list type is an example of the high-level basic types that make programming in Python so easy to manage.

The actual buttons are created from the list of names using a different Python method for creating a list called a list comprehension.

>>> buttons = [swing.JButton(each) for each in names]
>>>

The line of code can be read almost as it looks in English: “Perform the statement swing.JButton( ) once for each element in the list called names.” That code creates a new JButton with each string in the list names as an argument. When evaluating a list comprehension, Python holds onto the values for each statement and returns them as a list. In this case, the variable buttons now contains a list of three JButton instances.

Now that we have a list of buttons, we can add them to the window with the use of a simple for loop.

>>> for eachButton in buttons:
...     eachButton.preferredSize = (100, 20)
...     win.contentPane.add(eachButton)
...
javax.swing.JButton[,0,0,0x0,invalid,layout. . .

In the interpreter, ... is used to indicate that the next line of code is part of a block—you don’t actually type the dots. However, you must indent the last two lines by the same amount (at least one character) for Jython to read the block properly. The top line of this block contains a for statement. In Python, for statements work only for iterating over sequences. They are roughly the equivalent of a Java Iterator, however the loop in the Python case is executed automatically once for each element of the sequence without having to either explicitly ask the iterator for the next object or cast the object to any specific type. From the interpreter, a blank line indicates the end of a block (outside the interpreter, you’d just start the next line back at column one).

Inside the loop, the code sets the preferred size of each button and adds it to the window’s content pane, again using the introspection shortcuts. Once all the buttons are added, we can pack the window again.

>>> win.pack( )

But now, the window is a mess—the buttons are placed on top of each other, and on top of the text field. We’ve forgotten to give the window a layout manager (which is the mechanism Swing uses to automatically place items within a window). No problem, we can just add it after we import the appropriate package.

>>> import java.awt as awt
>>> win.contentPane.layout = awt.FlowLayout( )
>>> win.pack( )

Adding Behavior

At this point, the window should look right, but it doesn’t do anything. We want it to place some text in the text field depending on what button you push. First, we need to create the text we want used.

>>> quotes = {"Groucho": "Say the secret word", "Chico": "Viaduct?",
 "Harpo": "HONK!"}

This line sets up a Python dictionary. A dictionary in Python is more or less equivalent to a Java HashMap: a collection of key/value pairs designed to be accessed in constant time no matter which element is accessed or how large the dictionary is. Again, the Python type is well integrated with the core language, allowing the creation in one line of what would take a series of put(key, value) calls in Java.

Once the text is in place, we can define a function that will perform the actual text replacement.

>>> def buttonPressed(event):
...     field.text = quotes[event.source.text]
...
>>>

This pair of lines defines a function to be called when a button is pressed. The event parameter in the first line will be the actual Java Event object created from the mouseclick. The line of code inside the function uses Jython shortcuts, looks up the quotes dictionary with the text of the source button, and sets the field with that value. The Java equivalent would be something like:

field.setText(quotes.get((javax.swing.JTextField) event.getSource( )).
getText( )))

We hope that we aren’t losing credibility by suggesting that the Python example is a little bit easier to read.

Finally, we associate the function with the buttons.

>>> for eachButton in buttons:
...     eachButton.actionPerformed = buttonPressed
...
>>>

This for loop puts the buttonPressed function in the actionPerformed slot for each button. This is another Jython shortcut—as used in Java, buttons don’t have an actionPerformed attribute. Instead, actionPerformed is the method defined inside an ActionListener interface. When you assign to actionPerformed Jython performs the appropriate call to the button’s addActionListener( ) method, such that the function buttonPressed is triggered when the action is performed. Also notice that Jython allows us to use a function as the righthand side of an assignment statement, we’re using the function as a value. At this point, the window should work, and look more or less like Figure 1-1.

Figure 1-1. The sample window

Of course, Jython does not have to be run interactively. The code that we used in the interactive shell session is shown as a standalone file in Example 1-1. The code is equivalent to the preceding session, but we did clean it up some, removing duplicate calls to pack( ), putting import and definitions where they would more typically come in a Python module, adding code to exit Jython when the window closes, and refactoring button creation into a separate function. Example 1-1 is typical of a Jython script as it would actually be written.

Example 1-1. The sample standalone window

import java.lang as lang
import javax.swing as swing
import java.awt as awt

names = ["Groucho", "Chico", "Harpo"]
quotes = {"Groucho": "Say the secret word",
        "Chico": "Viaduct?", "Harpo": "HONK!"}

def buttonPressed(event):
     field.text = quotes[event.source.text]

def exit(event):
    lang.System.exit(0)

def createButton(name):
    return swing.JButton(name, preferredSize=(100,20),
            actionPerformed=buttonPressed)

win = swing.JFrame("Welcome to Jython", size=(200, 200),windowClosing=exit)
win.contentPane.layout = awt.FlowLayout( )

field = swing.JTextField(preferredSize=(200,20))
win.contentPane.add(field)

buttons = [createButton(each) for each in names]
for eachButton in buttons:
    win.contentPane.add(eachButton)
win.pack( )
win.show( )

Running this script from Jython (for example, by executing jython filename at an ordinary command prompt) will give you the same window and behavior as in Figure 1-1.

What’s Jython Good For?

Having seen the interactive example, hopefully you are interested in learning more about Jython. But you may be wondering exactly what you might use it for. It can help to think of the JVM as a platform in its own right. Java has been the overwhelming choice of programming language for the JVM platform—a number of different languages other than Jython run under a JVM in one way or another, but for most people, so far, the JVM and Java programming have been effectively synonymous. Uses of Jython can be split into two areas: things you might want to do within a JVM for which Java is not a great choice, and things you might want to do where Java does seem like a strong choice.

In the first category are the kinds of programs at which scripting languages have traditionally excelled. Programs that are small utility tools, or one-time-only scripts, or rapid development prototypes, have all been in the purview of scripting languages such as Python. The Java language, for all its usability benefits over, say, C++, was not designed for that kind of rapid development or scripting work. Jython makes that kind of programming easier on a JVM, giving you scripting language flexibility where it did not exist previously. This also suggests a place for Jython as an adjunct to existing Java programs—performing cleanup and maintenance functions, for example.

Web programming is another area in the first category. Java has made tremendous strides as a server-side web application tool over the last few years, primarily because of the creation of really good industrial-strength server environments. Writing the actual web application in Java, however, is still a chore, especially when maximum response to changed requirements is needed. Outside the Java world, many (if not most) web applications are still written in dynamic scripting-style languages such as ColdFusion, Perl, or Python. It’s no accident that template languages or other scripting languages written specifically for Java web applications have proliferated. Jython as a web language gives you a scripting language that is more powerful and established than other Java web tools such as WebMacro or Tea, yet still gives you full access to the Java servlet libraries.

Another area that Java doesn’t really cover is the use of a scripting language by your Java program. The Jython interpreter can be embedded inside any Java program, allowing you full access to Jython for scripting inside the program. One use of this feature common in Python is to have your preference or properties file be a “live” Jython script, saving you the trouble of having to convert a properties or XML file to actual functionality.

We do not, however, want to give you the impression that Jython is good only for tasks that Java is weak at. In fact, we also think that you will find Jython useful even for the kinds of applet or GUI applications traditionally thought of as Java’s strengths. We believe that if you decide to prototype your program in Jython, there is a very good chance that you will find that development of the Jython version is so smooth, you will keep the prototype rather than port it to Java.

The Benefits of Jython

We think that Jython is likely to improve your productivity for a great number of project types that are currently performed in Java. In this section, we’ll start to explore the reasons why we believe this to be true. We’ll also suggest some reasons why Jython might be a good addition to your toolkit even if you are already a CPython programmer.

For Java Programmers

If you are already programming in Java, you are probably wondering why you need another language to run under the JVM. Doesn’t Java work just fine? Sure, Java is great. But, by using Jython instead of Java, you’ll probably find that the number of lines of code in your program has dropped by as much as 50%. Many empirical studies of programming suggest that shorter programs have fewer bugs. In addition, programmer productivity tends to be about the same for any number of lines of code even if, as in Jython, each line of code tends to do more than it might in another language. In other words, an expert Jython programmer will likely produce programs faster, and with fewer bugs, than an expert Java programmer.

We don’t mean to attack Java as a programming language. Java, like every programming language, is a tool, and it has its uses. However, it’s hard to use Java for any length of time and not realize that it is an exceptionally verbose and often inflexible language. After you’ve written lines of code such as the following, which includes a typecast that is there only to keep the compiler happy:

MyClass instance = (MyClass)list.get(2);

it becomes easier to see the benefits of just writing:

instance = list[2]

The difference between the Java and Python code emphasizes one of the main sources of the productivity advantage of Jython—dynamic typing. In Python, you do not need to declare variables for use, nor do you need to tell the interpreter what the expected data type of a variable is. It is important to note that despite being dynamically typed, Python also has strong typing. This means that a line of code such as "1" + 1 is an error in Python (unlike many other scripting languages, which would quietly allow this).

If you have never programmed in a dynamic language, the idea of not declaring variables or types may make you a little nervous. After all, isn’t the point of static typing to allow the compiler to catch errors before the program runs? It’s certainly true that static typing can do that. Most programmers who switch to a dynamic language are surprised by how rarely those errors actually occur in practice, and how quickly they are usually found and fixed when they do occur.

In Python most type errors are caught immediately the first time you run the program—long before any users see it. Often type mistakes will result in errors the first time a module is loaded or the first time a function is called. Some basic unit testing makes it nearly impossible for a type check error to get by. When compared with the amount of effort spent in Java convincing the compiler that your program is legal, it seems that static typing may not be worth the effort. It’s worth your time to try it and see if your experience is similar to ours.

In addition to dynamic typing, the Python scripting language used in Jython offers several other features that will improve your programming productivity:

Clean, easy-to-read syntax

Python was designed from the ground up to be as readable as possible—it’s been described as “executable pseudocode.” Python’s use of indentation to denote block boundaries makes for consistent and clear code. Unlike some other scripting languages, Python syntax tends to be in words rather than typographical syntax—it’s very unlikely you’ll be writing lines of code that look like comic book curse words. As a result, when you have to come back to your code six months later, odds are you will still be able to understand it.

Interactive interpreter

Jython has a command-line interpreter where you can enter any Jython expression (including function definitions, class definitions, and module imports) and evaluate it interactively. The interactive session makes it easy to test and debug Jython code and also to explore existing Java libraries by trial and error.

Module-based organization

Unlike Java, where every line of code has to be inside a class definition, Jython separates the package organization from the class system. A Jython module can contain any valid statement, including class and function definitions as well as normal program code. The lack of insistence on structure is particularly nice in short scripts, but also helpful for distributing a number of related classes together.

High-level, built-in types

Jython’s list of basic types includes a few that go beyond Java’s basic data types. These include sequence types similar to Java collection classes and dictionaries similar to Java’s map classes. Having these types built into the language makes them easier to work with—you can enter an entire dictionary as a literal expression, for example. Jython also includes a built-in file type which is far easier to use than Java’s I/O classes.

Simple object-oriented semantics

Classes, instances, and modules are all implemented using the same simple concept of a namespace or mapping between variable names and values. Syntax and behavior of all three are similar, and are only a short step from the behavior of any Python dictionary. This consistency makes the behavior of Python programs extremely easy to predict, with nearly no special cases or exceptions to be memorized.

Operator overloading

Python allows you to easily overload all operators and many built-in functions to work as desired on user-defined classes. This allows your classes to interoperate cleanly with built-in types, and can also result in clearer code.

Dynamic dispatch and polymorphism

Both Python and Java have dynamic dispatch, meaning that the class whose code is evaluated from a line such as instance.method( ) is determined at runtime based on the class to which that instance belongs. Unlike Java, Python does not test for the existence of method( ) in any particular class at compile time. This is a corollary of dynamic typing, and has many of the same strengths and weaknesses. However, the flexibility it gives you over Java is significant, removing the need for Java-style interfaces and more generally promoting code reuse by making it easier for new code to interact with existing code.

No compile phase

The Jython development cycle does not have a separate compilation phase. Files are compiled if needed during execution, speeding up development.

First-class functions and classes

A first-class object can be returned from or passed to a function. In Python, functions, classes, and modules are all first-class objects. Being able to pass these kinds of code objects around can lead to very elegant code designs and increase reuse by allowing classes to “plug” functionality into existing structures. While some of this is technically achievable in Java using either anonymous inner classes or the java.lang.reflect package, the Python version is much easier to use. The following two code blocks are roughly equivalent, each creating a function object called someFunc and calling it.

Java:

import java.lang.reflect.*;
Class aClass = anInstance.getClass( );
Method someFunc = aClass.getMethod("method", new Class[] {Integer,
String});
someFunc.invoke(anInstance, new Object[] {new Integer(3), "Fred"});

Python:

someFunc = anInstance.method
someFunc(3, "Fred")

Extensive included library

Jython includes most of the Python standard library. Although some of that functionality is duplicated in the Java standard library, much of it is not. Examples include regular expression support (finally coming in JDK 1.4), parsers, network support, unit test frameworks, and much more.

All this additional functionality comes without having to sacrifice integration with existing Java code. Jython code can be compiled to Java .class or .jar files, and these files can be distributed like any other compiled Java files—the fact that the code was written in Jython can be made completely transparent to the end user.

For Python Programmers

If you are already a Python programmer, you know about the programming features of Python and are probably wondering what you gain from the Java side of the equation. There seem to be at least three important gains.

Extended reach

Using Jython, you can deploy a Python language program in arenas that are simply not possible using CPython. The most notable examples of this are web-based—namely, the creation of applets that will be accepted by mainstream browsers, and the creation of servlets that can be run by Java servlet or J2EE servers.

Ease of distribution

Jython makes it easy to distribute your program as a cross-platform binary in .jar format. Although there are binary tools for CPython on different platforms, there is no similar cross-platform tool for CPython.

Tools and libraries

This is the biggest advantage of Jython. Although the Python standard library and available third-party tools are varied and wonderful, Java has benefited from a much larger pool of available tools, particularly enterprise-level tools. The Swing GUI toolkit is more complete and more cross-platform than any GUI toolkit available for CPython, and is arguably easier to use. Database tools are much more widely available and standardized in the Java world. There is a large quantity of high-level tools for XML data. All these libraries and tools can be used from Jython at least as easily as other Java tools would be able to use them.

The Speed Question

Everybody asks it, at some point. Whenever you try to sell somebody on using a high-level scripting-style language, the question will inevitably come up: “Isn’t it slow?” As long-time programmers of scripting languages and other languages that have been branded as slow (including Java), we have a variety of reasons why raw benchmark speed is less important than it might seem as a factor in choosing a programming tool. In fact, we’ll also argue that for most of you, most of the time, the speed difference is not going to hurt at all.

What is the exact magnitude of the speed difference? It’s notoriously difficult to get good information about performance across languages. Sometimes, the person compiling the numbers has an axe to grind and has chosen a task that favors one language. More often, the person compiling the examples has just done a better job optimizing one version over the other. So, any cross-language speed comparison needs to be taken with a grain of salt.

That said, one of the authors’ experience in running identical code under both Python 2.1 and Jython 2.1a3 (using Sun’s JDK 1.3) suggests that CPython takes 75% of the time that Jython does. Jython is about 1–10 times slower than equivalent Java code, although admittedly useful hard numbers on this are hard to come by because the exact speed difference strongly depends on the nature of your application. Programs that spend a lot of time doing operations on primitive data types will show the largest speed difference between Java and Jython.

Jython performance is heavily dependent on the specifics of the JVM, of course. Specifically, the Sun JDK 1.4 is expected to make significant improvements in the performance of Java reflection, and as a result Jython should make substantial speed gains under JVM 1.4.

Still, up to 10 times slower seems like a big speed difference. And for some programs and some projects it might be. But for most programs and projects, the benchmark speed hit will not be as noticeable in practice as you might think. There are four reasons why the speed loss is not as harmful in practice as it is in benchmarks.

For a large number of programs, the bottleneck is either user input speed or network latency, and even a large performance hit in these cases is not noticeable to users. Java programs tend to be in this category frequently—if raw speed was the issue, you probably wouldn’t be using Java in the first place.

Even for programs in which optimal performance is particularly important, profiling will often indicate that a small number of classes or methods are the bottleneck. In Jython, these areas can be targeted and rewritten in Java so that you get the maximum performance benefit for the minimum effort.

There’s what we might call the Peters principle, after CPython core developer, Tim Peters. He has suggested that his Python programs often run faster than his C programs in practice, because development is so much easier in Python that you often wind up with a much better algorithm than you would in C. In particular, common performance enhancements such as caching function results are quite easy to code in Python.

Finally, as in so many aspects of software design, there’s a trade off. If each run of your program takes five seconds longer, but you get it to your users three months sooner than you otherwise would have, what’s that worth to you? How much value is created in the development time saved? For many projects, three months of programmer time is worth far more than the user time lost if the program is slower. For some projects, of course, the speed is still critical.

As always, the rule is “Make it work, then make it fast.” Jython is a fabulous environment for making it work, and if at some point you find that you still need to make it faster, there are mechanisms to try, both within Jython and by converting some code to Java.

The Rest of the Book

The remainder of the book is broadly divided into three sections: an introduction to the Python language, an overview of how Jython and Java interact, and a tour of various important modules and libraries that can assist a Jython programmer.

You will find an introduction to the Python language in Chapter 2 through Chapter 5. The goal of these chapters is a brief but thorough tour through the Python concepts you will need to use Jython effectively. Throughout these chapters, we’ll be comparing Python types and structures with the nearest Java equivalents. The four chapters build on top of each other. Chapter 2 starts with a description of Python’s built-in types and the functionality they offer. Chapter 3 covers Python statements, including simple statements such as assignments, and block statements such as loops and conditionals. This chapter also covers Python’s use of whitespace as a block delimiter. In Chapter 4, we show how you combine statements into functions, and how to create modules that can be reused across multiple programs. Chapter 5 describes Python’s object-oriented syntax and semantics, again paying particular emphasis to how it differs from Java’s object-oriented structures.

In these chapters, we also try to give a description of what is considered good Python programming style. If you are already comfortable programming in Python, it is probably okay if you just skim this section. However, a few Jython specifics are covered in those early chapters, so they’re worth looking over.

In Chapter 6 through Chapter 8, we’ll move to Jython-specific topics. These chapters describe the various ways in which Jython and Java can interact. The goal of Jython is to make the interaction between Java and Jython code as simple as possible, and to allow you to use Java objects as though they were written in Jython. Chapter 6 covers the use of existing Java classes from within Jython. This includes creating instances of preexisting Java classes, and calling methods of those classes. In addition, Jython performs some automatic type conversions between Java and Python types that are covered in this chapter. Chapter 7 moves into the tighter integration between Java and Jython that comes when your Jython class is a direct subclass of an existing Java class. There are some rules for accessing parent class members that you need to know. Chapter 8 takes a closer look at the introspection shortcuts used in this chapter’s exercise that allow you to bypass Java’s getSomething and setSomething methods. That chapter also covers the Python tools that allow you to dynamically get information about the classes in your system, both Python and Java, while your program is running.

Chapter 9 through Chapter 11 discuss using Jython with existing Java and Python libraries. Jython puts you in a unique position with respect to common tools. Frequently, there is a Java solution and a Python solution that are both usable. We’ve chosen which to highlight on a case-by-case basis, choosing based on ease of use in Jython, existence of documentation, or sheer coolness. Chapter 9 presents several examples using the Swing GUI toolkit. Chapter 10 uses the JDBC database API, the servlet API, and XML tools to give further examples of using existing Java tools. Chapter 11 covers what portions of the Python standard library are available in Jython, and which are particularly useful.

Finally, Chapter 12 and Chapter 13 cover advanced Jython topics. Chapter 12 shows how you can use Jython as a scripting language within a Java program by including the Jython interpreter as an object. In Chapter 13, we show how you can compile your Jython code to .class or .jar files that can be run by any JVM or Java engine.