# Appendix B

# Java Terminology

abstract modifier A modifier used to create template classes.

abstract class A template class that contains such things as variable declarations and methods, but cannot contain code for creating new instances.

applet Code that requires an external program to provide an interface to the user. Web browsers and the Java Developer's Kit (JDK) applet viewer are examples of interfaces that support applets.

applet viewer A program that allows you to view an applet directly without a Java-enabled browser. You will find this program in the Java Developer's Kit.

application Stand-alone program that can be run directly from the command line.

argument A parameter that is passed to a method when it is called.

array A single- or multidimensional group of variables.

`available()` method A method used to determine if some amount of data is ready to be read without blocking in the input stream. This method is found in the following `java.io` classes: `InputStream`, `FilterInputStream`, `BufferedInputStream`, `ByteArrayInputStream`, and `PushbackInputStream`.

binary operator An operator that acts on two values and returns one value.

block A section of code beginning and ending with curly braces `{}`. The statements are grouped so they can be used together to accomplish a certain task or so that they can be executed when a particular condition is met.

boolean A data type that can be either `true` or `false`.

boolean literal A literal declared with the keywords `true` or `false`.

catch Code that realizes an exception has occurred and deals with it appropriately. See also `try`.

`char` data type A 16-bit unsigned integer that represents a Unicode value.

character literal A single character value.

class Made up of objects that are not all exactly alike but have enough similar characteristics that they can be grouped together.

class library A set of classes. See also package.

class variable A variable that is available to all instances of a class.

`close()` method A method used to close an output stream that an application or applet no longer needs. This method is found in the following `java.io` classes: `OutputStream` and `FilterOutputStream`.

conditional expression An expression that executes one of several sections of code based on a conditional test.

constructor A special method used in the initialization of an object.

data type Defines the kind of data that can be stored in a variable.

declaration statement A statement that declares a variable or a line of code. Most declaration statements end with a semicolon.

double data type A double-precision, 64-bit long, floating-point number used as a variable.

exception Java's method of handling errors.

expression Performs computations.

final A modifier that indicates an object is fixed and cannot be changed.

`finally` Used to perform any necessary cleanup if an exception occurs. The `finally` statement ensures that a section of code will be run.

`float` data type Designates a single-precision, 32-bit long, floating-point number as a variable.

floating-point literal Represents a number that has a decimal point, such as 3.7.

friendly A term used to describe the default access control for methods of a particular class in which the class itself, subclasses, and classes in the same package can call the method.

`flush()` method A method that is used to force any data buffered for the output stream to be written to the output device. This method is found in the following `java.io` classes: `OutputStream`, `FilterOutputStream`, `BufferedOutputStream`, and `DataOutputStream`.

keyword A reserved word that can be used only as it is assigned in Java. Here is a complete list of reserved words in Java:

> `abstract
> boolean
> break
> byte
> byvalue
> case
> cast
> catch
> char
> class
> const
> continue
> default
> do
> double
> else
> extends
> false
> final
> finally
> float
> for
> future
> generic
> goto
> if
> implements
> import
> inner
> instance of
> int
> interface
> long
> native
> new
> null
> operator
> outer
> package
> private
> protected
> public
> rest
> return
> short
> static
> super
> switch
> synchronized
> this
> threadsafe
> throw
> transient
> true
> try
> var
> void
> while`

identifier A Java reserved word or title given to variables, classes, and methods.

`import` statement A statement that is used to include a class to be searched for in a particular package.

inheritance A methodology whereby the code that was developed for one use can be extended for use elsewhere without having to actually make a copy of the code.

`init()` method A method that is only called the first time an applet is loaded into a viewer. It is used to initialize data. The method is in the `java.applet.Applet` class.

input stream A data stream that is accepted and processed by a process looking for incoming data.

instance One specific object within the class of objects.

instance variable A variable particular to an instance of a class.

integer A whole number, such as 1 and 5280.

integer literal A literal that can be decimal (base 10), octal (base 8), or hexadecimal (base 16).

