Glossary of JBuilder and Java terms

This glossary contains JBuilder-specific terms, and relates Java terms to JBuilder.

abstract
Abstract classes are general in nature and cannot be directly instantiated. An abstract class is designed as a template for extension by a subclass. For example, the JBCL DataSet class provides basic functionality that is extended by DataSetView and StorageDataSet. An abstract class can include non-abstract methods which have method bodies, as well as abstract method signatures. If a class has any abstract methods, the class must be declared abstract. See instance

accessor method
A non-private method that allows you to read and change private fields in an object.

adapter class
A class that contains stub implementations for every signature of an interface. Instead of adding method stubs to your own class for every signature in the interface, when you just want to override a small subset of an interface's signatures, you can extend the adapter class and override only the signatures that you are interested in. Anything ending in "adapter" is added to go with its corresponding "listener". This is done to provide the UI Designer with a base class to use to build its event adapter stubs when you set an event from the Inspector. An adapter class is an empty class (with no code in it) to act as a template for the UI Designer. You typically see an "xxxEvent" used by an "xxxListener" and accompanied by an "xxxAdapter". There are some "cracked" events in the jbcl.dataset package where there is only an "xxxListener" and an "xxxAdapter". There is no corresponding "xxxEvent" for these because the methods in the adapter pass several arguments rather than one single event argument.

AppBrowser
The JBuilder window that allows you to browse through various objects (and code) included in your application. The AppBrowser consists of a tool bar and three panes with tabbed pages: the Navigation pane to the upper left, the Structure pane to the lower left, and the Content pane on the right. If you click on an object listed in the Navigation pane, the Structure and Content panes change according to the new selection. Similarly, if you click on an object listed in the Structure pane, the Navigation and Content panes change accordingly. The AppBrowser has three modes: Source editing mode, UI Design mode, and Debugging mode.

Applet class
In Java, a subclass of java.awt.Panel used to build a program intended to be embedded in an HTML page and run in an HTML browser or applet viewer. Various security restrictions are imposed on an applet. For example, an applet cannot perform input/output operations on a user's system and therefore cannot read or write files or transmit computer viruses.

Application
In Java, a stand-alone program that is similar to programs created using C++ or other programming languages. A Java application does not need to be run in an HTML browser, nor is it subject to the security restrictions imposed on Java applets.

architecture
See model-view architecture

argument
Data that a method accepts in order to perform the operations specified within itself.

array
An ordered arrangement or pattern of data. Typically you refer to individual items in the array by an index value. Index values in Java are zero-based and start with 0 for the first element, 1 for the second, and so on.

