Object-oriented Concepts and Definitions
Learning a new language is always jargon heavy. Below, we present several definitions
and object-oriented concepts that you may see throughout the course. When possible, we
provide references to the course text.
[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 is declared with modifier abstract.
The main feature is that the class cannot be substantiated (Gries/Gries pp. 163–164).
- abstract method
-
A method declared with modifier abstract in
an abstract class. Its body is replaced by a ";".
Its main feature is that it must be overridden in any non-abstract
subclass (Gries/Gries p. 163–164).
-
- access modifier
-
Java has four levels of access to components. In order of accessibility,
they are: public, protected,
package, and private.
A component declared with public is
accessible everywhere. A component in a class C declared
with protected is accessible in
C, subclasses of C, and classes in the same package as C. A component
declared with no access modifier is a package component
—it is accessible in all classes in the same package. A component
declared with private is accessible
only within the class in which it is declared (Gries/Gries pp. 155–156).
-
- actual parameter
-
A term used for argument (of a method call).
The term should never be used because it is confusing, especially
because the adjective "actual" tends to be omitted and then it is just parameter,
which is even more confusing).
-
- apparent class
-
The apparent class of a variable is the class-type with which it
is declared. It is a syntactic property. It determines which components
can be referenced (Gries/Gries p. 150).
-
- applet
-
An applet is a Java program that contains a subclass of
java.awt.Applet or javax.swing.JApplet. It can appear on web pages.
(Gries/Gries pp. 438–444).
-
- application
-
A Java application is a program that has a class that contains a
static procedure defined like this:
public static void main(String[] pars) {...}
An application can be executed without using an IDE, as a stand-alone
program. The text explains how to create this stand-alone program,
in what is called a jar file (Gries/Gries
pp. 435–437.
- argument
-
An expression that occurs within the parentheses of a method call.
The following call has two arguments: x+y and y+w:
min(x+y, y+w)
The number of arguments must equal the number of parameters of the
method that is being called, and the type of each argument must be
the same as or narrower than the type of the corresponding parameter (Gries/Gries
pp. 59, 62.
- assertion
-
A true-false statement about the variables in a program that is placed
as a comment at a particular place in the program to indicate that
the true-false statement is true at that place. See also precondition and postcondition (Gries/Gries pp. 75, 506–507).
-
- boolean
-
A primitive type whose values are true and false.
Gries/Gries pp. 226–229).
-
- Boolean, class
-
A wrapper class for type boolean.
(Gries/Gries pp. 174–175).
-
- bottom-up rule
-
The rule that indicates that, when looking for a variable or method
in an object, start from the bottom and look upward. This rule ensures
that an overriding method will be called (if present) rather than
an inherited one (Gries/Gries, pp. 143–144).
-
- byte
-
A primitive type whose values are integers in the range
–2^8 .. 2^8 – 1 (Gries/Gries pp. 218–219).
-
- Byte, class
-
A wrapper class for type byte.
(Gries/Gries pp. 174–175).
-
- cast
-
A cast is an operation that converts a value from one type to another.
For example, the cast
(double)(5+6)
converts the value of the expression, which is 11, to double
format. A widening cast may be done implicitly; a narrowing cast must be done
explicitly, because it may lose information or may be illegal.
See narrower type).
-
- char
-
A primitive type whose values are single characters, like
'h', '$', and '\n'
(Gries/Gries pp. 224–225).
-
- Character, class
-
A wrapper class for type char.
Gries/Gries pp. 174–175).
-
- class
-
A class definition defines the format of objects (or
instances or folders) of the class —it defines the methods and
fields that go in each object of the class.
For the basic syntax of a class definition, see Gries/Gries p. 107 and
(for a subclass definition) p. 142.
The class definition also defines the static variables
(class variables) and static methods (class methods).
A class can be used as a type. If C is
(the name of) a class, then C v; declares a variable
v that contains either null or
the name (on the tab) of an object of class C).
-
- class, apparent
-
See apparent class).
-
- class as a type
-
A class name can be used as a type. Its values are the names of objects
of that class. For example, the declaration JFrame j indicates
that variable j can contain values that are the names of objects
of class JFrame).
-
- class invariant
-
The collection of meanings and constraints on the fields of a class
that describe the valid states of all instances of the class before
and after each method is called. The class invariant should appear
as comments on the declarations of the fields. A constructor should
truthify the class invariant. Each method body can assume that the
class invariant is true and should terminate with the class invariant
true, for all objects (Gries/Gries pp. 146–147).
-
- class method
-
See static method).
-
- class, real
-
See real class).
-
- class type
-
A type that is the name of a class. Its values are the names of objects
of that class (Gries/Gries, pp. 115–116).
-
- class variable
-
Same as a static variable).
-
- component
-
A component of a class is a variable or method that is declared in
the class or is inherited from the superclass.
Gries/Gries, p. 39, 82).
-
- conditional expression
-
An expression of the form <boolean-expression> ? <expression-1> : <expression-2>.
To evaluate it, evaluate the <boolean-expression>; if it is true, use the value of
<expression-1> as the value of the conditional expression; otherwise, use the value of
<expression-2> as the value of the conditional expression).
-
- constructor
-
A method that is declared with the basic form:
<access modifier> <class-name> ( <parameters> ){ ... }
The purpose of a constructor is to initialize some or all of the fields
of a new instance of class <class-name> when the instance is created.
See also constructor call (Gries/Gries,
pp. 110–112, 147–148).
-
- constructor call
-
A call of a constructor. There are three
ways to call a constructor —the last two ways may appear only as
the first statement of a constructor body:
1. In a new-expression.
2. As a call of another constructor in the same class: this(<arguments>);.
3. As a call of a constructor of the superclass: super(<arguments>);.
(Gries/Gries, pp. 112, 116, 147).
-
- constructor call, default
-
If (and only if) the body of a constructor does not contain a constructor call as its first statement,
Java automatically inserts this one: super();.
(Gries/Gries, pp. 148).
-
- constructor, default
-
If (and only if) a class definition does not contain a constructor, the following
one is automatically inserted in the class:
public<class-name>()
{super();}
(Gries/Gries, p. 111). This page has a mistake, in that the default
constructor is shown with an empty body, whereas it contains the
call super();.
- default values
-
Fields (both static and non-static) have default values (if they
are not initialized), as follows:
Numeric-type fields
|
0
|
boolean fields
|
false
|
char fields
|
'\u0000'
|
class-type fields
|
null
|
Local variables do not have initial default values and are expected
to be assigned before referenced (Gries/Gries, p. 107).
- deprecate
-
To deprecate means to lessen in value.
Some classes and methods within classes in the Java API package have
been deprecated because they have been superceded by newer ones that
do a better job. You can still use the deprecated entities, but it
is better if you don't (Gries/Gries, p. 495).
-
- double
-
A primitive type whose values are scientific
numbers, e.g. 3.46E–4. Each value occupies 64 bits (Gries/Gries
pp. 221–224).
-
- Double, class
-
A wrapper class for type double.
Gries/Gries pp. 174–175).
-
- escape character: \
-
Character \, the escape character, is used to write characters that cannot appear directly
in a String. Here are a few (not exhaustive) examples:
New-line Character
|
\n
|
Backslash Character
|
\\
|
Double-Quote Character
|
\"
|
Single-Quote Character
|
\'
|
The last example is special; you can use ' in a String, but as a character you must write '\''.
- extends clause
-
A clause, extends ,
put on a class definition to indicate that the defined class is a subclass
of class C and that C is a
superclass of the defined class. The subclass
inherits all components defined in and inherited by the superclass
(Gries/Gries, pp. 142-143).
-
- field
-
A variable belonging to a class
- a static field - or object -
an non-static field (Gries/Gries p. 107).
-
- file drawer
-
In order to provide an easy-to-understand introduction to classes
and objects, we view a class as a file drawer, which holds (1) the
objects (i.e. manila folders) and (2) the static variables and
methods. The Java class definition defines the format of the content
manila folders (see class).
-
- float
-
A primitive type whose values are scientific
numbers, e.g. 3.46E–4. Each value occupies 32 bits (Gries/Gries pp.
224).
-
- Float, class
-
A wrapper class for type float.
(Gries/Gries pp. 174–175).
-
- folder, manila
-
Our analogy for an object or instance.
-
- formal parameter
-
We use the term parameter (of a method) instead of
formal parameter and argument (of a method call) instead of
actual parameter.
The terms formal parameter and actual parameter should be
avoided because they are confusing, especially because the
adjectives - which differentiate them - tend to be forgotten.
-
- frame for a call
-
When a method is called, a frame is created for the call. This frame contains the following:
- the name of the method
- a program counter, which indicates the statement to execute next
- a scope box, containing the name of the class or object in which the method resides
- the parameters of the method
- the local variables of the method
(Gries/Gries, pp. 93–94).
- function
-
A method that is declared with the basic form:
<access modifier> <return-type> <function-name>( <parameters> ){ ... }
Execution of the body of the function must terminate by with executing a
return statement, giving an expression whose value is to be
returned. A call on a function is an expression and thus yields a value.
(Gries/Gries, pp. 55–58).
-
- function call
-
A function call is an expression, so it can be placed wherever an
expression (of the appropriate type) can be placed. Its form is one
of the following:
-
For a static function:
<class-name> . <function-name> ( <arguments> )
-
For a non-static function:
<expression> . <function-name> ( <arguments> )
where the <expression> evaluates to the name of an object that contains the function called.
Both "<class-name>." and
"<expression>." can be omitted if the
call appears in a place in which the function can be called without them (Gries/Gries, p. 62).
-
- getter method
-
A non-static function whose purpose is to retrieve a value from the
object in which the method appears —the value is usually in a field
of the object. If the field to be retrieved is named xab,
by convention, the name of the getter method is getXab.
(Gries/Gries, p. 35, 109).
-
- header, of a method
-
The part of a declaration of a method that gives the access
modifiers, prefixes like static, the return
type or void, the method name, and
the parameter declarations delimited by parentheses. Thus, it is
the complete method declaration except for the method body (Gries/Gries, p. 57).
-
- implements clause
-
The implements clause, implements <interface-name>,
on a class indicates that the class overrides all abstract methods
declared in the interface (Gries/Gries, pp. 336–337).
-
- import statement
-
The import statement has one of the following forms:
import <path>.<class-name>
; // import a particular class
import <path>.*
; // import all classes in the package
where the <path> is a path of the API package (e.g. javax.swing)
or a path to a directory on your hard drive that represents a package of classes.
It is placed as the first statement of a file that contains a class definition
in order to indicate that the class may refer to the classes in the directory
given by the <path> (Gries/Gries, pp. 31–32, 330–331).
-
- inheritance
-
A subclass inherits all the instance fields and methods available
in its superclass. This means that each instance of the subclass
contains not only the instance fields and methods defined in it but
also the instance fields and methods defined in an inherited by the superclass
(Gries/Gries, pp. 143–144).
-
- inside-out rule
-
A rule, used in most programming languages, that indicates how to determine
what a reference to a variable or a method means (e.g. which declaration it refers to)
(Gries/Gries, pp. 83, 109–110).
-
- instance
-
An instance of a class is an object; in our
analogy instance, object, and manila folder are synonyms
(Gries/Gries, p. 31).
-
- instance method
-
A method that is defined without modifier
static in a class. A copy of the method resides in each
instance of the class. (Gries/Gries, p. 3, 107).
-
- instanceof
-
Operation <object-expression> instanceof <class-name>
yields true iff the object whose name is given by
<object-expression> is an instance of class <class-name> or of a
subclass of <class-name> (Gries/Gries, p. 150, 152–153).
-
- instance variable
-
A variable that is defined without modifier
static in a class. Also called a field. A copy
of the variable resides in each instance of the class
(Gries/Gries, p. 31, 45–46).
-
- instantiate
-
To create an instance of. So, evaluation of a new-expression
new C(...) instantiates
class C, producing a new instance of it.
-
- int
-
A primitive type whose values are integers
in the range –2^31 .. 2^31 – 1 (Gries/Gries pp. 216–218).
-
- Integer, class
-
A wrapper class for type int.
(Gries/Gries pp. 172–174).
-
- integral types
-
The Java primitive types whose values
are integers: byte, short, int,
long, and char (Gries/Gries, pp. 215–221).
-
- interface
-
An interface provides a way to ensure syntactically (at compile time)
that a class implements certain methods. The interface defines the
methods abstractly (without bodies), and the class definition then
includes an implements clause to
indicate that it will define the methods (Gries/Gries, pp. 335–47).
-
- invariant
-
See class invariant.
-
- literal
-
A Java denotation of a value. Literals are used to initialize any of the
primitive types, or
initialize Strings. Here are a few examples of literals:
Type int
|
354
|
Type double
|
3.56
|
Type long
|
1356099454469L
|
Type float
|
3.56f
|
Type boolean
|
true
|
Type char
|
'c'
|
Type String
|
" Hello World!"
|
- local variable
-
A variable that is declared within the body
of a method (Gries/Gries, pp. 76–78).
-
- long
-
A primitive type whose values are integers
in the range –2^63 .. 2^63 – 1 (Gries/Gries pp. 219–220).
-
- Long, class
-
A wrapper class for type long.
(Gries/Gries pp. 174–175).
-
- manila folder
-
Our analogy for an object or instance.
-
- Math, class
-
Class Math, in package java.lang,
contains several useful mathematical functions. Examples include sin(...),
tan(...), ceil(...)— it also includes
the constants PI and E
(Gries/Gries, pp. 23–25).
-
- method
-
A set of instructions to be carried out. A method is analogous to a recipe in a cookbook.
Java has three kinds of method: function, procedure,
and constructor.
(Gries/Gries, pp. 55–99).
-
- method body
-
A method consists of a method header followed by the method body,
which has the following form:
{ <sequence of statements/declarations> }
When the method is called, its body is executed
(Gries/Gries, pp. 64–71).
-
- method call
-
An expression or statement that ends up executing the method body.
See function call, procedure call,
and constructor call. It is important to understand how a method
call is executed. Its execution is performed in four steps:
- Draw a frame for the call
- Assign argument values to the parameters
- Execute the method body
- Erase the frame for the call
(and, if a function, return the function value)
(Gries/Gries, pp. 59–62, 162–163).
-
- method header
-
(See header, of a method).
-
- method name
-
The name of the method, defined in the method header.
-
- method main
-
A Java program becomes an application when a static procedure main
is defined that has one parameter, of type String[]. The application
can be started without having to have an IDE around. To start execution, this method
main is called (Gries/Gries, pp. 435–437).
- method signature
-
The method name together with the types of its parameters. For example,
one method in class Math has signature
min(int, int).
(Gries/Gries, pp. 57).
-
- method specification
-
The specification of a method defines what the method does. It is
used to understand how to write calls on the method. It must be clear,
precise, and thorough, and it should mention all parameters, saying
what they are used for. It is a contract between the programmer who
wrote the method and users of the method. It may be given in terms
of a precondition and postcondition.
(See Gries/Gries, pp. 376–379 for more details).
-
- narrower type
-
A type from which Java will perform a cast automatically; that is Java
will automatically cast from a narrower type to a wider type. However, casts from a wider type
to a narrower type must be explicitly asked for in a Java program.
Below, each line gives a series of types, beginning with the narrowest type and proceeding to
the widest type:
byte --> short --> int --> long --> float --> double
char --> int --> long --> float --> double
subclass --> superclass
(Gries/Gries, pp. 225–226, 151–152).
-
- new-expression
-
The new-expression has the form new <class-name>( <arguments> ).
It is evaluated in three steps:
- Create an instance of class <class-name>;
- Execute the constructor call <class-name>(<arguments>);
- Yield as value the name of the newly created instance
(Gries/Gries, pp. 116–117).
-
- non-static variable
-
(See instance).
-
- non-static method
-
(See instance method).
-
- null
-
A value that means "the absence of an object name". If a reference
like null.b or a method call like
null.m(...) is attempted at runtime,
a "null pointer exception" happens (Gries/Gries, p. 38).
-
- object
-
An instance of a class; in our analogy we often refer to these as a manila
folder. Each object of a class contains the non-static fields
and methods defined in and inherited by the class
(See class).
-
- Object, class
-
The superest class of them all: any class that does not explicitly
extend another class automatically extends class Object
(Gries/Gries, p. 154).
-
- object type
-
(See class type).
-
- overloaded
-
A method name is overloaded if there are two methods with the same name but different
signatures. For example, in class Math,
there are functions with signatures
min(int, int) and
min(double, double).
(Gries/Gries, p. 23).
-
- override
-
A method that is inherited from the superclass can be overridden
by redeclaring it in the subclass. The bottom-up rule ensures that
the overriding method will be called, rather than the inherited one.
-
- package
-
A package consists of the classes that are contained in a specific
directory on your hard drive (or the API packages, like javax.swing
and java.lang). The package statement itself is beyond the scope
of this course, although it is discussed in the text
(Gries/Gries, pp. 329–334).
-
- parameter
-
A variable that is declared within the parentheses of the
header of a method (Gries/Gries, pp. 56–58).
-
- parameter declaration
-
A parameter declaration occurs within the parentheses of the
header of a method. It has the form <type> <variable-name>
(Gries/Gries, pp. 57-58).
-
- postcondition
-
An assertion that indicates what is to be
true at the end of execution of a method body —or, more generally,
of any sequence of statements (Gries/Gries, pp. 93, 506).
-
- precedence of operators
-
Standard mathematics gives precedence to multiplication * over addition +, so that the
expression 2 + 3 * 5 is evaluated as if it were parenthesized like this: 2 + (3 * 5).
The precedences used in Java for all operators are given on
this page.
-
- precondition
-
An assertion that indicates what is to be
true at the beginning of execution of a method body —o r, more
generally, of any sequence of statements. The following example illustrates our convention
for preconditions of a method. The specification of method m states that in any call of m,
its argument must be at least 0. If the argument is less than 0, it is the user's fault,
and the specification says nothing about what the method will do in that case.
The method does not have to check for that condition.
/** ...
Precondition: x >= 0 */
public void m(int x) {
(Gries/Gries, pp. 93, 506).
- primitive type
-
A type that is fully integrated into Java. In other words, one
one that is not defined by a class definition.
The primitive types of Java are: char, byte,
short, int, long,
float, double, and boolean.
(Gries/Gries pp. 215–216).
-
- private
-
An access modifier. A variable or
method that is declared with this modifier can be referenced only
within the class in which the declaration occurs
(Gries/Gries, pp. 155–156).
-
- procedure
-
A method that is declared with the following basic form:
<access modifier> void <function-name>( <parameters> ){ ... }
A call of a procedure is a statement
(Gries/Gries, pp. 55–58).
- procedure call
-
A procedure call is a statement. Its form is one
of the following:
-
For a static function:
<class-name> . <function-name> ( <arguments> )
-
For a non-static function:
<expression> . <function-name> ( <arguments> )
where the <expression> evaluates to the name of an object that contains the function called.
Both "<class-name>." and
"<expression>." can be omitted if the
call appears in a place in which the function can be called without them (Gries/Gries, p. 59–60).
-
- promoting a value
-
Same as casting it to a wider type, this is done automatically
in Java when necessary. See narrower type (Gries/Gries, p. 220).
-
- public
-
An access modifier: the variable or
method that is declared with this modifier can be referenced everywhere.
Gries/Gries, pp. 155–156).
-
- real class
-
The real class of a variable is the class of the object whose name
is in the variable. The real class can change at runtime, when a
new object (i.e. object name) is stored in the variable (Gries/Gries p. 150).
-
- return statement
-
A statement which terminates the execution of the method body in which it occurs and, in
the case of a function, returns the value of the <expression> as the value
of the function call. In a procedure, a return statement has the following form:
return;
On the other hand, a return statement in a function has the following form:
return <expression>;
(Gries/Gries p. 150).
-
- runtime
-
Runtime refers to the time when a Java program is "running", or being executed. This is
in contrast to compile time which refers to when a Java program is being compiled (i.e. being
checked for syntax errors and being translated into a machine language program).
-
- scope
-
The scope of a variable is the set of statements in which it can
be referenced. For a parameter, it is the body of the method in which
the parameter is declared. For a local variable, it is from its declaration
to the end of the block in which the declaration occurs
(Gries/Gries, pp. 65, 76–78).
-
- scope box
-
A box within the frame for a method call that
contains the name of the class (for a static method) or object (for
an instance method) in which the method resides
(Gries/Gries, pp. 93–94).
-
- setter method
-
A non-static procedure whose purpose is to store a value in a field
of the object in which the method resides. If the field is named xab,
by convention, the name of the setter procedure is setXab.
(Gries/Gries, p. 35, 109).
-
- short
-
A primitive type whose values are integers
in the range –2^15 .. 2^15 – 1 (Gries/Gries pp. 218–219).
-
- Short, class
-
A wrapper class for type short.
(Gries/Gries pp. 174–175).
-
- signature
-
(See method signature).
-
- specification, of a class
-
A description of what a class is for. Generally speaking, it indicates
what an instance of the class represents.
- specification, of a method
-
(See method specification).
-
- static
-
(See either static method or static variable).
-
- static field
-
(See static variable).
-
- static method
-
A method that is declared with attribute static.
There is only one copy of the method, and it resides in the class
itself (in the class file drawer) (Gries/Gries, p. 124).
-
- static variable
-
A variable or field declared in a class definition with attribute
static. There is only one copy of the variable.
It is created when execution of the program starts, and it resides in the class itself
(in the class file drawer)
(Gries/Gries, pp. 122–124).
-
- String, class
-
The values of class String are objects
that contain sequences of characters (Gries/Gries, pp. 175–181).
-
- subclass
-
Class SC is a subclass of class C,
and C is the superclass of SC,
if the definition of class SC has an extends
clause extends C. This means that every instance of class
SC inherits all
the components of class C (Gries/Gries, pp. 141–162).
-
- super
-
A keyword that is used in two ways. First, to call an inherited function instead of an
overriding one. Second, to call a constructor of a superclass
(Gries/Gries, pp. 144–146, 147–148).
-
- superclass
-
(See subclass).
-
- this
-
A keyword that is used in two ways. First, as a name for the object in which it appears
(e.g. this.getName()). Second, to call another constructor
of the class in which it appears (e.g. this(3, 5);).
(Gries/Gries, pp. 109–110, 112).
-
- toString function
-
A Java convention is to write an instance function toString() that
yields a description of the object in which it resides
(Gries/Gries, pp. 112–113).
-
- type
-
A set of values together with operations on them (Gries/Gries, pp. 17).
-
- variable
-
A name with an associated value. Sometimes viewed as a named box
with the value in the box. In Java, a variable has a type,
which defines the set of values that can go in its box. In Java, there are four kinds
of variable: parameter, local variable,
instance variable (or field), and class variable
(or static variable)
(Gries/Gries, pp. 26–28).
-
- variable declaration
-
The basic form of a variable declaration is
<type> <variable-name>.
Depending on the kind of variable being declared, there may be modifiers.
See parameter, local variable,
instance variable, and
static variable for more
(Gries/Gries,pp. 28).
-
- wider type
-
A type to which Java will perform a cast automatically; that is Java
will automatically cast from a narrower type to a wider type.
See narrower type for more information.
-
- wrapper class
-
Each of the primitive types of Java has an associated
wrapper class. For example, the wrapper class for type int
is Integer. Each instance of the wrapper class contains, or wraps,
one value of the primitive type, thus allowing a primitive type value to be
viewed as an object. In addition, the wrapper class provides functions
for manipulating values of the primitive type and may also include a few constants
(Gries/Gries, pp. 172–175).
-
|