interface Used to define the structure of a set of methods that will be implemented by classes yet to be designed and coded.

literal Represents data in Java. It is based on character and number representations. The types of literals are integer, floating-point, boolean, character, and string.

`main()` method A method that must be defined in every Java application. When a Java application is invoked, the Java compiler looks for the method named `main` and begins execution there.

`mark()` method Used to mark a point in an input stream to which it may be necessary to return at a later time. This method is found in the following `java.io` classes: `InputStream`, `FilterInputStream`, and `BufferedInputStream`.

method A function that reports back a status.

modifier Used to alter certain aspects of classes. Modifiers are specified in the declaration of a class before the class name.

native Methods implemented in a platform-dependent language, such as C or C++.

`new` The command in Java that creates a new instance of a reference data type.

null No value is assigned to a variable.

operator A symbol used for arithmetic and logical operations.

output stream A data stream that is generated by a producer process.

package To group together a variety of classes and/or interfaces that perform similar functions.

primitive data type A data type that can have only one value at a time and is the simplest built-in form of data within Java.

`private` A modifier that specifies only the current class can call this method or variable. When you use this modifier, you are excluding subclasses of the class as well.

`private protected` A modifier is a special combination of private and protected access modifiers. This modifier specifies that only the class in which the method or variable is defined can call the method or variable, and does not exclude subclasses of the class, which can access the method.

`protected` A modifier that specifies that only classes in the current package in which the method or variable is defined can call the method. This allows access for objects that are part of the same application, but not to other applications.

`read()` method The method an application actually uses to read data from a stream. This method is found in the following `java.io` classes: `InputStream`, `FilterInputStream`, `BufferedInputStream`, `DataInputStream`, `ByteArrayInputStream`, and `PushbackInputStream`.

reserved word A word that can be used only as it is assigned in Java.

separator Divides code into segments.

single inheritance The concept that a class can only have one superclass.

`skip()` method The method used to bypass part of an input stream. `skip` is used to move quickly through a stream by skipping a fixed number of bytes. This method is found in the following `java.io` classes: `InputStream`, `FilterInputStream`, `BufferedInputStream`, and `ByteArrayInputStream`.

`start()` method The method that is called after the `init()` method the first time an applet is loaded into a viewer or if an applet has been suspended and must be restarted. The method is in the `java.applet.Applet` class.

statement Any line or lines of code ending in a semicolon. Statements may be an expression, a method call, or a declaration.

`static` modifier A modifier that is used to specify a method that can be declared only once. No subclasses are allowed to implement a method of the same name.

static variable A variable that exists in only one location and is globally accessible by all instances of a class. See also class variable.

`stop()` method A method that is called whenever an applet needs to be stopped or suspended. The method is in the `java.applet.Applet` class.

stream Allows a Java application to communicate with files, networks, devices, other applications, and even among threads within the same application.

string literal A sequence of characters enclosed in double quotes, such as `"This is a string literal"`.

subclass Extends the superclass and creates a new variation of the class. Inherits the characteristics of the preceding class.

`super` A reference to the superclass. It is often used as a shortcut or explicit way to reference a member in the superclass of the current class.

superclass The top-level class of every application.

template classes Classes that are normally used to provide a superclass for other classes.

`this` Allows the current instance of a variable to be explicitly referenced.

thread Provides Java with the capability to have a single application easily run multiple concurrent code execution.

token The basic elements of the Java language. At compile time, the `javac` compiler takes the code and pulls out these basic building blocks for further processing.

`try` Executes a block of code that may generate (throw) an exception. See also `catch`.

unary operator An operator that manipulates a single value.

`void` A special return type in Java. `void` indicates that there is no return type of any kind. This is used for methods that have no need to return anything to the calling program, or that only modify method arguments or global variables.

`write()` method The method an application actually uses to write data to a stream. This method is found in the following `java.io` classes: `OutputStream`, `FilterOutputStream`, `BufferedOutputStream`, `DataOutputStream`, and `ByteArrayOutputStream`.