AWT
Abstract Windowing Toolkit. The java.awt package contains components that are simple GUI controls such as checkboxes, labels, radio buttons, and text boxes. (As an alternative to AWT controls, JBuilder's JBCL library provides versions of standard controls that are data-aware components, supporting easy, dynamic updating of the data shown in the controls. See model-view architecture.)

BeanInfo class
A class defining the PME (properties, methods, and events) for the class of the same name. For example, BevelPanelBeanInfo is a BeanInfo class for BevelPanel. The naming rule is strict: the BeanInfo class associates itself with its class by stripping off the word "BeanInfo". BeanInfo's are not required for a class, but they are present for two reasons: A BeanInfo class provides information about a component, as a substitute for adhering to the JavaBeans naming conventions for property getter and setter methods and for events. The BeanInfo class causes the specified properties and events of a component to appear in the Component Inspector. Useful for these cases: See also Component Writer's Guide: Specifying component information with BeanInfo classes

block
A group of commands that appear together and are handled as a single unit, typically enclosed in braces { }.

cast
(1) The process of converting an object of one data type into another type. For example, a numeric value of 12.34 is cast into a text value of "12.34". (2) In Java, an instance of a class can be cast to an instance of another class as long as the latter is a subclass of the former, or if an interface, implements the former.

class method
A method declared using the keyword static. Methods of this type are not passed an implicit this reference and may only refer to class variables and invoke other class methods of the current class. A class method may be invoked through the class name, rather than through an instance of the class. See also class variable

class variable
A variable that is global to a class and to all instances of that class. Class variables are used to communicate between different objects with the same class and for handling global states among a set of objects. Class variables are defined using the keyword static. For example,

static int total; // Declares a class variable called total

static final int maxRows = 100; // Declares a class variable called maxRows that cannot change values.

See also class method, static

class
(1) An encapsulated collection of data and methods that operates on the data. A class may be instantiated to produce an object that is an instance of the class. (2) Keyword used to declare a class, thereby defining a new object type.

Component Inspector
A user-interface portion of JBuilder that presents the properties of the component selected in the Component Tree or the UI Designer. The Inspector consists of two tabs: Properties and Events. Selecting the Properties tab displays the properties of the selected component(s). Selecting the Events tab displays the events that a component surfaces, and that your application may respond to.

Component Palette
A JBuilder user-interface that displays a tabbed tool bar of components by group (AWT, Controls, Data access, and so on).

Component Tree
A JBuilder user-interface where all components included in an application or applet are listed, including visual and nonvisual components. The list is structured as a tree and displays the object hierarchy.

component
(1) An object that can be used and tested as a unit, independent of context in which the component is eventually used, and whose internal implementation is completely hidden from the user. (2) Any GUI primitive that is implemented as a subclass of the java.awt package. (3) A class that follows the prescribed JavaBeans Specification.

composite component
A visual component built from model-view elements in the JBCL. See also model-view architecture, component

constant variable
See constant

constant
Any variable declared final in Java is a constant. Its value must be specified with an initializer when it is declared, and that value may never be changed. For example: public static final double pi=3.14159;

constructor
A method in a class file of the same name as the class that describes how the object should be created and initialized. If a class has no explicitly implemented constructor, the default constructor is implied.

container
A specialized component that contains and manages other components. The basic Container component is java.awt.Container and include components such as Frame, Panel, and Dialog.

Content pane
The right side of the JBuilder AppBrowser window, where the content information appropriate for the selected object is displayed. The Content pane usually shows three tabs: Source, Design, and Doc. When the Source tab is selected, the Content pane displays Java source code for viewing or editing purposes. When the Design tab is selected, the Content pane displays the UI Designer. When the Doc tab is selected, a limited-functionality HTML browser displays the content of a corresponding HTML file. For example, selecting the Doc tab when the currently selected object is a JBCL class or method displays the HTML documentation for that class. If there is no corresponding HTML file for the currently selected object (your application class for example), the Doc tab displays the message "No JavaDoc file found". See also Tabs on the right side of the AppBrowser in the online F1 Help topic AppBrowser window overview.

control
A visual component. In the JBCL, a component named "control" is a composite component built from model-view elements in the component library. See also model-view architecture

CORBA
Common Object Broker Request Architecture. The heterogeneous, multilanguage distributed computing environment that has a language-neutral object model. CORBA provides the mechanisms by which objects transparently make requests and receive responses. For more information on CORBA, see the Developing distributed applications and the Object Management Group Web page at http://www.omg.org/

cracked event
An event with no event class; there is only an "xxxListener" and an "xxxAdapter". There is no corresponding "xxxEvent" for these because the methods in the adapter pass several arguments rather than one single event argument. There are some "cracked" events in the jbcl.dataset package. See also adapter class

DataExpress
JBuilder's data architecture built on the foundation of JDBC. The DataExpress architecture offers a powerful combination of JavaBeans components that efficiently manage database connections and transactions.

data field
See field (Java)

data item
model view. Drawn on the screen within a view (a control) by an item painter. For example, each entry shown within a list control is a data item. See model-view architecture

data member
A variable or object that holds a property value. See model

Data pane
The bottom pane of the Debug tab in the Debugger, by default. The Data pane displays the values of all data members that are currently in use.

data source
See data model

data type
Data that contains information characterized as boolean, char, byte, short, int, long, float, double, Object, or Array. See also primitive data type, non-primitive data type

declaration
(1) A part of a computer program that defines the nature of other elements of the program or reserves parts of the hardware for special use. (2) In Java, the code segment that defines an object or its behavior, including input and output parameters and results. Also referred to as a method or property signature.

default constructor
A constructor that takes no arguments. A default constructor is required for components that follow the JavaBeans Specifications. Also referred to as null constructor.

delegation
In object-oriented programming, the act of assigning implementation of a method or interface to another object.

delimiter
A character designated to surround a data value to separate it and therefore make it a distinct single value. For example, double quotes are often used as a delimiter for character data values when dealing with import or export of data to delimited text formats.

descriptor
A collection of related properties. For example, the ConnectionDescriptor encapsulates properties related to connecting to a SQL server database.

design surface
See UI Designer

Dialog class
A JBuilder UI container component that is a pop-up window, similar to a Frame, used to get user input or provide user information such as a warning dialog box. Dialogs can be modal or modeless. See also modal dialog box, modeless dialog box

distributed objects/applications
Objects or applications that can be accessed remotely from any machine on the network. Its location is not critical to the user of the object. For additional terms specific to distributed applications, see the glossary in the Developing distributed applications section of the Building Applications with JBuilder.

encapsulation
Combining of methods and data together into a single data structure. In Java, this is known as a class.

enumerated type
A property that has a restricted list of accepted values. For example, an Hour property might be restricted to the values 1-24.

event
The link between the behavior that a component wants to react to, and the code that tells the application what to do (how to respond). Components need to fire and respond to events such as mouse clicks, button presses, or changes in component state. An event is the link between these occurrences and the user code that tells the application how to respond. Java differentiates between the source of an event (the provider of feedback) and the handler for an event (what to do).

event adaptor
A class that is used to filter event methods and handle only specified ones.

event handler
A method that is designed to do some specified processing when a particular event happens. The class that generates the event is referred to as an event source. See also event

event listener
A component that is registered for and receives the events in which they are interested, ignoring all others.

event listener interface
A collection of related events. The event listener interface for a particular group of events is implemented by a component that is interested in that event group.

event registration
The means by which Java components receive events from other components. By registering a component as a listener of an event group, this component receives notifications from the component being listened to. The JavaBeans Specification indicates naming conventions that components should follow.

event set
Defines a type of event, what it communicates, and what is required to generate and to listen to the event. An event set consists of the event-listener interface, an event object, and event registration methods. See also Component Writer's Guide: Event sets

event source
A component that generates or fires an event. See also event

Events page
A tabbed page in the JBuilder Component Inspector that displays event names associated with the object currently selected in the Component Tree.

extends
A keyword used in a class or interface declaration. In class definitions, extends specifies the superclass of the class being defined. The keyword extends is followed by the name of the superclass. For interfaces, the extends keyword is followed by a list of classes. See implement

field (Java)
Class data member such as variables or member objects.

field (JBCL)
A single data item, for example, the TextFieldControl displays a single String value. With data-aware controls, a field occurs at the intersection of a row and column.

FileDialog component
A UI component that provides a basic, system-independent open/save dialog box, enabling you to access the file system.

final
A keyword used with classes, methods, and variables. With classes, it signifies that a class cannot be further subclassed. With methods, it means that the method cannot be overridden. With variables, it means that the variable has a constant value that cannot be changed. In such cases, the value of the variable must be stated and no assignments after initialization are permitted.

Frame class
A UI container component that comprises a top-level window with a border and a title. A frame has an optional status bar and standard window controls such as a control menu, buttons to minimize and maximize the window, and controls for resizing the window. Typically the main UI container for a Java application is a customized subclass of Frame.

getter/setter methods
See accessor method, property

graph model
A container to hold data items that appear in a model-view, data-aware control. Holds a tree (a directed acyclic graph) of data items.

handler
See event handler

IDE
Integrated Development Environment. An alternative to command-line programming. Software to help programmers write code efficiently, taking advantage of the standardization, ease-of-learning, and ease-of-use of a graphical user interface. Combines a variety of programming tools and features. The main tools typically include a compiler, debugger, and project manager. An IDE can provide a graphical interface for underlying command-line programs, and also enable the programmer to work from the command line.

implement
A class that implements an interface must provide an implementation for all the method signatures of each of the interfaces that are implemented. To implement is to write the code for a method. implements is a keyword used to specify that a class inherits behavior from an interface and has written the code or at least an empty block for every method signature in an interface. A class can implement multiple interfaces. The following are valid:

import
A keyword that makes Java classes available to the current class using an abbreviated name.

inheritance
The acquisition of data (variables) and behavior (properties, methods and events) from a parent (superclass) in an object hierarchy. Single inheritance is the Java restriction where a class can inherit from a single superclass. This restriction can be eased by use of interface and delegation.

inner class
A class embedded in another class or method. An object-oriented, and more generally applicable, approach to method pointers. Inner classes enable you to define small auxiliary objects and pass units of behavior.

inspector
(1) A window in the debugger that allows you to monitor values. (2) The UI Designer's Component Inspector window. See Component Inspector

instance variable
A non-static variable of a class that are declared outside a method definition. A copy of an instance variable exists in every instance of the class that is created. See also variable

instance
An instance is an object. When a class is instantiated, the object that results is an instance of the class.

interface
A group of method declarations that provides basic functionality to classes that share common behavior or needs. This allows Java classes to span multiple class hierarchies even though a Java class can only inherit implementation from a single superclass. A class that implements an interface must provide an implementation for all the method signatures in the interface.

introspection
JBuilder's ability to examine a bean and extract information about it automatically. See also Component Writer's Guide: Specifying component information with BeanInfo classes

item editor
In a model-view component, an item editor class enables an item shown in a control to be edited. The actual data change is made in the model, which is a single place to store the item values. For example, an item in a list control can be edited, if an item editor is used as part of the composite component.

item painter
The part of a component that allow an item of data to be displayed on the screen. Part of the model-view architecture that presents a view mechanism for data types and objects. The information to display is received from the view. See also model-view architecture

JAR
Acronym for Java ARchive. A cross-platform file format that uses Java to group, and possibly compress, multiple class files and other files such as graphics and sound files into one file. A JAR file is downloaded in a single HTTP transaction.

JavaBean
A component that follows the JavaBeans Specification. Such components may be added to the JBuilder Component Palette, and its properties, methods, and events appear in the JBuilder Component Inspector and Component Tree.

JavaBeans Specification
The rules and guidelines for Java cross-platform components. For information, see the JavaSoft Web page at http://splash.javasoft.com

JBCL
JBuilder Component Library, the component library that is included with JBuilder. All components in the JBCL are JavaBeans-compliant.

JDBC
Java Data Base Connectivity, the SQL interface for Java that focuses on executing raw SQL statements and retrieving their results. It has two major sets of interfaces: JDBC API (for application writers) and JDBC Driver API (for developers writing Java-based drivers).

JDBC API
One of the major interfaces of JDBC. It is expressed as a series of abstract Java interfaces that allow an application programmer to open connections to particular databases, execute SQL statements, and process the results.

JDBC Driver API
One of the major interfaces of JDBC. It is expressed as a series of abstract Java interfaces that allow a programmer to create Java-based drivers that connect to SQL databases.

listener
See event listener

listener interface
See event listener interface

local variable
A variable defined inside a method definition.

Main window
The window at the top of the screen when JBuilder is launched. Comprises the JBuilder main menu, toolbar, and Component Palette.

matrix model
A container to hold data items that appear in a model-view, data-aware control. Holds a two-dimensional array of data items; a table. Has rows and columns.

member object
An object that is instantiated in another object.

Menu Designer
A JBuilder user-interface that allows you to visually design menus. The Menu Designer appears when you double-click any menu object in the Component Tree when the UI Designer is open.

method overloading
The ability of a programming language to have the same method defined with varying signatures. For example, the Button class allows for a method call of Button() and an alternate signature of Button("myButtonText").

method overriding
The definition of a method at the subclass level that overrides an inherited method of the same name from the (parent) superclass.

method, class
See class method

method
(1) A Java function. (2) Behavior or action information that is built into the structure of a component object. Can have a visibility of public, package, private, or protected. See also class method

modal dialog box
A type of dialog that is used to get user input or provide user information such as a warning dialog. A modal dialog box prevents the user from switching to any other window in the current application until the dialog is closed. (Note that displaying a modal dialog box does not prevent you from switching to the window of another application.) See also Dialog class, modeless dialog box

model
Models handle access to the information for a component, without exposing or using any knowledge about data types. A model is a container that serves the information, often called data items, to the view (such as a list box) on request. A model can be a container (holding and storing the items itself) or it can simply communicate between the view and the actual data container. The type of model depends upon the data structure required by the view, but not on the type of data. JBCL provides the following models: singleton (single-item), vector (list), matrix (table), and graph (tree). In the context of data connectivity, a model acts as the source of data for an object of another class. For example, the data cursor manager is the model to the data-aware control. A model is sometimes called the data model; this is different than an arrangement of multiple tables in databases. See also model-view architecture, Component Writer's Guide : Models in JBCL

model-view architecture
The approach where smaller components that surface model, view, item painter, and item editor functionality are connected together to create a new component. Also known as composite component. A model-view component displays data items such as entries in a list control.

modeless dialog box
A type of dialog that is used to get user input or provide user information such as a warning dialog. A modeless dialog box lets the user have the dialog box open while setting focus to any other window in the current application. See also Dialog class, modal dialog box

multicast event
Events that can have a list of listeners who are notified when the event occurs. See also event, unicast event

Navigation pane
The upper left panel of the JBuilder AppBrowser window. It allows you to navigate through the selected item, whether the item is a project, a directory of files, or a subset of files.

new
A Java keyword used to create a new array or new instance of the specified class. Abstract classes cannot be directly instantiated.

non-primitive data type
In Java, the non-primitive data types are Objects and Arrays, which are classes. Also called "reference type" because it is handled by reference (like other classes) rather than value.

nonvisual component
A component that does not have a visual UI at runtime and does not have the ability to paint anything to the screen. See also component

null constructor
See default constructor

obfuscation
A process by which the internal implementation or architecture is hidden from the end user. For example, during compiling, replacing variable names by random strings.

object-oriented programming
An approach to programming that involves organizing objects and their behaviors into classes of reusable components. Also known as OOP.

OOP
See object-oriented programming

package
(1) A Java keyword that defines the package that a class belongs to. Each package corresponds to a directory. (2) The default visibility for methods and variables.

package
A group of related Java classes.

painter
See item painter.

panel
A component class that is a container used to group other components such as buttons, checkboxes, and text fields in the UI Designer. A panel has no border or caption. A panel has a layout manager assigned to it, to control placement of controls within the panel.

parent class
See superclass

polymorphism
The ability to determine at runtime (late binding) which code to run given multiple methods with the same name but different operations.

primitive data type
In Java, data that is passed by value. The primitive Java data types are boolean, char, byte, short, int, long, float, and double. See also non-primitive data type

private
A keyword and visibility modifier where a method or variable is visible only to the class in which it is declared. If a constructor is declared private, only a static member in that class can create an object of that class. A class cannot be private, only default accessibility ("package") or public.

property
The state of a component (changeable in the Designer and at runtime) that affects the object. Often associated with a visual change such as color but not limited to visual characteristics. For example, a timer component might have a precision setting that determines how partial seconds should be handled. Property types are: simple properties, array properties, enumerated properties, and property objects. See also read-only property, write-only property, Component Writer's Guide: Creating properties

property editor
A type of dialog box available off of an ellipses button on the Component Inspector. When you double-click a property in the Component Inspector window (part of the UI Designer and part of the visual design tools), an elipses button might appear. When you click the elipses button, a property editor dialog box appears.

Properties page
A tabbed page of the Component Inspector that displays and allows modification of the properties for the selected object in the Component Tree.

protected
A visibility modifier that limits a method's visibility to the class in which it is declared or any subclasses derived from that class.

public
A visibility modifier placed on the declaration line of a property, method, or variable that makes it available to all classes.

read-only property
A property that has a read (get) accessor but no write (set) method. See also property

reference type
See non-primitive data type

registration method
A method by which a component becomes a listener of events generated by another component. See also event registration

Remote Method Invocation
The all-Java distributed computing system. It assumes the homogeneous environment of Java Virtual Machine (VM) and the system uses the Java object model. Often abbreviated as RMI.

return type
The data type returned by the execution of a method or procedure. The return type always appears in the declaration of a method or property. For example,

public Boolean keyDown(Event evt, int key);

Valid return types are void and those listed under data type.

RMI
See Remote Method Invocation

scoped object list editor
A property editor which displays each of the objects in scope that match the given property type. For example, the dataSet property for the various JBuilder controls use the scoped object list editor and lists all the objects in scope of the type DataSet. See also Component Writer's Guide: Writing property editors

selection pool
Highlighted items in a control. For example, in a graphical list of files in a directory, you can select a range of 5 files, plus another file a few entries down. This is different than focus, which refers to a single control. The selection pool is also distinct from subfocus, which refers to a single item in a control, with a dashed-line rectangle or dots around the item.

separator
(1) A character that is designated to separate each data value in a list. Often used in cases of data import or export. For example, a common ASCII file format is to have data values separated by commas. (2) Horizontal line separating menu items.

set method
See accessor method

signature
The combination of the name of a method and the list of its parameters. An interface contains signatures with empty blocks; that is, methods containing no statements.

singleton model
A container to hold data items that appear in a model-view, data-aware control. Holds a single data item. This model is sometimes called an "atom".

Smart Dependencies Checking
JBuilder provides fast yet complete compiling by using Smart Dependencies Checking, which results in fewer unnecessary compiles of interdependent source files, and thus accelerates the edit/recompile cycle. When compiling, instead of deciding whether to recompile a source file based only on the time stamp of the file, JBuilder analyzes the nature of the changes you make to source files. A source file is recompiled only if it uses (or depends on) a particular element that has changed within another source file. A class uses another class when it calls a method in another class, uses (imports) a variable in another class, extends a class, or implements an interface. When you compile source files for the first time, a dependency file is automatically created for each package, and is placed in the output directory along with the class files. The dependency file contains detailed information about which class uses which, for all the classses in that package. Smart Dependencies Checking is used by the compiler in the IDE and by the bmj command-line compiler, but not by the bcj command-line compiler. See also Building Applications with JBuilder: Smart Dependencies Checking

Source pane
The Java source code editor that appears in the Content pane when the Source tab is selected.

static
The keyword used in class declarations that designates it as a class variable.

Structure pane
A pane in the JBuilder AppBrowser that displays a list of objects in the current application and their object hierarchy. The elements of an object selected in the Navigation pane are listed in the tree in the Structure pane. When the AppBrowser is in the UI Design mode, the Component Tree appears in the Structure pane.

subclass
Any class that descends from a parent class (also known as superclass) and inherits the behavior of its superclass.

subfocus
A control, as a whole, can have focus. An item within the control can have subfocus. For example, a list control might currently have focus; then an item in the list control can have subfocus.

superclass
Any of the parent classes in the class hierarchy from which a particular class receives its basic behavior.

synchronized
Keyword used in method signatures to prevent conflicts in multithreaded applications.

this
In Java, a keyword specifying the object itself. Typically used to indicate an instance variable, as opposed to a variable that resides inside a method and has the same name as the instance variable.

Threads and Stack pane
The top pane of the Debug tab, by default. The Debug tab appears while debugging. The Threads and Stack pane displays information about the running thread groups and threads. The current context is defined by which thread is selected. Also displays the sequence of method calls that brought your program to its current state. Only methods in the currently loaded symbol table are listed in this pane. Using the Threads and Stack Pane, you can return to the point from which the current method was called, then resume debugging from there.

Two-Way Tools
When you use the editor to edit your source code in JBuilder, these changes are automatically reflected when you switch to the visual design tools. Conversely, when you use the visual design tools to change your program, these changes are automatically reflected in the source code, which you can see in the editor.

typecasting
See cast

type
See data type

UI Designer
A JBuilder tool that allows you to visually design the user-interface portion of your application. The UI Designer is the central part of the visual design tools. In other environments, this type of feature is referred to as a forms designer or a form. The UI Designer is also referred to as a design surface. To access the UI Designer, first select an object that is capable of being designed is selected in the Structure Pane, for example, a Frame. Then select the Design tab that appears at the bottom of the AppBrowser. The UI Designer appears in the right side of the AppBrowser window. To use the UI Designer, in the Component Palette at the top of the screen, click an icon for a component, then click or draw an area for the component's placement on the design surface. The properties of the selected object are displayed in the Component Inspector window, on the right side of the screen. See also visual design tools

unicast event
In Java, an event with only one listener which is notified when the event occurs. Unicast event listeners are registered using methods that are named "add" and "remove". For example, addEventListener(). In JBuilder, a unicast event is supported as a multicast event that throws a TooManyListeners exception on the registration of the second or subsequent listener. See also event, multicast event

Unicode
A code system for international characters managed by the Unicode Consortium. For the code specification, see The Unicode Standard, Version 1.0, 2 volumes (Addison-Wesley, 1991). See also Building Applications with JBuilder: The 16-bit Unicode format, the Unicode Web page at http://www.unicode.com

variable
A location in memory in which values are stored. A variable has a name (by which you can refer to it), a data type, and a value. A variable must be declared before it can be assigned a value. There are three types of variables: instance, class, and local

variable, class
See class variable

variable, instance
See instance variable

variable, local
See local variable

vector model
A container to hold data items that appear in a model-view, data-aware control. Holds a one-dimensional array of data items; a list.

view manager
The part of the model-view architecture that manages the relationship between data types and the appropriate item painter required to display individual data types.

view
The part of a component that holds its essential behavior. The view uses the data provider interface to get its items and passes them along to the time painter for rendering to the screen. The visual part of a visual component. A view does not actually contain data items; data items shown as the items in a ListView are actually stored in a model. A view is a broker of screen real-estate. See also model-view architecture, view manager, model, item painter, item editor

visibility
See public, package, private, protected

visual component
A component that draws something on the screen at runtime, becoming part of the user-interface of the program.

visual component designer
See UI Designer

visual design tools
Sometimes called UI design tools or Visual Component Designer (VCD). Consists of the following (see their entries):

Watch pane
The left pane of the Debugger when the Watch tab is selected. The Watch pane displays the values of specific data members that you have selected for tracking. Watches are evaluated in the current context. Each time your program's execution pauses, the debugger evaluates all the items listed in the window and updates their displayed values.

write-only property
A property that has a write (set) accessor but no read (get) method. See also property