M/F 2:30-3:20   
in Philips 101

CS 1130: Transition to OO Programming

Spring 2015

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:
  1. the name of the method
  2. a program counter, which indicates the statement to execute next
  3. a scope box, containing the name of the class or object in which the method resides
  4. the parameters of the method
  5. 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:
  1. Draw a frame for the call
  2. Assign argument values to the parameters
  3. Execute the method body
  4. 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:
  1. Create an instance of class <class-name>;
  2. Execute the constructor call <class-name>(<arguments>);
  3. 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).