|
FHTW Berlin
Fachbereich 4
Internationale Medieninformatik
PROG1: Programmierung I
Wintersemester 02/03
|
Course Glossary
A
- abstract method
-
A method with no body; a method signature followed
by a semi-colon.
- applet
- A Java program
capable of running embedded in a web browser or other applet environment. Contrast
application.
- application
-
A Java program capable of running "standalone". Contrast applet.
-
animacy
- A Java Thread that enables concurrent
execution, e.g., of a self-animating object.
See the chapter on Self-Animating Objects.
-
animate object
- See self-animating object.
-
array
- A structure for holding many Things
of the same type.
- argument
-
A value supplied to a method when it is invoked.
During the execution of the method body, this value
is named by the matching method parameter.
-
arithmetic operator
- An operator that
computes one of the arithmetic functions. See the chapter on Expressions.
-
assignment
- The association of a name
with a value. See the chapter on Things, Types, and Names.
Also the operator in such an assignment. See the
chapter on Expressions.
- asterisk
-
* Sometimes called "star". Used to delineate certain comments
and as the multiplication operator.
B
- backslash
- \ Used in character
escapes.
- binary operator
- An
operator that takes two operands.
See the chapter on Expressions.
- bit
-
A single binary digit.
- bitwise
operator
- An operator that computes a bit-by-bit
function such as bitwise complement. See the chapter on Expressions.
-
block
- A segment of code that begins with a { and
ends with the matching }. See the section on Blocks
in the chapter on Statements.
- body
-
The body of a method, class, or interface,
i.e., either a method body, a class
body, or an interface body.
- boolean
-
A true-or-false value. In Java, represented by the primitive
type boolean and by the object type Boolean.
See the sidebar on Java Primitive
Types in the chapter on Things, Types, and Names.
-
boolean expression
- An expression
whose type is boolean.
- boot,
boot up
- Start up (a computer or program).
- brace
-
{ or } Used to enclose bodies or blocks.
-
bracket
- [ or ] Used in array
expressions.
- bug
- An error in a program. Contrast
feature.
C
-
call
- See invocation.
- case-sensitive
-
Distinguishing between upper and lower case letters.
- cast
expression
- An expression involving a type
and an operand whose value is the
same as its operand but whose type is the type supplied. Contrast coercion.
-
catch statement
- A particular kind of Java
statement, typically used with exceptions,
that receives a thrown object. See
the chapter on Exceptions.
- character
-
A single letter, digit, piece of punctuation, or piece of whitespace. In Java,
represented by the primitive type char,
using unicode notation, and occupying sixteen bits, and
by the object type Char. See the sidebar on
Java Primitive Types in the chapter
on Things, Types, and Names.
- character
escape
- A special sequence indicating a character other than by typing
it directly. Especially useful for non-printing characters, such as carriage return.
-
class
- A (user-definable) type
from which new objects can be made. See the chapter on Classes
and Objects.
- class body
- The portion
of a class declaration containing the class's members.
The portion of a class declaration enclosed by { }. See the chapter on Classes
and Objects and the Java Chart on Classes.
-
class object
- The object
representing the class itself, i.e., the factory. Itself
an instance of class java.lang.Class.
-
coercion
- Treating an object of one type as though
it were of another type. Contrast cast. See the chapter on
Expressions.
- comment
-
Text embedded in a program in such a way that the Java compiler ignores it. Intended
to make it easier for people to read and understand the code.
- comparator
-
An operator in an expression
of boolean type.
- compiler
-
The utility that transforms your Java code into something that can be run on a
Java virtual machine.
- compount
assignment
- A shorthand assignment operator
(or expression) that also involves an arithmetic
or logical operation.
- concatenation
-
The gluing together of two strings.
- conditional
-
A compound statement whose execution depends on the evaluation
of a boolean expression.
- conjunction
-
The logical operator && (and).
-
concurrent
- Literally or conceptually at the
same time.
- console
- See Java console.
-
constant
- A name associated
with an unchanging value. Typically declared final.
-
constructor
- The code which specifies how to
make an instance of a class. Its
name matches the name of the class. A constructor is a class member.
See the chapter on Classes and Objects.
D
- data
- Values,
as opposed to executable code. Things that might be associated with names
such as variables, parameters,
or fields.
- data repository
-
A kind of object whose primary purpose is to store data.
-
debug
- To attempt to eliminate bugs
from your program.
- declaration
- A statement
associating a name with a type. Once the
name has been declared, it can be used to refer to Things of the associated type.
See the chapter on Things, Types, and Names.
-
default value
- The value
associated with a name that has been declared
but not assigned a(n initial) value. See the sidebar
on Default Initialization in
the chapter on Things, Types, and Names.
- definition
-
A statement that both declares
and initializes a name. See
the chapter on Things, Types, and Names.
- disjunction
-
The logical operator || (or).
-
dot
- See period.
- double
precision floating point
- A representation for rational numbers (and an
approximation for real numbers) that uses 64 bits of storage. In Java, implemented
by the primitive type double. See floating
point.
E
embedded
- The property of being in an environment (or system)
and interacting with it.
- entity
- A member
of the community. A conceptual unit consisting of an object or set of objects
that is (implicitly or explicitly) persistent and that interacts with other entities.
-
environment
- Where an entity
is embedded. What the entity interacts with.
-
evaluate
- To compute the
value of an expression.
-
event
- 1. Something that happens.
2. A special kind of object used in event-driven
programming to record the occurrence of a particular event (in the conventional
sense). See the chapters on Event-Driven Programming
and Event Delegation.
- event-driven
programming
- A style of programming in which an implicit (often, system-provided)
control loop activates event handler methods when
a relevant event occurs. See the chapters on Event-Driven
Programming and Event Delegation.
-
event handler
- In event-driven
programming, a method that is called when a relevant event
occurs. See the chapters on Event-Driven Programming
and Event Delegation.
- exit
condition
- The condition under which the repeated execution of a loop
stops. Formally called the termination condition for the loop.
- exception
-
A special kind of Java object used to indicate an exceptional
circumstance. Typically used in conjunction with throw
and catch statements. See the chapter on Exceptions.
-
expression
- A piece of Java code with a type
and a value. Contrast statement.
See the chapter on Expressions.
- extend
-
To reuse the implementation supplied by a superclass
through inheritance.
F
- factory
- A class, metaphorically,
for its instances.
- field
-
A data member of a class, i.e., a name
associated with each instance of a class (if not static)
or with the class object itself (if static).
See the chapter on Classes and Objects.
-
field access
- An expression
requiring an object and a field name.
Its type is the declared type of
the field and whose value is the value currently associated
with that field.
- floating point
-
A representation for rational numbers (and an approximation for real numbers)
that uses 32 bits of storage. In Java, implemented by the primitive
type float. Contrast double precision
floating point.
- footprint
- See method
footprint.
G
- global variable
-
A term with no meaning in Java.
- graphical
user interface
- A user interface that makes
use of windows, icons, mouse, etc., and is typically implemented in an event-driven
style. Sometimes abbreviated GUI.
- GUI
-
An acronym for graphical user interface.
H
- hyphen
- - Used as
the unary and binary
subtraction operator and to indicate negative numbers.
I
- identifier
- The formal term for a name.
-
implementor
- The 1. person or 2. entity
that provides the implementation for an interface
or contract.
- implementation
- Executable
code. Also "how to".
- incremental
program design
- The design-build-test-design cycle in which every attempt
is made to keep the program working at all times and to make only minor modifications
between tests.
- inheritance
- The process
by which one class shares the definition and implementation
provided by another. Uses the Java keyword extends.
See the chapter on Inheritance.
- initialization
-
The assignment of an initial value
to a name or, by extension, to an object's
fields.
- instance
-
An object created from a class, whose
type is that class. See the chapter on Classes
and Objects.
- instantiate
- To create
an instance from a class, typically
through the use of a constructor (and new).
-
integer type
- In Java, one of byte,
short, int, long, char, or boolean.
Expressions of these (and only these) types may be used as the test expression
of a switch statement.
- interface
-
1. The common region of contact between two or more entities.
2. (Java) A formal statement of method signatures and constants defining
a type and constraining the behavior of objects implementing
that interface.
See the chapter on Interfaces.
- interface body
- The portion of an interface
declaration containing the interface's members.
The portion of an interface declaration enclosed by { }.
- invocation
-
To call a method, i.e., execute its body,
passing arguments to be associated with the method's parameters.
J
- Java console
-
A place in every Java environment from which standard
input is read and to which standard output
is written. I/O to the Java console is provided by cs101.util.Console,
java.lang.System.in, and java.lang.System.out.
K
- keyword
- A word
with special meaning in Java. All Java keywords are reserved, i.e., cannot
be used as Java names.
L
- label name
- A name capable of referring
to something of an object type, i.e., anything not
of a primitive type. See the chapter on Things,
Types, and Names.
- left-hand side
-
In an assignment, the expression
representing the shoebox or label
to which the value is assigned.
- literal
-
A Java expression to be read literally, i.e., at face
value. Only the primitive types plus strings
have corresponding literal expressions. See the sidebar on Java
Primitive Types in the chapter on Things, Types, and
Names.
- local
- Another term for a variable.
Short for local variable.
- local variable
- The formal term
for a variable.
- logical
operator
- An operator that computes an arithmetic function such as conjunction
or disjunction. See the chapter on Expressions.
-
loop
- A construct by which a sequence of statements
is executed repeatedly, typically until some exit condition is met.
M
- member
- The constructors,
fields, and methods of a class.
Alternately, the (static) fields and (abstract) methods
of an interface. See the chapter on Classes
and Objects.
- method
- An executable class
member. Consists of a signature plus a body
(unless abstract). When a method is invoked on an argument
list, the body is executed with each of the method's parameter
names bound to its corresponding argument.
-
method body
- The portion of a method
that contains executable statements. When a method is
invoked (on a list of arguments),
its body is executed within the scope of the parameter
bindings, i.e., with the parameter names bound to the corresponding arguments.
-
method footprint
-
The name plus the ordered list of parameter
types of a method. An object
may have at most one method with any particular footprint. See the chapter on
Interfaces.
- method invocation
-
See invocation.
- method
overloading
- When one object has two or more methods
with the same name (but different footprints),
typically performing different functions.
- method
signature
- The specification of a method's name,
parameter names and types, return
type, and exceptions, possibly including modifiers.
See the chapter on Interfaces.
- modifier
-
A formal Java term such as abstract, final, public,
static, synchronized, etc., which is used in the declaration
of a class or interface, method,
field, or constructor. See the
Java Charts for details.
N
- name
- A Java expression
that refers to a particular object or value. Examples include variables,
parameters, fields, and type
names. See the chapter on Things, Types, and Names.
-
name binding
- The association of a name
with a value, typically through assignment
or through parameter binding during method
invocation. The details of this association depend on whether the name is
a shoebox name or a label name,
i.e., of primitive or object
type.
- null
- The non-value with
which an unbound label name is
associated.
- null character
- The
character with unicode number 0. Not to be confused with the non-value null.
O
- object
- A non-primitive,
non-null Java Thing. An instance
of (a subclass of) java.lang.Object.
- object type
- In
Java, any type other than one of the eight primitive
types. All object types are named by label names.
-
operand
- One sub-expression of an operator
expression. See the chapter on Expressions.
-
operator
- The part of an operator
expression that determines the particular relationship of the operands
to the expression's value. See the chapter on Expressions.
-
operator expression
- An expression
involving an operator (e.g., +) and one or more operands.
Typically, the value of the expression is a particular function
of the operands, with the operator specifying what function. See the chapter on
Expressions.
- overloading
- See method
overloading.
P
- parameter
-
A name whose scope is a single invocation
of the method to which it belongs. Declared
in the method signature. When the method is invoked
on a list of arguments, each parameter is bound
to the corresponding argument prior to (and with scope over) the execution
of the method body.
- parameter binding
-
The form of name binding that occurs when a method
is invoked on a list of arguments.
Each of the method's parameters is bound to the corresponding
argument, i.e., the first parameter to the first argument, etc.
- peanut
butter
- A gooey brown paste made by grinding up a certain legume, often
consumed with jelly between two slices of very bland white bread.
- period
-
. Sometimes also called "dot". Used in method invocation
and field access expressions, package
naming, and as a decimal point.
- persistent
-
Existing even when not currently the subject of the coder's or computer's attention.
-
pointer
- A term with no meaning in Java.
- postfix
-
Coming after.
- prefix
- Prior to.
-
primitive type
- In Java, one of byte,
short, int, long, float, double,
char, or boolean. All primitive types are named by shoebox
names. See the sidebar on Java
Primitive Types in the chapter on Things, Types, and
Names.
- program
- n. A collection of
executable code.
v. To compose a program. See also incremental
program design, debug.
- programming
language
- A language in which one writes a program. For the purposes of
this book, Java.
Q
R
- reference type
- The formal term for the types
named by a label name.
- reserved
word
- A word that cannot be used as an identifier
in Java, typically because it is a keyword.
- return
type
- The type of the value returned
by a method invocation.
-
rule
- A proto-method. Consists
of a specification and a body.
See the chapter on Statements and Rules.
- rule
body
- The set of statements detailing how a rule
is to be accomplished. A proto-method body. See the
chapter on Statements and Rules.
- rule
specification
- The information needed and provided by a rule.
A proto-signature. See the chapter on Statements
and Rules.
S
- scope
-
The expanse of code within which a name has meaning, i.e., is a valid expression.
See the note on Scoping in the chapter on Expressions.
Not quite.
- self-animating
object
- An object or entity
with its own animacy, i.e., one that runs concurrently
and persistently. See the chapter on Self-Animating
Objects.
- shared reference
-
A situation in which two label names refer to the same
object.
- shoebox name
-
A name capable of referring to something of a primitive
type, whose value is encoded directly in the memory reserved by the name.
The types named by shoebox names are formally called value
types. See the chapter on Things, Types, and Names.
-
side effect
- A change to something that occurs
as a consequence of evaluating an expression.
For example, an assignment.
- signature
-
See method signature.
- slash
-
/ Used to delineate comments and as the division operator.
-
standard input
- The stream
which reads from the Java console. Bound to java.lang.System.in.
-
standard output
- The stream
which writes to the Java console. Bound to java.lang.System.out.
-
statement
- A piece of executable Java code. Has
neither type nor value. Contrast expression.
See the chapter on Statements and Rules.
- stream
-
A persistent Java object which permits the reading or writing of multiple sequential
values. Represents a connection to another (potentially non-Java) entity. Used
for input or output.
- string
- A sequence
of characters. In Java, represented by the object type
String. Although there is no primitive type
representation of strings in Java, they are described in the sidebar on Java
Primitive Types in the chapter on Things, Types, and
Names.
- subclass
- A class
that inherits from another, i.e., extends
that other. Contrast superclass. See the chapter on
Inheritance.
- superclass
-
A class that is inherited from
by another, i.e., the other extends the superclass. Contrast subclass.
See the chapter on Inheritance.
T
- termination condition
- The formal name for an exit
condition.
- Thing
- The nouns of Java,
including Things of primitive type and objects.
See the chapter on Things, Types, and Names.
-
throw statement
-
A particular kind of Java statement, typically used with
exceptions, that causes an object
to be thrown and thereby circumvents the typical return trajectory. See the chapter
on Exceptions.
- throws
clause
- The part of a method signature
which specifies any exceptions thrown
by that method. See the chapter on Exceptions.
-
top level
- Immediately inside the containing structure.
Top level within a class means inside the class body but not inside any other
structure.
- trinary operator
- An
operator that takes three operands.
See the chapter on Expressions.
- type
-
A partial specification of the Thing. In Java, a type is either a primitive
type or an object type. See the chapter on Things,
Types, and Names.
- type-of-thing name-of-thing rule
-
The rule that says: to declare a name,
first state its type, then state its name.
U
unary
operator - An operator that takes one operand.
See the chapter on Expressions.
- unbound
-
The state of a label name when it is not associated
with an object, i.e., has no object referent. In this case,
the label name is associated with the non-value null.
-
unicode
- The representation used by Java for characters.
-
user interface
- The portion of a program
with which a (human) user interacts. See also graphical
user interface.
V
- value
-
Either a primitive value or an object.
-
value type
- The formal term for the types named by
a shoebox name.
- variable
-
A Java name that has scope only from its declaration
to the end of the enclosing block. Variables are formally
called local variables; sometimes, this is abbreviated to locals.
-
virtual machine
- The utility that actually
runs your (compiled) Java program.
- void
-
The return type of a method whose
invocation does not return anything. Contrast
null.
W
X
Y
Z
This course is an adaption for the
Fachhochschule für Technik und Wirtschaft
, Berlin
by
Prof. Dr. Debora
Weber-Wulff
of a part of
Prof. Dr. Lynn Andrea
Stein's
Rethinking CS101 project produced while she was at the MIT
AI Lab
belonging to the
Department
of Electrical Engineering and Computer
Science (EECS) at the
Massachusetts
Institute of Technology. The copyright for
all materials belongs to Lynn Andrea Stein, this adaptation is used
by permission. All rights reserved.
A textbook is in preparation by
Morgan Kaufmann Publishers
Questions or comments:
<weberwu@fhtw-berlin.de>
Last change: 2002-09-29 13:56