About...
©1999 Osmar R. Zaïane
(zaiane@cs.ualberta.ca)
Glossary for Structural Programming and Data Structures
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z |
|---|
abstract class - A class that contains at least one abstract method. (Chapter 13)
abstract method - A method declared but not implemented by a superclass. It is the responsibility of a subclass to implement the method. (Chapter 13)
Abstract Window Toolkit - A collection of Java classes that allows the programmer to create graphical user interfaces. (Chapter 3 GUI Supplement)
access control - The ability to allow or prevent access to a method or variable. (Chapter 4)
accumulator - A variable that holds a partial sum or product or the analog for another binary operation besides + or *. (Chapter 9)
activation record - A block of memory holding the parameters and local variables of a method, along with the return address of the invoker of the method. (Chapter 11)
adapter class - A class introduced to facilitate the implementation of an event listener. (Chapter 13 GUI Supplement)
all-paths testing - An approach to testing in which every possible sequence of statements is tested at least once. (Chapter 7)
applet life cycle - The phases an applet goes through from being initially loaded through its execution and subsequent termination. (Chapter 4 GUI Supplement)
argument - Information provided in a message in addition to the method-name and ultimately made available to the method via a parameter; one of the two ways that methods get needed information. (Chapters 2,4)
array - A programming language feature that provides an indexed collection of data values. (Chapter 10)
assignment - The association of a value with a variable. (Chapter 2)
automatic testing - An approach to testing in which the test suite verifies the correctness of the test results. (Chapter 7)
AWT - See Abstract Window Toolkit. (Chapter 3 GUI Supplement)
behavior - Any action that an object may take in response to a message. Similarly, any action that the object may take; any change it may undergo or any characteristic it may reveal. (Chapters 1, 2)
behavior - Any action that the object may take, any change it undergo, or any characteristic it may reveal as a result of a method invoked. (Chapter 4) binary search - An algorithm for efficiently searching a sorted collection by repeatedly dividing the region where the item might be found in half and reducing consideration to one half or the other. (Chapter 10)
boolean - A primitive data type modeling true and false values. (Chapter 6)
boolean expression - An expression evaluating to a boolean value. (Chapter 6) 5
break statement - A statement that forces immediate termination of a loop. (Chapter 9)
buffer - A place to store information temporarily, prior to further process- ing. (Chapter 3)
bug - A run-time error in a program. (Chapter 7)
cascaded if/else - a sequence of if/else statements in which the else por- tion of one if statement consists of another if statement. (Chapter 6)
cascading - A technique in which the result of one method invocation is used as the receiver of a second method invocation. (Chapter 2)
character - A distinct elementary symbol, often corresponding to a single keyboard keystroke; letters, digits, punctuation marks, space, and tab are all examples of characters. (Chapter 1)
character generator - A portion of the display hardware responsible for the display of characters in text mode. (Chapter 5 GUI Supplement)
checked Exception - An Exception that, if possibly thrown by a method, must appear in the methods throws clause; so-called because the Java compiler checks for its presence in the clause. (Chapter 14)
class - A category of objects that share the same behavior. (Chapter 1)
class method - A method that is not associated with any particular object of a class but rather with the class itself. As a result, it can be invoked without reference to an object. Such a method is also called a static method. (Chapter 4)
client-server model - A program design approach in which one program, the server, provides a service to another program, the client, which is requesting that service. (Chapter 14 Net Supplement)
code - A section of text written in some programming language such as Java. (Chapter 1)
collection - A class or language construct that manages one or more objects. (Chapter 8)
command name - Text associated with an action event. (Chapter 13 GUI Supplement)
compiler - A program that translates code written in a high-level programming language into machine language. (Chapter 1)
composition - A technique in which the result of one method invocation is used as an argument in a second method invocation. (Chapter 2)
composition - A technique in which a class is defined using instance variables that are references to objects of other classes. (Chapter 13)
compound condition - A condition (boolean expression) containing one or more logical operators. (Chapter 6)
compound statement - One or more statements surrounded by braces that are thereby treated as a single statement. (Chapter 6)
computer network - A collection of computers, connected by wires, that can exchange data with each other. (Chapter 3)
concurrent threads - Two or more threads running at the same time or in an interweaved fashion. (Chapter 9 GUI Supplement)
conditional - A statement that allows selective execution of code depending upon some true or false condition. (Chapter 6)
constant - A variable whose value may not be changed after initialization. (Chapter 5)
constructor - A method that is invoked when an object is created. The name of the constructor method is the same as the corresponding class name. The purpose of the constructor is to guarantee a reasonable and consistent state at the time of object creation. (Chapters 3,4)
container - A graphic component, such as an apples, that can contain other graphic components. (Chapter 4 GUI Supplement)
continue statement - A statement that forces Java to skip the remainder of the loop body in the current iteration. (Chapter 9)
coordinates - The horizontal (x) and vertical (y) position of a pixel on a 4 graphic mode display. (Chapter 5 GUI Supplement)
counter - A variable that keeps count of something else. (Chapter 9)
counting loop - A loop whose termination is based on executing a certain number of times. (Chapter 9)
current activation record - The most recently allocated activation record, which corresponds to the currently executing method. (Chapter 11)
dangling else - A problem occurring in a nested if statement, in which the single else is associated with the wrong if. (Chapter 6)
debugging - The process of finding and fixing bugs. (Chapter 7)
declaration - A Java statement which introduces a variable into a Java program. A declaration of a reference variable specifies the name (identifier) of the variable and the class of object to which it may refer. (Chapter 2)
default - A behavior or value that is used if no explicit behavior provided. (Chapter 4)
device driver - Software used to communicate with a hardware device such as the monitor or printer. (Chapter 5 GUI Supplement)
dialog box - A window whose purpose is to receive input from the user. (Chapter 13 GUI Supplement)
dimension - The number of indices required to access an element in an array. (Chapter 10)
display parameterization - A technique in which the various graphic shapes of a display are related to each other so that modifications may be easily made. (Chapter 12 GUI Supplement)
double - A primitive data type that models high precision floating-point numbers. (Chapter 5)
elements - The individual objects contained within a collection. (Chapter 8)
end user - A person who is using a program, usually not the author of the code. (Chapter 3)
enumerate - List or go through all members of a collection. (Chapter 8)
event - An action occurring within the graphical interface, such as a button click, requiring attention from the program. (Chapter 6 GUI Supplement)
event source - The component that generated an event. (Chapter 6 GUI Supplement)
event-driven programming - A style of programming, usually associated with graphical interfaces, in which an interface is created and subsequent processing occurs as a result of events generated by the interface. (Chapter 6 GUI Supplement)
every-statement testing - An approach to testing in which every statement is tested at least once. (Chapter 7)
Exception - An object that represents an unexpected circumstance or an out-of-the-ordinary situation. (Chapter 14) execute - To carry out instructions of program code. (Chapter 1)
expression - A sequence of operands and operators producing a value. (Chapter 5)
extreme - A value in a set that is no greater or no less than all the other elernints (Chapter 9)
false - The literal of type boolean representing a false value. (Chapter 6)
file - A collection of information that has a name and that can be stored on a disk of a computer system. (Chapters 1,3)
fixed-width font - A font in which all characters are the same width. (Chapter 5 GUI Supplement)
float - A primitive data type that models floating-point numbers. (Chapter 5)
floating-point - Numbers of fixed precision that are associated with measurements and are used typically in scientific and engineering applications. (Chapter 5)
flush - The forced output of characters saved in a buffer. (Chapter 3)
font - A character style in which each character reflects the theme of that style. (Chapter 5 GUI Supplement)
font metrics - Information regarding the dimensions of a font. (Chapter 5 GUI Supplement)
font style - A variation on a font-bold, plain, or italic. (Chapter 5 GUI Supplement)
frame - A window with a title bar, optional menu, and control elements to minimize, maximize, and close the window. (Chapter 13 GUI Supplement)
gaining the focus - Becoming the currently active component 13 GUI Supplement)
graphical user interface - An interface that uses graphic elements such as buttons, menus, scrollable windows, and graphical drawings to communicate with end users. (Chapter 1 GUI Supplement)
graphics mode - A mode of screen or printer display in which the screen is broken into a grid of dots, allowing the display of graphic shapes. (Chapter 5 GUI Supplement)
GUI - See graphical user interface. (Chapter 1 GUI Supplement)
GUI component - A control, such as a button, that can be placed into an applet. (Chapter 4 GUI Supplement)
has-a - A relationship between an object and some value such that the value is part of the object's state. This is usually expressed in Java by the object possessing an instance variable corresponding to the value. (Chapter 6)
header - An integer that indicates how much data follow in a set of input (Chapter 9)
heuristic - A rule used by an application to aid in the making of seemingly intelligent decision. (Chapter 12)
HTML - See HyperText Markup Language. (Chapter 2 GUI Supplement)
HTTP - See HyperText Transport Protocol. (Chapter 14 Net Supplement)
hypertext - Text with embedded links allowing the information to be read in a nonlinear manner. (Chapter 2 GUI Supplement)
HyperText Transport Protocol - The protocol used by web servers and their clients. (Chapter 14 Net Supplement)
HyperText Markup Language - The set of rules that govern the construction and use of tags on a web page. (Chapter 2 GUI Supplement)
identifier - A sequence of characters that may be used as a name in a Java program. An identifier typically consists of an alphabetic character (A-Z, a-z) followed by zero or more alphanumeric characters (A-Z, a-z, 0-9). (Chapter l)
if statement - The if statement conditionally executes a statement based upon the value of a boolean condition. The if part is executed if the condition is true, the else part, if present, is executed if the condition is false. (Chapter 6)
implement - Provide the code that realizes a design. (Chapter 4) implementation - The specific code that realizes a class. (Chapter 4)
implements - The guarantee that a class makes to implementing the methods specified in an interface. (Chapter 13)
index - An integer that denotes a position in an ordered collection. (Chapter 10)
inheritance - A technique in object-oriented languages in which one class assumes all the methods and instance variables of another class as its own. The inheriting class may also provide its own additional behavior. (Chapter 13)
initialized - Given a first value. (Chapter 4)
input - Information from outside the program that is provided to the program. (Chapter 4)
instance - A particular object of a class. (Chapter 1)
instance variable - A variable that is declared within a class but outside of any method; its purpose is to store information needed by methods to be preserved in between invocations. Each object has its own set of instance variables that have their own unique values. It is these values that distinguish one object from another. The entire set of the instance variables of an object defines its state. (Chapter 4)
int - A primitive data type modeling whole numbers (integers). (Chapter 5)
interactive - An arrangement of bidirectional and alternating data flow between user and program. (Chapter 3)
interface - An abstract class containing only abstract methods. (Chapter 13)
interleaved execution - Two or more threads alternating execution. (Chapter 9 GUI Supplement)
Internet - A rapidly growing, very widely used global network of networks. (Chapter 3)
Internet address - A String, such as www.aw.com, that identifies a machine on the Internet. (Chapter 3)
Internet Protocol - A method of communication used by the Internet, in which information is moved unreliably through intermediate machines. (Chapter 14 Net Supplement)
interpreter - A program that directly carries out the statements of a highlevel programning language. (Chapter 1)
invocation chain - The sequence of method invocations starting with main that lead to and include the invocation of the currently executing method. (Chapter 14)
IP - See Internet Protocol. (Chapter 14 Net Supplement)
is-a - The relationship between subclass and superclass. An object of a subclass is-a object of the superclass and may be used wherever an object of the superclass may be used. (Chapter 13)
iteration - The repeated execution of a section of code until some condition is satisfied. (Chapter 9)
Java - The name of one of the most recent and popular programming languages; also the one used in this text. (Chapter 1)
Java API - See Java Application Programming Interface. (Chapter 3 GUI Supplement)
Java applet - A Java program that is part of a web page and executes within a browser. (Chapter 2 GUI Supplement)
Java Application Programming Interface - A description of the classes and methods distributed with Java. (Chapter 3 GUI Supplement)
keyword - A word with a special, predefined meaning in Java language. (Chapter 1)
layout managers - A family of classes in the AWT that facilitate the placement of controls within a container component. (Chapter 4 GUI Supplement)
listener - A class that notifies a component that it wishes to be informed of events generated by that component. (Chapter 6 GUI Supplement)
literal - A value whose name is a literal representation of itself, e.g., 2. (Chapter 5)
local variable - A variable that is declared within a method; it exists only during the invocation of the method and is used as a temporary, convenient holder of information. (Chapter 4)
log2N - The number of times one can start with N and successively divide by 2 before reaching 1. The log2 is the inverse of exponentiation, with 2 as the base: if 2x is N, then log2N is x. (Chapter 10)
Logical operator - An operator that combines boolean expressions into larger boolean expressions. (Chapter 6)
long - A primitive data type modeling very large integers. (Chapter 5)
loop - A language construct that repeatedly executes a section of code. (Chapter 8)
loop condition - The condition that controls the while statement's execution (Chapter 9)
loop pattern - The code structure of a loop that is frequently used. (Chapter 8)
loop termination - The ending of a loop's execution, usually because a particular condition has become satisfied. (Chapter 9)
message - The mechanism by which a method is invoked. A message consists of a method name that identifies the behavior followed by a (possibly empty) argument list that provides further details. (Chapters 1,2)
method - A self-contained section of code belonging to a class that achieves a specific behavior for that class. A method consists of a return type, method-name, and parameter list, all of which form the method's signature, and the section of code that is called the body of the method. (Chapter 2,4)
method name - The identifier associated with a method. (Chapter 2)
modal dialog box - A dialog box, which when active prevents activity in any other window of the applet. (Chapter 13 GUI Supplement)
model - A representation of something. Models are usually simpler than the object they are representing; they only contain those aspects relevant to the user of the model. (Chapter 1)
modifiers - Special keys, such as the alt or ctrl keys, that may be held down in conjunction with other keys. (Chapter 13 GUI Supplement)
move-to-front - A strategy for organizing a collection where every time an item is requested, it is moved to the beginning of the collection on the assumption that it is likely to be asked for again. (Chapter 10)
multithreaded programming - Programs written with more than one thread executing at a time.
mutually exclusive check boxes - A group of check boxes for which only one may be chosen at any one time. (Chapter 8 GUI Supplement)
nested if/else - An if/else or if statement appearing as the true portion of another if or if/else statement. (Chapter 6)
network resource - A resource, usually a file, that is available to users o' machines other than the one on which the file is stored. (Chapter 3)
nonmodal dialog box - A dialog box, which when active allows activity in other windows of the applet. (Chapter 13 GUI Supplement)
object - An entity in Java that models something; a member of a class (Chapter 1)
operand - A value participating in an operation. (Chapter 5)
operation - An action in Java that results in a value. (Chapter 3)
operator - A symbol or keyword representing an operation (e.g., the identifier new represents the operation that creates an object). (Chapter 3)
output - information that the program provides to the external world. (Chapter 4)
overloading - The practice of having a class provide different-though highly related-methods of the same name; the methods are distinguished by the types of arguments they receive. (Chapter 2)
overriding - The act of reimplementing a method in a subclass with the exact same signature of a method in the superclass. (Chapter 13)
packet - A small piece of data resulting from breaking up information for communication across a network. (Chapter 14 Net Supplement)
parameter - A variable that is declared in the parentheses of a method signature and whose purpose is to store the value of the corresponding argument; naturally, the type of the argument and the parameter must match in some sense. (Chapter 4)
picture element - See pixel. (Chapter 5 GUI Supplement)
pixel - A single dot of a graphic mode display. (Chapter 5 GUI Supplement)
point - A unit of measurement for a font's size-1 point equals 1/72 of an inch. (Chapter 5 GUI Supplement)
polymorphism - A feature of object-oriented languages in which the exact method to be invoked is determined at run-time by the class of the receiving object (Chapter 13)
predicate - A method whose return value is boolean. (Chapter 6)
prepend - Place in front of, place before. (Chapter 4)
primitive data type - A data type provided as part of the language definition rather than through a class definition. No class or methods are associated with the data type. (Chapter 5)
private - A keyword modifier in a method definition or instance variable declaration that prevents access to a method or variable from any code outside the class. (Chapter 4)
program - A Java text that can be compiled and executed. (Chapter 1)
prompt - A String that is written to the screen to tell an end user what kind of input should be entered next. (Chapter 3)
proportional font - A font in which the width of the characters vary. (Chapter 5 GUI Supplement)
protocol - The set of rules governing the interaction between a client and a server. (Chapter 14 Net Supplement)
prototype - Part of a method definition that consists of return-type, method-name, and argument list in parentheses. (Chapters 2,4)
public - A keyword modifier in a method definition or instance variable declaration that allows access to a method or variable from any code out, side the class. (Chapter 4)
receiver - An object that is the recipient of a message in response to which it therefore exhibits some behavior. (Chapter 1 )
recursion - The process of using a recursive procedure; the carrying out of a recursive call. (Chapter 11)
recursive call - An invocation of a method from within that method. (Chapter 11)
recursive procedure - A procedure that carries out a part of a task and refers to itself to carry out the rest of the task. (Chapter 11)
reference - A value or expression that refers to an object, thereby allowing us to send messages to the object. (Chapter 1,4)
reference variable - An identifier that may be assigned a reference to an object of a particular class. (Chapter 2)
relational operator - An operator that compares two values, producing a boolean expression as the result. (Chapter 6)
responsibility - The characteristic of being obligated to provide a certain behavior or carry out a certain task. (Chapter 4)
responsibility-driven programming - A perspective on class design, in particular the assignment of behavior, in which the burden of maintaining an object lies as much as possible with the object's class. This makes it easier for other objects to work with the object. (Chapter 12)
return - The action of the receiver of a message providing a value that is given to the sender; the value replaces the phrase that sent the message. (Chapter 2)
return value - The value given back to the sender by the receiver of a message. (Chapter 2)
return statement - A verb keyword that allows a method to terminate its own execution and allows the sender of the message to resume execution; additionally, the return statement allows the method to send some information back to the receiver. (Chapter 4)
return type - The first part of the prototype; it specifies what kind of information will be returned by the method. (Chapter 4)
router - A machine on a network that transfers (routes) packets. (Chapter 14 Net Supplement)
runtime Exception - An Exception that reflects a programming error that typically can occur "anywhere" and ought to occur "nowhere" in the code and therefore is not required to be in the throws clause. (Chapter 14)
sanity check - A test in a program that verifies what the programmer believes to be true at that point in the code. (Chapter 7)
search - An algorithm for finding a particular item that is stored in a collection of related values or objects. (Chapter 10)
selection sort - An algorithm for sorting where one successively selects progressively ascending elements of a collection. (Chapter 10)
self-organizing vector - An approach to searching where the order of elements in the vector is changed as it is learned which elements are frequently accessed. (Chapter 10)
sequential search - An algorithm for searching an indexed collection checking the elements in the same sequence that they are stored in the collection. (Chapter 10)
short-circuiting - Ending the evaluation of a condition without evaluating all its clauses as soon as the value of the condition can be determined. (Chapter 9)
signature - A method's name along with a description of its arguments. (Chapter 2)
Simple Mail Transfer Protocol - The protocol used by email servers and their clients. (Chapter 14 Net Supplement)
SMTP - See Simple Mail Transfer Protocol. (Chapter 14 Net Supplement)
socket - A communication endpoint-analogous to a telephone-that permits a program to communicate to another program across a network. (Chapter 14 Net Supplement)
state - The collection of values of the instance variables of an object at any given time. (Chapter 4)
statement - A sentence of the Java programming language. A statement represents an action to be carried out. (Chapter 1 )
static final - The Java keywords used to declare a constant. (Chapter 5)
static method - See class method. (Chapter 4)
String constant - A sequence of characters embedded in double quotes, e.g, "Hello" . The constant is a reference to the String object consisting of the characters between the quotes in our case, the characters Hello. (Chapter2)
subclass - A class that inherits from some other class. (Chapter 13)
superclass - A class that is inherited from. (Chapter 13)
switch statement - A multiway conditional. The switch allows selective execution of multiple cases based upon the value of an expression. (Chapter 6)
tag - A notation that controls the appearance of data on a web page. A tag consists of an open angle bracket, a tag word, additional tag-dependent information, and a close angle bracket.(Chapter 2 GUI Supplement)
tag word - The text in a tag that specifies how the tag controls the page's appearance. (Chapter 2 GUI Supplement)
TCP - See Transmission Control Protocol. (Chapter 14 Net Supplement)
TCP/IP - A collection of network communication protocols that includes TCP and IP. (Chapter 14 Net Supplement)
termination step - An essential step in any viable recursive procedure where the task is checked to see if it can be carried out without recursion. (Chapter 11)
test driver - A method (or collection of methods) whose purpose is to test the behavior of one or more classes. (Chapter 7)
text mode - A mode of screen or printer display in which each position can display a text character. (Chapter 5)
this - A pronoun keyword that refers to the current object; this allows for convenient reference to the object's instance variables, particularly when the parameters have the same name. (Chapter 4)
thread - The process of carrying out a set of instructions (Chapter 9 GUI Supplement)
Throwable - The parent class from which Exception is derived. (Chapter 14)
throws clause - A clause in a method prototype that lists objects the method might throw. (Chapter 14)
Transmission Control Protocol - A reliable, conceptually direct communication between two machines that is coded on top of the Internet Protocol. (Chapter 14 Net Supplement)
transpose - A strategy for organizing a collection in which every time an item is requested, it is moved up one position, exchanging position with the item in front of it. (Chapter 10)
true - The literal of type boolean representing a true value. (Chapter 6)
typeface - The combination of a font, style, and size. (Chapter 5 GUI Supplement)
typing a key - The event generated by pressing then releasing a key. This is essentially the combination of two events: key press and key release. (Chapter 13 GUI Supplement)
URL - A unique identification of a network resource, including the Internet address of the machine on which the resource is stored, the file name of the resource, and the protocol (such as HyperText Transfer Protocol, or HTTP) that should be used to access the resource. (Chapter 3)
while statement - A particular loop construct in the Java language. (Chapter 8)
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z |
|---|
[Grading] [Glossary] [U-Chat Tool] [Web Links] [Student Resources]
|
Last updated: January 25th, 2000 |
[About this site and list of symbols] |
