Unlike Java, Jython does not implicitly and automatically import
java.lang. Your Jython code can explicitly
import java.lang, or even just
import java, and then use classes such as
java.lang.String as if they were Python classes. Specifically, your Jython code can use imported Java classes as if they were Python classes with a
_ _slots_ _ class attribute (i.e., you cannot create arbitrary new instance attributes). You can subclass a Java class with your own Python class, and instances of your class do let you create new attributes just by binding them, as usual.
You may choose to import a top-level Java package (such as
java) rather than specific subpackages (such as
java.lang). Your Python code acquires the ability to access all subpackages when you import the top-level package. For example, after
import java, your code can use classes
java.util.Vector, and so on.
The Jython runtime wraps every Java class you import in a transparent proxy, which manages communication between Python and Java code behind the scenes. This gives an extra reason to avoid the dubious idiom
import *, in addition to the reasons mentioned in The from ... import * statement. When you perform such a bulk import, the Jython runtime must build proxy wrappers for all the Java classes in package
somewhere, spending substantial amounts of memory and time wrapping many classes your code will probably not use. Avoid
from ... import ...