Java abstract keyword: “The Java abstract keyword is used to declare Java abstract methods and Java classes. An abstract method has no implementation defined; it is declared with Java arguments and a Java return type as usual, but the body enclosed in curly braces is replaced with a semicolon. The implementation of a Java abstract method is provided by a Java subclass of the Java class in which it is defined. If an abstract method appears in a class, the class is also abstract. Attempting to instantiate an abstract class will fail at compile time.” (LerJav)
Metadata added to Java source code using the @ tag syntax. Annotations can be used by the compiler or at runtime to augment classes, provide data or mappings, or flag additional services.
An older, XML-based build tool for Java applications. Ant builds can compile, package, and deploy Java source code as well as generate documentation and perform other activities through pluggable “targets.”
Application Programming Interface (API)
An API consists of the methods and variables programmers use to work with a component or tool in their applications. The Java language APIs consist of the classes and methods of the java.lang, java.util, java.io, java.text, java.net packages and many others.
A Java program that runs standalone, as compared with an applet.
Annotation Processing Tool (APT)
A frontend for the Java compiler that processes annotations via a pluggable factory architecture, allowing users to implement custom compile-time annotations.
A language feature used to test for conditions that should be guaranteed by program logic. If a condition checked by an assertion is found to be false, a fatal error is thrown. For added performance, assertions can be disabled when an application is deployed.
Discrete or transactional in the sense that an operation happens as a unit, in an all-or-nothing fashion. Certain operations in the Java virtual machine (VM) and provided by the Java concurrency API are atomic.
Abstract Window Toolkit (AWT)
Java’s original platform-independent windowing, graphics, and UI toolkit.
The mystical, spectral, alter ego of a Snark. From the 1876 Lewis Carroll poem “The Hunting of the Snark.”
A primitive Java data type that contains a true or false value.
In Java generics, a limitation on the type of a type parameter. An upper bound specifies that a type must extend (or is assignable to) a specific Java class. A lower bound is used to indicate that a type must be a supertype of (or is assignable from) the specified type.
Wrapping of primitive types in Java by their object wrapper types. See also unboxing.
A primitive Java data type that’s an 8-bit two’s-complement signed number.
A behavior that is defined by one object and then later invoked by another object when a particular event occurs. The Java event mechanism is a kind of callback.
The changing of the apparent type of a Java object from one type to another, specified type. Java casts are checked both statically by the Java compiler and at runtime.
The Java catch statement introduces an exception-handling block of code following a try statement. The catch keyword is followed by one or more exception type and argument name pairs in parentheses and a block of code within curly braces.
An electronic document using a digital signature to assert the identity of a person, group, or organization. Certificates attest to the identity of a person or group and contain that organization’s public key. A certificate is signed by a certificate authority with its digital signature.
certificate authority (CA)
An organization that is entrusted to issue certificates, taking whatever steps are necessary to verify the real-world identity for which it is issuing the certificate.
A primitive Java data type; a variable of type char holds a single 16-bit Unicode character.
The fundamental unit that defines an object in most object-oriented programming languages. A class is an encapsulated collection of variables and methods that may have privileged access to one another. Usually a class can be instantiated to produce an object that’s an instance of the class, with its own unique set of data.
The class keyword is used to declare a class, thereby defining a new object type.
An instance of the class java.lang.ClassLoader, which is responsible for loading Java binary classes into the Java VM. Classloaders help partition classes based on their source for both structural and security purposes and can also be chained in a parent-child hierarchy.
See static method.
The sequence of path locations specifying directories and archive files containing compiled Java class files and resources, which are searched in order to find components of a Java application.
See static variable.
The consumer of a resource or the party that initiates a conversation in the case of a networked client/server application. See also server.
Classes in the core java.util package for working with and sorting structured collections or maps of items. This API includes the Vector and Hashtable classes as well as newer items such as List, Map, and Queue.
The unit of source code for a Java class. A compilation unit normally contains a single class definition and in most current development environments is simply a file with a .java extension.
A program that translates source code into executable code.
A methodology for building parts of an application. It is a way to build reusable objects that can be easily assembled to form applications.
Combining existing objects to create another, more complex object. When you compose a new object, you create complex behavior by delegating tasks to the internal objects. Composition is different from inheritance, which defines a new object by changing or refining the behavior of an old object. See also inheritance.
A special method that is invoked automatically when a new instance of a class is created. Constructors are used to initialize the variables of the newly created object. The constructor method has the same name as the class and no explicit return value.
A class that is called to parse a particular type of data and convert it to an appropriate object.
A packet of data normally sent using a connectionless protocol such as UDP, which provides no guarantees about delivery or error checking and provides no control information.
A duplicate of an object along with all of the objects that it references, transitively. A deep copy duplicates the entire “graph” of objects, instead of just duplicating references. See also shallow copy.
Document Object Model (DOM)
An in-memory representation of a fully parsed XML document using objects with names like Element, Attribute, and Text. The Java XML DOM API binding is standardized by the World Wide Web Consortium (W3C).
A Java primitive data type; a double value is a 64-bit (double-precision) floating-point number in IEEE-754 (binary64) binary format.
Document Type Definition (DTD)
A document containing specialized language that expresses constraints on the structure of XML tags and tag attributes. DTDs are used to validate an XML document, and can constrain the order and nesting of tags as well as the allowed values of attributes.
Enterprise JavaBeans (EJBs)
A server-side business component architecture named for, but not significantly related to, the JavaBeans component architecture. EJBs represent business services and database components, and provide declarative security and transactions.
The object-oriented programming technique of limiting the exposure of variables and methods to simplify the API of a class or package. Using the private and protected keywords, a programmer can limit the exposure of internal (“black box”) parts of a class. Encapsulation reduces bugs and promotes reusability and modularity of classes. This technique is also known as data hiding.
The Java keyword for declaring an enumerated type. An enum holds a list of constant object identifiers that can be used as a type-safe alternative to numeric constants that serve as identifiers or labels.
The implementation technique used by Java generics in which generic type information is removed (erased) and distilled to raw Java types at compilation. Erasure provides backward compatibility with nongeneric Java code, but introduces some difficulties in the language.
A user’s action, such as a mouse-click or keypress.
The Java object delivered to a registered event listener in response to a user action or other activity in the system.
A signal that some unexpected condition has occurred in the program. In Java, exceptions are objects that are subclasses of Exception or Error (which themselves are subclasses of Throwable). Exceptions in Java are “raised” with the throw keyword and handled with the catch keyword. See also catch, throw, and throws.
The design pattern of catching an exception and throwing a new, higher-level, or more appropriate exception that contains the underlying exception as its cause. The “cause” exception can be retrieved if necessary.
A keyword used in a class declaration to specify the superclass of the class being defined. The class being defined has access to all the public and protected variables and methods of the superclass (or, if the class being defined is in the same package, it has access to all nonprivate variables and methods). If a class definition omits the extends clause, its superclass is taken to be java.lang.Object.
A keyword modifier that may be applied to classes, methods, and variables. It has a similar, but not identical, meaning in each case. When final is applied to a class, it means that the class may never be subclassed. java.lang.System is an example of a final class. A final method cannot be overridden in a subclass. When final is applied to a variable, the variable is a constant — that is, it can’t be modified. (The contents of a mutable object can still be changed; the final variable always points to the same object.)
A reserved method name. The finalize() method is called by the Java VM when an object is no longer being used (i.e., when there are no further references to it) but before the object’s memory is actually reclaimed by the system. Largely disfavored in light of newer approaches such as the Closeable interface and try-with-resources.
A keyword that introduces the finally block of a try/catch/finally construct. catch and finally blocks provide exception handling and routine cleanup for code in a try block. The finally block is optional and appears after the try block, and after zero or more catch blocks. The code in a finally block is executed once, regardless of how the code in the try block executes. In normal execution, control reaches the end of the try block and proceeds to the finally block, which generally performs any necessary cleanup.
A Java primitive data type; a float value is a 32-bit (single-precision) floating-point number represented in IEEE 754 format.
The process of reclaiming the memory of objects no longer in use. An object is no longer in use when there are no references to it from other objects in the system and no references in any local variables on any thread’s method call stack.
The syntax and implementation of parameterized types in the Java language, added in Java 5.0. Generic types are Java classes that are parameterized by the user on one or more additional Java types to specialize the behavior of the class. Generics are sometimes referred to as templates in other languages.
A class that uses the Java generics syntax and is parameterized by one or more type variables, which represent class types to be substituted by the user of the class. Generic classes are particularly useful for container objects and collections that can be specialized to operate on a specific type of element.
A method that uses the Java generics syntax and has one or more arguments or return types that refer to type variables representing the actual type of data element the method will use. The Java compiler can often infer the types of the type variables from the usage context of the method.
A drawable surface represented by the java.awt.Graphics class. A graphics context contains contextual information about the drawing area and provides methods for performing drawing operations in it.
graphical user interface (GUI)
A traditional, visual user interface consisting of a window containing graphical items such as buttons, text fields, pull-down menus, dialog boxes, and other standard interface components.
A random-looking identifying number, based on the data content of an object, used as a kind of signature for the object. A hashcode is used to store an object in a hash table (or hash map). See also hash table.
An object that is like a dictionary or an associative array. A hash table stores and retrieves elements using key values called hashcodes. See also hashcode.
The human-readable name given to an individual computer attached to the internet.
Hypertext Transfer Protocol (HTTP)
The protocol used by web browsers or other clients to talk to web servers. The simplest form of the protocol uses the commands GET to request a file and POST to send data.
Integrated Development Environment (IDE)
A GUI tool such as IntelliJ IDEA or Eclipse that provides source editing, compiling, running, debugging, and deployment functionality for developing Java applications.
A keyword used in class declarations to indicate that the class implements the named interface or interfaces. The implements clause is optional in class declarations; if it appears, it must follow the extends clause (if any). If an implements clause appears in the declaration of a non-abstract class, every method from each specified interface must be implemented by the class or by one of its superclasses.
The import statement makes Java classes available to the current class under an abbreviated name or disambiguates classes imported in bulk by other import statements. (Java classes are always available by their fully qualified name, assuming the appropriate class file can be found relative to the CLASSPATH environment variable and that the class file is readable. import doesn’t make the class available; it just saves typing and makes your code more legible.) Any number of import statements may appear in a Java program. They must appear, however, after the optional package statement at the top of the file, and before the first class or interface definition in the file.
An important feature of object-oriented programming that involves defining a new object by changing or refining the behavior of an existing object. Through inheritance, an object implicitly contains all of the non-private variables and methods of its superclass. Java supports single inheritance of classes and multiple inheritance of interfaces.
A class definition that is nested within another class or a method. An inner class functions within the lexical scope of another class.
An occurrence of something, usually an object. When a class is instantiated to produce an object, we say the object is an instance of the class.
A non-static method of a class. Such a method is passed an implicit this reference to the object that invoked it. See also static, static method.
A Java operator that returns true if the object on its left side is an instance of the class (or implements the interface) specified on its right side. instanceof returns false if the object isn’t an instance of the specified class or doesn’t implement the specified interface. It also returns false if the specified object is null.
A non-static variable of a class. Each instance of a class has an independent copy of all of the instance variables of the class. See also class variable, static.
A primitive Java data type that’s a 32-bit two’s-complement signed number.
A keyword used to declare an interface.
A collection of abstract methods that collectively define a type in the Java language. Classes implementing the methods may declare that they implement the interface type, and instances of them may be treated as that type.
The process of making an application accessible to people who speak a variety of languages. Sometimes abbreviated I18N.
The module that decodes and executes Java bytecode. Most Java bytecode is not, strictly speaking, interpreted any longer but compiled to native code dynamically by the Java VM.
The process by which a JavaBean provides additional information about itself, supplementing information learned by reflection.
An 8-bit character encoding standardized by the ISO. This encoding is also known as Latin-1 and contains characters from the Latin alphabet suitable for English and most languages of western Europe.
A component architecture for Java. It is a way to build interoperable Java objects that can be manipulated easily in a visual application builder environment.
Java classes that are built following the JavaBeans design patterns and conventions.
A language developed early in the history of the web by Netscape for creating dynamic web pages. From a programmer’s point of view, it’s unrelated to Java, although some of its syntax is similar.
Java API for XML Binding (JAXB)
A Java API that allows for generation of Java classes from XML DTD or Schema descriptions and the generation of XML from Java classes.
Java API for XML Parsers (JAXP)
The Java API that allows for pluggable implementations of XML and XSL engines. This API provides an implementation-neutral way to construct parsers and transforms.
The Java API for XML Remote Procedure Calls, used by web services.
Java Database Connectivity (JDBC)
The standard Java API for talking to an SQL (Structured Query Language) database.
A native Java XML DOM created by Jason Hunter and Brett McLaughlin. JDOM is easier to use than the standard DOM API for Java. It uses the Java Collections API and standard Java conventions. Available at the JDOM Project site.
Java Web Services Developer Pack (JDSDP)
A bundle of standard extension APIs packaged as a group with an installer from Sun. The JWSDP includes JAXB, JAX-RPC, and other XML and web services-related packages.
lambda (or lambda expression)
A compact way to put the entire definition of a small, anonymous function right where you are using it in the code.
A nickname for ISO 8859-1.
An object that controls the arrangement of components within the display area of a Swing or AWT container.
A pure Java GUI component that has no native peer in the AWT.
A variable that is declared inside a method. A local variable can be seen only by code within that method.
The Java API for structured logging and reporting of messages from within application components. The Logging API supports logging levels indicating the importance of messages, as well as filtering and output capabilities.
A primitive Java data type that’s a 64-bit two’s-complement signed number.
A cryptographically computed number based on the content of a message, used to determine whether the message’s contents have been changed in any way. A change to a message’s contents will change its message digest. When implemented properly, it is almost impossible to create two similar messages with the same digest.
The object-oriented programming term for a function or procedure.
Provides definitions of more than one method with the same name but with different argument lists. When an overloaded method is called, the compiler determines which one is intended by examining the supplied argument types.
Defines a method that matches the name and argument types of a method defined in a superclass. When an overridden method is invoked, the interpreter uses dynamic method lookup to determine which method definition is applicable to the current object. Beginning in Java 5.0, overridden methods can have different return types, with restrictions.
MIME (or MIME type)
A media type classification system often associated with email attachments or web page content.
Model-View-Controller (MVC) framework
A UI design that originated in Smalltalk. In MVC, the data for a display item is called the model. A view displays a particular representation of the model, and a controller provides user interaction with both. Java incorporates many MVC concepts.
A keyword placed before a class, variable, or method that alters the item’s accessibility, behavior, or semantics. See also abstract, final, native method, private, protected, public, static, synchronized.
This is a special value of the double and float data types that represents an undefined result of a mathematical operation, such as zero divided by zero.
A method that is implemented in a native language on a host platform, rather than being implemented in Java. Native methods provide access to such resources as the network, the windowing system, and the host filesystem.
A unary operator that creates a new object or array (or raises an OutOfMemoryException if there is not enough memory available).
The Java “new” I/O package. A core package introduced in Java 1.4 to support asynchronous, interruptible, and scalable I/O operations. The NIO API supports nonthreadbound “select” style I/O handling.
null is a special value that indicates that a reference-type variable doesn’t refer to any object instance. Static and instance variables of classes default to the value null if not otherwise assigned.
The fundamental structural unit of an object-oriented programming language, encapsulating a set of data and behavior that operates on that data.
An instance of a class, having the structure of the class but its own copy of data elements. See also instance.