HTW Berlin Medieninformatik HTW Berlin
Fachbereich 4
Internationaler Studiengang
Internationale Medieninformatik (Bachelor)
Info 1: Informatik I
Summer Term 2019
Course Glossary

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


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 { }.
interoperability
The capabability for easily exchanging data between applications.
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
  1. n. A collection of executable code.
  2. 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

 

   


Copyright Prof. Dr. Debora Weber-Wulff
Questions or comments: <weberwu@htw-berlin.de>
Some rights reserved. CC-BY-NC-SA - Copyright and Warranty

The exercises are adapted from Objects First with Java, A Practical Introduction Using BlueJ. David Barnes & Michael Kölling, 2016

Last change: 2009-03-28 16:34