Appendix A. An Agile Java GlossaryThis appendix lists key terms. Most terms that appear in the text of Agile Java in italicized form appear here. Each definition is brief but should provide you with a good idea what a given term means. Refer to the index in order to locate occurrences of the term within Agile Java. The context should provide you with a more robust understanding of a specific term. - abstract
representing concepts as opposed to concrete, specific details
- acceptance test
a test that demonstrates functional behavior; also known as a functional test or customer test
- access modifier
a keyword that identifies the level of exposure of a Java element to other code
- action method
a method that effects an action, usually altering the state of an object
- activation
a UML construct that represents the lifetime of a method in a sequence diagram
- actual value
in an assertEquals statement, the expression or value that you are testing. The actual value immediately follows the expected value.
- agile
a term for a body of lightweight processes; an agile process centers around the idea that requirements will change as a project progresses
- annotation
a construct that allows you to embed descriptive information for Java elements in source code. An annotation is verified against an interface specification by the compiler.
- anonymous inner class
an unnamed class that is dynamically defined within a method body
- API
application programming interface
- application
a computer-based system that provides value to humans or other systems
- application programming interface
the published specification for other classes with which your code can interact
- argument
an element that is passed to a method. Informal use of the term can indicate either one of the list of actual arguments passed in a method call or the formal parameters listed in the method's signature
- argument list
the list of values or references passed to a method
- array initializer
an initialization construct that allows provision of a set of initial values for elements in an array
- assignment
the act of storing the result of an expression in a field or variable
- assignment operator
the equals sign (=); used as part of an assignment
- atomic
an operation that executes as a single indivisible unit
- attribute
a general object-oriented term for a characteristic of an object. You define attributes on a class.
- autoboxing
automatically enclosing a primitive with its corresponding wrapper type
- autounboxing
automatically extracting a primitive from its corresponding wrapper type
- bind
to supply a type for a parameterized class
- boolean
a type that represents two possible values: true and false
- bound
having supplied a type for a parameterized class
- block
(n.) a section of code enclosed between braces; (v.) to wait until some other operation has completed
- border
a buffer area between the edges of a container and any of its components
- byte codes
the programming operations and other relevant information contained in a class file
- callback
the technique of passing a function as a parameter so that the receiver can message to it
- camel case
the mixed-case naming scheme preferred for Java identifiers
- cast
to tell the compiler that you want to convert the type of a reference; to narrow a numeric value to a smaller type
- catch
to trap a thrown exception
- checked exception
an exception that your code must explicitly acknowledge
- checked wrapper
a collection wrapper that ensures that objects stored in the collection are of the appropriate type
- class
a template for creating objects; a class defines behavior and attributes
- class constant
a reference to a fixed value that can be accessed irrespective of creating object instances
- class diagram
a UML model that shows class detail and the static relationship between classes
- class file
a file containing code that has been compiled from source code
- class library
a collection of useful classes provided by a vendor or another developer as an API
- class literal
a value that represents the sole instance of a class
- class loader
code that dynamically reads a stream of bytes representing a Java compilation unit from some source location and converts it to a usable class
- class variable
a variable defined on a class that can be accessed without using an instance of the class
- classpath
a list of directories or JAR files that Java uses for compilation and execution
- client
a class, or code in general, that interacts with a specific target class. The target class may be referred to as a server class.
- clone
to create a copy of an object
- close
to design a class so that it needs no further modification despite future changes
- coding
the act of writing programs
- collective code ownership
a team philosophy that allows anyone to modify any portion of the system
- collision
when two elements hash to the same location in a hash table
- compiler
an application that transforms source code into a binary form that a platform can understand and execute
- command object
an object that captures information in order to be able to effect specific behavior at a later time
- comment
a free-form annotation of code that is ignored by the compiler
- complex annotation
an annotation that includes another annotation
- compound assignment
a shortcut form of assignment that presumes that the variable being assigned to is also the target of the first operation in the right-hand expression
- composition
an association between classes whereby objects of one class are composed of objects of another class
- concatenate
append
- connection pool
a group of shared database connections
- constructor
a block of code that allows you to provide statements to initialize an object. Invoking a constructor using the new operator results in the creation of an object.
- constructor chaining
calling one constructor from another
- container
a component that can contain other components
- controller
a class responsible for managing input from the end user
- cooperative multitasking
a multithreading scheme in which the individual threads are responsible for yielding time to allow other threads to execute
- couple
to increase dependencies between classes
- covariance
the ability for a subclass to vary the return type of an overridden method
- critical section
- See [mutual exclusion]
- customer test
- See [acceptance test]
- daemon thread
a secondary thread; an application can terminate regardless of whether or not daemon threads are active
- declaration
the point at which something is defined
- decouple
to minimize dependencies between classes
- decrement
to subtract (usually one) from a value
- decrement operator
--. A unary operator that subtracts 1 from the operand
- default package
the unnamed package; classes that are defined without a package statement end up in the default package
- dependency
a relationship between two classes (or any two entities) where one requires the existence of the other
- dependency inversion
designing class associations so that classes are dependent upon abstractions instead of concrete implementations
- deprecated
Java code intended for eventual removal from a class library
- dereference
to navigate to a memory location based on the memory address stored in a reference
- derived class
- See [subclass]
- deserialize
to "reconstitute" an object from a sequence of bytes
- design by contract
a design technique that requires programmers to create a contract for how their software is expected to behave. and - See also [precondition]
- See also [postcondition]
- See also [invariant]
- driver
with respect to JDBC, an API that meets Sun's specification for interfacing with a database
- dynamic proxy class
a class that allows you to implement one or more interfaces at runtime
- element
a Java construct that an annotation can possibly annotate: a class, enum, interface, method, field, parameter, constructor, or local variable
- encapsulation
hiding implementation specifics from clients; a core object-oriented concept
- erasure
the scheme chosen by Sun to implement parameterized types; it refers to the fact that parameterized type information is erased to its upper bounds
- escape sequence
a sequence of characters within a String or character literal that maps to a single character. An escape sequence begins with the character \. Escape sequences allow you to represent characters that you may not be able to type directly.
- exception
an object that encapsulates error information
- expected value
in an assertEquals statement, the value you expect to receive when comparing to an actual result. The expected value immediately precedes the actual value.
- factory method
a method responsible for constructing and returning objects
- field
the Java implementation of an attribute. A field minimally specifies a type and name for a characteristic of a class
- field initializer
a code expression used to provide an initial value for a field or local variable
- formal parameter
a named argument listed in a method or constructor signature
- format elements
substitution parameters in a resource defined in a resource bundle
- format specifier
a placeholder for substitution values within a format string; defines the transformation from value to output string
- frame
a top-level window
- fully qualified
indicates that a class name contains its complete package information
- garbage collection
the VM process of reclaiming memory that is no longer needed
- garbage collector
the code that is responsible for garbage collection
- generic method
a method that can be parameterized with one or more type parameters
- generics
parameterized types
- global
available to any interested client
- guard clause
a code construct that defines an early return from a method in the event of an exceptional condition
- hacking
informal: creating software with abandon. Originally, hacking was a positive term; modern use of the term (including its use in Agile Java) is usually pejorative
- hash code
an integer generated by a hashing algorithm that is used as the key for locating elements in a hash table
- hash table
a fixed-size collection that determines the location of its elements using a hash code
- heavyweight
refers to a process that emphasizes written, up-front documentation and discourages deviation from an initial plan
- i18n
Internationalization
- identifier
the name given to a Java element, such as a field, method, or class
- immutable
unchangeable. A class is immutable if its attributes cannot be altered. An immutable object is also known as a value object
- implement
to provide code details. When you implement an interface, you supply concrete definitions for the methods it declares
- increment
to add (usually 1) to a value
- increment operator ++.
A unary operator that adds 1 to the operand
- inherit
to extend from a base class
- inheritance
a relationship between two classes where one class (known as the subclass or derived class) specializes the behavior of another class (known as the superclass or base class)
- initial value
the value that a field or local variable has at the time of declaration
- inline
to embed previously externalized code into a method body; i.e., to eliminate the need for a method call by moving the target method's code into the calling method
- instance variable
- See [field]
- instantiate
to create an object
- interface
general: the point of communication between two things, such as two systems or two classes; Java: a construct that allows you to define method specifications, but no implementation details
- interface adapter class
a class that transforms an externally defined interface into one that is more useful in the context of the current system
- internationalize
to code a system such that it can supports deployment to different localities
- interpreter
an application that reads and executes compiled code; - See also [virtual machine]
- invariant
an assertion that must always hold true while executing code; - See also [design by contract]
- invert
to turn upside-down; used in the context of dependency inversion
- jagged array
an array of arrays where each subarray can vary in size
- JAR
Java ARchive
- Java archive
a class container; implemented using the ZIP file format
- layout
the arrangement of components in a user interface
- layout manager
a class that can aid in arranging components in a user interface
- lazy initialization
a programming technique whereby you do not provide an initial value for a field until it is used for the first time
- lightweight
refers to a process that emphasizes adaptation over adherence to plan
- linked list
a serial data structure that adds new elements by dynamically allocating memory. Elements of a linked list must refer to other elements by storing one or more references to them.
- local variable
a variable defined within the body of a method
- locale
a region that is defined by perhaps geography, culture, or politics
- localize
to prepare an internationalized application for delivery to a locale
- log
to record
- logical operator
an operator that returns a boolean value
- lower bound
a constraint that requires a wildcard to be a supertype of the specified class
- marker annotation
an annotation that provides no arguments
- marker interface
an interface with no method declarations; allows programmers to signal intent for a class
- member
a constructor, field, or method defined on the instance side of a class
- member-value pair
a key and corresponding value supplied in an annotation
- memory equivalence
when two object references are equali.e., they point to the same object in memory
- metadata
data about data
- method
a unit of code that helps define the behavior of a class. A return type, name, and argument list uniquely define a method. A method consists of a number of statements
- methodology
a process for building software
- mnemonic
a single-letter shortcut for activating a button
- mock object
an object used for creating context to aid in verifying assertions against target code. Loosely used, a mock is any object that substitutes for production code to aid in testing
- model
a class that contains application or business logic
- modulus
an operator that returns the remainder of a division operation
- multiline comment
a comment that can span multiple source lines; you start a multiline comment with /* and end it with */
- multithreaded
having the ability to execute certain code sections at the same time as other sections
- mutual exclusion
a form of synchronization in which a section of code has exclusive attention from the Java VM while it executes
- naked type variable
a use of a type parameter symbol within a type declaration
- namespace
a namespace implies the ability to define unique names, such that entities with the same base name do not clash with one another. In Java, this is accomplished through the use of package names
- nested
embedded within
- nested class
a class defined within another class
- nondeterministic
having the potential to return different results each time when given the same inputs and initial state
- numeric literal
a code instance of a number, such as an integer or a floating-point number
- object
an entity that has identity, type, and state; objects are created from classes
- object-oriented
based on the concepts of classes and objects
- operator
a special token or keyword recognized by the compiler. An operator takes action against one or more values or expressions
- overload
to supply multiple definitions for a method or constructor. You vary the definitions by their argument list (or possibly their return value;) - See also [covariance]
- overloaded operator
an operator that has different meanings depending on the context in which it is used
- override
to provide a replacement definition for a method already defined in a superclass
- package
an arbitrary collection of classes, defined either for deployment or organizational purposes
- package import
a form of the import statement that indicates that any of the classes in the specified package might be used in the class
- package structure
the current state of package organization
- pair programming
a development technique in which two developers actively program at a single workstation
- parameter
informally, another name for an argument
- parameterized type
a class to which you can bind one or more classes; doing so supplies additional constraints on the types of object that the class can interact with
- persistent
existing from application execution to execution
- platform
an underlying system on which applications can be run
- polymorphism
the ability of objects to supply variant behaviors, in response to a message, based on their type. Seen from the opposite direction, the ability of clients to send a message to an object without an awareness or concern for which object actually receives the message
- postcondition
an assertion that must hold true after executing code; - See also [design by contract]
- postfix operator
a unary operator that appears after the target it operates on
- precondition
an assertion that must hold true prior to executing code; - See also [design by contract]
- preemptive multitasking
a multithreading scheme in which the operating system (or virtual machine) is responsible for interrupting and scheduling threads
- prefix operator
a unary operator that appears before the target it operates on
- primitive type
non-object types in Java. Numeric types and the boolean type are primitive types
- process framework
a foundation for creating and customizing a process tailored to your needs
- process instance
a specific customization of a process framework
- program
the body of code that comprises an application; often used interchangeably with the term "application"
- programmer test
- See [unit test]
- programming
- See [coding]
- programming by intention
a programming technique whereby you first specify your intent for a solution (i.e., the general steps involved) before implementing it (i.e., providing the detailed code)
- project
the related things that make up an effort
- proxy
a stand-in. A proxy object is an object that might filter or control access to the object it stands in for. To a client, a proxy is indistinguishable from the real thing
- public interface
the methods of a class that are exposed to any other client class
- query method
a method that returns information to a client but does not alter the state of the object
- queue
a serial data structure that returns the eldest object when a client requests an object from it Also known as a first-in-first-out (FIFO) data structure
- random access file
a logical interpretation of a file that allows you to quickly seek to specific positions in the file and read from or write to that position
- raw type
an unbound parameterized type
- realizes
implements
- receiver
the object to which a message is sent, directly or indirectly, as the result of a method call
- recursive
calling oneself; sending a message to the same method that is currently executing
- refactor
to transform code; by definition, refactoring should not change the behavior of code
- refactoring
(n.) a code transformation; (v.) the act of applying transforms to code
- reference
a memory address; a variable that points to an object
- reflective
of or dealing with reflection
- reflection
the capability in Java that allows you to dynamically derive information about types and their definitions at runtime
- regression test
a test that ensures that the existing application still works after changes have been applied
- regular expression
a set of syntactical elements and symbols that is used to match text
- resource bundle
a collection of resources such as message strings; allows an application to dynamically load said resources by name. A resource bundle is usually an external file.
- rethrow
to catch and subsequently throw the same or another exception object
- return type
indicates the class of object that a method must provide to the caller
- runtime
refers to the scope of execution of a program; i.e., when it is running
- sandbox
a customizable virtual Java place that defines boundaries for security purposes
- scale
the number of digits to the right of the decimal point in a decimal number
- scope
the lifetime of an object or variable; the sphere of influence it has
- seed
a number used as the basis for determining a pseudorandom number sequence
- semantic equality
when two objects are considered the same based on arbitrary criteria as supplied by a programmer. In Java, you use the equals method to define semantic equality
- serializable
a class whose objects can be serialized; arbitrarily designated by a programmer
- serialize
to convert an object to a sequence of bytes
- server
a class or group of classes that provides a service to clients
- singleton
a class that is coded to disallow creation of more than one instance of itself
- signature
the information that uniquely identifies a method: its return type, name, and list of argument types
- simple design
an approach to design that values testing, elimination of duplication, and code expressiveness. Simple design rules result in positive emergent behavior in code.
- single-line comment
a comment that begins with //; an end-of-line character terminates the comment
- software development kit
a bundle of applications and utilities designed to help developers build and execute custom applications
- source file
a file containing code as typed by a programmer
- spurious wakeup
an unexpected activation of an idling thread
- stack trace
the execution summary that an exception generates. A stack trace shows, in reverse order, the chain of message sends leading up to a problem
- stack walkback
- See [stack trace]
- state
a snapshot of what an object looks like at a current point in time, represented by the values in its attributes
- statement
a line of Java code, terminated by a semicolon
- static import
an import form that allows you to use class methods or variables defined in a different class as if they were defined locally
- static initialization block
a block of code that executes when a class is first loaded by the VM
- static method
a method you can invoke without first instantiating the class on which it is defined
- static scope
having existence for the lifetime of a class
- story
an informally stated requirement; a promise of further conversation
- strategy
an algorithm; a variant way of accomplishing a task
- stream
a sequence of data that you can write to or read from
- string literal
a code instance of a String object, represented by text enclosed in double quotation marks
- strongly typed
a characteristic of a programming language whereby variables and constants must be associated with a specific data type
- subclass
the specialized class in an inheritance relationship
- subscript
an index representing a position within an array
- suite
a collection of unit tests
- synchronization
the coordination of simultaneously executing threads to avoid data contention
- target
the subject of desire; the object being operated on; in Ant, a process you want to execute
- TDTT
test-driven truth table
- temp variable
- See [local variable]
- temporary variable
- See [local variable]
- ternary operator
an operator that allows you to represent an if-else statement as an expression
- test-driven
designed by virtue of programming specification tests prior to coding the corresponding implementation
- test-driven truth table (TDTT)
a series of assertions to demonstrate the results for all possible combinations of bitwise and logical operators
- token
an individual text component delineated by specially designated text characters
- tolerance
the acceptable margin of error when comparing two floating-point quantities
- thread
a Java unit of execution. A Java process may contain multiple threads, each of which can be executing simultaneously with the others
- thread pool
a group of reusable threads
- throw
to generate an exception; a transfer control mechanism
- trace statements
code inserted in your application to allow you to monitor its behavior as it executes
- two's complement
an scheme used for internal representation of negative integers. To obtain the two's complement representation of a number, take its positive binary representation, invert all binary digits, and add 1
- type parameter list
in a parameterized type, the list of arguments that you must bind to
- uncaught exception handler
a hook that allows you to trap executions thrown from a thread
- upper camel case
a Java identifier naming scheme; camel case in which the first letter of the identifier is upper case
- unary operator
an operator that has a single target
- unchecked exception
an exception that does not require code to explicitly acknowledge it
- unit test
a body of code that verifies the behavior of a target class (i.e., a unit); also known as a programmer test
- upper bound
the constraint attached to a type parameter
- user interface
the means with which a human interacts with an application
- user thread
the main thread in an executing application; the existence of an active user thread sustains application execution
- varargs
a variable number of arguments
- view
a class responsible for displaying things to an end user
- VM
virtual machine
- virtual machine
an application that executes and manages custom programs. A virtual machine interacts with an underlying operating system as necessary; also referred to as an interpreter
- walkback
- See [stack trace]
- weak reference
a reference that does not count for purposes of garbage collection
- whitespace
space, tab, new line, form feed, and carriage return characters (collectively)
- wildcard
a substitution character (?) in a type argument (for a parameterized type) that represents any possible type
- wrapper
an object that contains another object or value. In Java, wrapper objects are used to contain primitives so that they can be used as objects
|