abstract—Class or method modifier that indicates that some or all behavior must be implemented in a subclass.
applet—A Java program that must be embedded within an HTML page and executed within a browser.
assert—Java keyword that causes an AssertionError to be generated if the specified boolean condition is false.
bean—Java architecture for writing reusable components in Java.
bitwise and—This operator (&) returns true when comparing two bits if both are true; otherwise, returns false.
bitwise exclusive or—This operator (^) returns true when comparing two bits if one bit is true and the other is false; otherwise, returns false.
bitwise not—This operator (!) returns the compliment of the bit being compared.
bitwise operators—Operators used on the byte data type to modify bit values. These include the bitwise and (&), or (|), not (!), exclusive or (^), shift left (<<), shift right (>>), and shift and rotate (<<<) operators.
bitwise or—This operator ( | ) returns true when comparing two bits if both are true, or if one is true and one is false; otherwise, returns false.
boolean—Primitive data type indicating either true or false.
break—Statement used to cause program execution to branch out of the current block of code enclosed by braces.
byte—Primitive data type representing eight bits of data.
bytecode—Platform-independent machine instruction code executed by the Java virtual machine. Java .class files, the product of compilation, are composed of bytecode instructions.
case—Statement that lists a condition for executing code within a switch statement.
catch—Used in conjunction with the try statement, indicates an exception and the block of code that will handle the exception.
cast—In Java, indicated by parens enclosing a class name. Causes the virtual machine to treat the object being cast as an instance of the class within the parens.
char—Primitive data type representing one Unicode character, or two bytes.
class—This is the basic component from which Java applications are built. Classes specify the types of state information (class and instance variables) and the behavior (methods) that instances of the class will exhibit.
class loader—A Java object that dynamically loads other classes into the Java virtual machine.
class variable—A variable that is shared among all instances of a class. Class variables are indicated by the use of the static keyword. If an instance of a class updates a class variable, it is updated for all instances of that class.
collections—The Java framework for handling data structures, such as lists and hashmaps.
const—This keyword is reserved in Java, but provides no programmatic function. Constants should be implemented in Java by declaring static final class variables.
constructor—A special method that creates a new object of the type of its enclosing class.
continue—Returns execution of a loop back to the beginning of the block that contains the continue statement, skipping any statements after the continue to the close of the block.
CORBA—Common Object Request Broker Architecture. Used to wrap legacy code so that it can be invoked by a Java program.
default—Statement used as part of a switch statement to indicate the fallback execution path if none of the cases within the switch apply.
do—The beginning statement of a do…while loop. All code after the do statement and prior to the conditional check on the while statement is executed at least one time.
double—Primitive data type representing a double-precision, signed 32-bit number.
EJB—Enterprise Java Bean. A framework for building distributed database applications.
else—Indicates the alternate branch of an if statement. This statement can be either unconditional, or may contain an additional condition in another if clause.
error—Indicates an unpredictable, and usually fatal, problem within the virtual machine.OutOfMemoryError.
exception—Often used to indicate an error condition, but may also be used to indicate a predictable condition occurring within an application.
extends—Keyword indicating that a class inherits from another class.
final—Keyword modifier for variable, method, or class declarations. In the case of a variable, it indicates that the variable cannot be re-initialized after the original declaration. For a method, it indicates that the method may not be overridden by a subclass. For a class, it indicates that the class may not be extended by a subclass.
finally—Statement composing the third part of a try…catch…finally block. The code within this code block will execute regardless of whether an exception was caught, or if normal execution occurred.
float—Primitive data type representing a floating point signed 64-bit number.
for—Beginning statement of a for loop. This statement has three parts: an initializer, which specifies the initial conditions of the loop; an iteration check that checks the loop condition prior to the loop being executed; and a loop iterator that is used to change the value of the loop condition.
garbage collection—The system by which the Java virtual machine reclaims memory that is no longer being used by the executing Java program. A Java object is eligible for garbage collection when it is set to null, when all references to the object fall out of scope, or when a weak reference to the object exists. Garbage collection is not guaranteed to run during the life of the virtual machine. When an object is garbage-collected, its protected void finalize() method runs, giving the object a chance to clean up after itself.
garbage collector—A process that runs within the Java virtual machine to reclaim memory that is no longer used by Java objects.
goto—This keyword is reserved in Java, but serves no function. It was reserved as a keyword by the language designers to ensure that unconditional branches, a.k.a. spaghetti code, could not be written in Java.
heap—An area of memory with the Java virtual machine from which objects are created. The initial and maximum heap size for the virtual machine can be set with the -Xms and -Xmx non-standard command line options.
if—A conditional statement that executes if a boolean condition following the if keyword is evaluated as true.
implements—Keyword indicating that a class implements the methods of a particular Java interface. A class can implement zero or more interfaces.
import—Statement used at the beginning of a Java class to make code from other Java packages available for use within the class. Note that, unlike the C #include directive, importing Java classes, even with the wildcard indicator “*”, does not increase the size of the importing class.
instance—An occurrence of an object in memory.
instanceof—Boolean operator that returns true if the left-hand operand is an instance of the class indicated by the right-hand operand. For example, (“mystring” instanceof java.lang.String) would return true.
int—Primitive data type for a 32-bit signed integer value.
interface—A definition that specifies the instance variables and/or method signatures that must exist within classes that implement the interface.
introspection—A means by which Java classes can determine the methods and instance variables of a class within the virtual machine. This mechanism is chiefly used in the Java Beans architecture to allow Java environments to discover the capabilities of a Java component without the component’s source code.
J2EE—Java Two Enterprise Edition. A toolset for building distributed, scalable, multi-tier enterprise-class applications.
JAAS—Java Authentication and Authorization Service.
JAF—JavaBeans Activation Framework. A framework for handling various data types within the JavaMail APIs.
Java—A platform-independent programming language developed by Sun Microsystems in the mid-1990s. Java was created to eliminate many of the shortcomings of languages such as C and C++, and draws from the syntax of languages such as C++, Smalltalk, and other object-oriented programming languages.
java—Command used to execute a Java program.
javac—Command used to compile a Java program.
javaw—Command used to execute a Java program without a console window being displayed.
Javadoc—A Java toolset for documenting Java APIs. Javadoc comments are denoted in code by /** and */, and are processed by the Javadoc tools into HTML API documentation.
Java 2D—A library of Java classes for line drawing, text processing, and image handling.
Java Accessibility API—Provides support for assistive technologies, such as screen readers, speech recognition, and refreshable Braille displays, for disabled users.
Java IMF—Java Input Methods Framework. A framework that provides a mechanism for entering text by other methods than a standard keyboard; for example, speech recognition or a Japanese keyboard.
JAXP—Java API for XML Processing. Includes libraries for SAX and DOM processing of XML documents, as well as support for other XML technologies, such as XSLT and XML schema.
JDBC—Java DataBase Connectivity. This is the API through which Java programs can access records in a database, and run SQL queries and stored procedures.
JDK—Java Development Kit. Now, Sun uses the term SDK, indicating the Standard Development Kit, which includes only the Java base classes and tools needed to compile and run basic Java programs.
JMS—Java Message Service. An API that allows Java programs to create, send, receive, and read messages in an enterprise messaging system.
JNDI—Java Naming and Directory Interface. An API for providing access to directory services, such as LDAP, from within Java programs.
JNI—Java Native Interface. A mechanism for allowing Java programs to invoke native code written for a particular platform.
JRE—Java Runtime Environment. Includes all files necessary to execute, but not to compile, a Java program.
jre—Command used to invoke the Java runtime environment.
jrew—Command used to invoke the Java runtime environment without a console window.
JSP—Java Server Pages. A mechanism for server-side scripting within Web pages.
JTS—Java Transaction Service. An API for supporting transactions distributed across multiple hosts. This allows operations to be committed or rolled back on more than one virtual machine if a failure occurs in one step of a transaction.
JVM—Java Virtual Machine. See virtual machine.
long—Primitive data type used to store 64-bit signed integer values.
method—Similar to functions and procedures in other languages. Methods implement the behavior for objects.
method signature—The criteria used by the Java compiler to determine which method within a class to execute when a method call is made. The signature includes the scope, return type, method name, and parameter types for the method, but not the exceptions thrown by the method. Overriding methods must have the same signature as the methods they override; overloaded methods must have the same return type and method name, but not the same parameter types as the methods they overload.
native—Keyword indicating that a method must be implemented using code native to the platform on which the virtual machine is executing, rather than within the virtual machine itself.
new—Operator that creates a new instance of a class by calling its constructor.
object—An instance of a class. An object has identity (uniqueness), state (instance variable or class variable values), and behavior (methods).
overloading—Overloading is the process of implementing several methods with the same return type and name, but different numbers and/or types of parameters.
overriding—Overriding a method occurs when a subclass implements a method with the same method signature as a superclass. Overriding can replace functionality implemented in the superclass, or can add to it by invoking the superclass’ method.
package—Statement indicating a class’ package name. Packages are divisions within an object-oriented program that group classes by functionality.
package protected—Scope that indicates that an instance variable is visible to other classes within its same package, or to subclasses of the class containing the instance variable. This scope is the default scope in Java, and is indicated by no scope indicator.
private—Scope indicator that hides an instance variable from all other classes, regardless of their package or their class hierarchy relationship to the class containing the variable.
protected—Scope indicator that makes an instance variable visible to subclasses that inherit from the class containing the instance variable.
public—Scope indicator that makes an instance variable visible to any class, regardless of package or class hierarchy relationship to the class containing the instance variable.
return—Statement that ends the execution of a method. If the method has a return type, this statement returns a value of that type; otherwise, if the method returns void, execution of the method ends at the return statement.
RMI—Remote Method Invokation. Allows a program running in one Java virtual machine to invoke methods on an object running an another Java virtual machine, even if the two VMs are running on different host machines.
serialization—The mechanism within the Java virtual machine for persistifying objects. The state of serialized objects is stored, and can be retrieved to re-create the object at a later time.
servlet—A Java program that executes on a Web server in response to an HTTP request similar to a CGI. Servlets can produce HTML output in the HTTP response returned, or can invoke Java objects’ methods on the server side without returning any text.
short—Primitive data type for a 16-bit, signed integer value.
signature—See method signature.
stack—A pool of memory within the Java virtual machine where parameter values and local variables created during method calls are stored.
static—Keyword indicating that a variable is to be shared among all instances of a class.
strictfp—Indicates that a method or class must be run with exact IEEE 754 semantics.
subclass—A class which inherits from, or extends, a given class.
super—Keyword that indicates that a method should invoke an overridden method in a superclass.
superclass—A class from which a subclass inherits state and behavior.
Swing—Term for the javax.swing package and its sub-packages. Swing includes code for creating user interfaces, handling user-generated events, handling and printing images, and other user interface functions.
switch—A statement that allows one of several blocks of code to be executed based on an expression value matching with a case within the switch statement.
synchronized—Keyword that indicates that a method or block of code is not allowed to execute simultaneously within multiple threads.
this—Keyword indicating the current instance of a class.
thread—A separate, concurrent path of program execution within the virtual machine.
throw—Statement that causes an exception to be thrown up the call stack.
throws—Keyword in a method declaration that indicates the exceptions the method may throw.
transient—Keyword indicating that an instance or class variable is not to be saved when an object is serialized.
try—Statement used in conjunction with a catch block that indicates a block of code and its associated error handling code.
virtual machine—The platform-independent environment in which Java programs execute. It simulates the resources and services available on a physical computer. The virtual machine executes platform-independent bytecode instructions, rather than machine-specific instructions.
VM—See virtual machine.
void—Keyword indicating that a method does not return any value.
volatile—Insures that, when accessing a variable with multiple threads, any cached copies of that variable in a separately-executing thread are updated with the original instance.
while—Statement that indicates the end of a do-while loop, or the beginning of a while loop, which includes a boolean test for continued loop execution.