CSE 2221 Midterm 2

Kernel Interface Design

The fundamental set of operations that define the core functionality of a component, forming the minimum necessary interface.

Constructor

A special method that initializes a newly created object and sets up its initial state.

No-Argument Constructor

A constructor that takes no parameters and creates an object with default initial values.

Copy Constructor

A constructor that creates a new object as a copy of an existing object.

Instance Method

A method that belongs to an instance of a class and operates on that specific object's data.

Receiver

The object on which an instance method is called (the object before the dot in method invocation).

Distinguished Formal Parameter

A special parameter in method documentation that represents the receiver object itself.

Parameter Modes

Specifications that describe how parameters are used by a method (restores, updates, replaces, clears).

Default Parameter Mode

The standard mode for parameters when no specific mode is declared (typically restores mode).

Primitive Type

Basic data types built into Java (int, double, boolean, char, etc.) that store actual values.

Reference Type

Types that store references (memory addresses) to objects rather than the actual object values.

Immutable Reference Type

A reference type whose object state cannot be changed after creation (e.g., String, Integer).

Mutable Reference Type

A reference type whose object state can be modified after creation (e.g., NaturalNumber, arrays).

Reference Diagrams

Visual representations showing how variables reference objects in memory.

Reference Value

The memory address or pointer that a reference variable holds.

Object Value

The actual data/state stored in an object in memory.

Assignment Operator (with Reference Types)

The = operator, which copies reference values (not object values) when used with reference types.

Call-by-Copy (with Reference Types)

Parameter passing mechanism where reference values are copied, allowing methods to access the same objects.

Garbage Collector

Java's automatic memory management system that removes objects no longer referenced by any variable.

Aliases / Aliasing of References

When multiple reference variables point to the same object in memory.

Arrays (Mutable Reference Type)

Fixed-size collections of elements that are reference types and can be modified after creation.

Scope

The region of code where a variable is accessible and valid.

Repeated Arguments

When the same object is passed multiple times as different parameters to a method.

NaturalNumber

A component representing non-negative integers with operations defined in its interface.

Standard

A secondary interface that extends a kernel interface with additional convenience operations.

@restores

Parameter mode indicating the method does not change the parameter's value.

@updates

Parameter mode indicating the method may modify the parameter's value.

@replaces

Parameter mode indicating the method replaces the parameter's value with a new value.

@clears

Parameter mode indicating the method changes the parameter to its initial (empty/zero) value.

== (with Reference Types)

Equality operator that compares reference values (checks if two variables point to the same object).

equals

Method that compares object values (checks if two objects have equivalent content/state).

Arrays.equals

Static method that compares arrays element-by-element for value equality.

null

Special reference value indicating a variable points to no object.

NullPointerException

Runtime error thrown when attempting to use a reference variable that has null value.

Interval Halving / Binary Search

Algorithm that repeatedly divides a search interval in half to efficiently find a target value.

Mathematical String Notation

Formal notation system for representing and reasoning about strings mathematically.

Empty String (Math)

A string with no characters, denoted as ε or "" with length 0.

Concatenation

Operation that joins two strings together end-to-end.

Substring

A contiguous sequence of characters within a string.

Prefix

A substring that starts at the beginning of a string.

Suffix

A substring that extends to the end of a string.

Substring Notation (Interval Notation)

Mathematical notation for extracting substrings using index intervals, like s[i,j).

Permutation

A rearrangement of elements where order matters, or the set of all possible rearrangements.

Fast Powering Algorithm

Efficient recursive algorithm for computing powers using repeated squaring.

|s|

Mathematical notation representing the length of string s.

rev(s)

Mathematical function that returns the reverse of string s.

perms(s1, s2)

Mathematical function that returns all permutations of strings s1 and s2 combined.

count(s, x)

Mathematical function that counts occurrences of character x in string s.

Recursion / Recursiveness

Programming technique where a method calls itself to solve a problem.

Recursive Structure

Data organization where elements are defined in terms of smaller versions of themselves.

Recursive Method

A method that includes at least one call to itself within its definition.

Recursive Design Strategy (FreeLunch)

Design approach that breaks problems into smaller self-similar subproblems.

Confidence-Building Argument

Reasoning that shows a recursive method works by verifying base cases and inductive steps.

Size Metric

A measure that decreases with each recursive call, ensuring the recursion eventually terminates.

Mathematical Induction

Proof technique that establishes a base case and shows if property holds for n, it holds for n+1.

Recursion on Trees

Recursive algorithms that process tree structures by recursively handling subtrees.

Inheritance

Mechanism where a class or interface acquires properties and behaviors from a parent class or interface.

Subinterface / Child Interface

An interface that extends another interface, inheriting its method declarations.

Superinterface / Parent Interface

An interface that is extended by another interface.

Subclass / Child Class

A class that extends another class, inheriting its fields and methods.

Superclass / Parent Class

A class that is extended by another class.

Overriding

Providing a new implementation of a method inherited from a superclass or interface.

Overloading

Defining multiple methods with the same name but different parameter lists in the same class.

Declared Type / Static Type

The type specified in a variable's declaration (known at compile time).

Interface Type

A declared type that specifies a contract of methods without implementation.

Instantiation

The process of creating an actual object instance from a class using the new keyword.

Object Type / Dynamic Type

The actual class type of an object created at runtime.

Polymorphism

Ability of objects of different types to be accessed through the same interface or to respond differently to the same method call.

implements

Keyword indicating a class provides implementations for all methods declared in an interface.

extends

Keyword indicating a class inherits from a superclass or an interface inherits from a superinterface.

super

Keyword used to reference the superclass or call superclass methods/constructors.

@Override

Annotation indicating a method is intended to override a method from a superclass or interface.

Unit Testing

Testing individual components or methods in isolation to verify they work correctly.

Integration Testing

Testing how multiple components work together when combined.

System Testing

Testing the complete, integrated system to verify it meets requirements.

Unit Under Test (UUT)

The specific component or method being tested.

Testing Mindset

Approach focused on finding defects and edge cases rather than confirming code works.

Test Case

A single test with specific inputs, expected outputs, and execution conditions.

Test Plan / Test Fixture

Collection of test cases organized to thoroughly test a component.

Boundary Cases

Tests at the edges of valid input ranges (e.g., empty, minimum, maximum values).

Routine Cases

Common, typical inputs that represent normal use of the component.

Challenging Cases

Complex or unusual inputs that stress-test the component's logic.

JUnit

Java testing framework that provides tools for writing and running unit tests.

@Test

Annotation that marks a method as a JUnit test case.