| Term | Definition |
|---|---|
| boolean | A primitive data type that holds one of two values: true or false. |
| Boolean value | Data values that can only be true or false, used in logical operations and conditional statements. |
| data type | A classification that specifies what kind of value a variable can store and what operations can be performed on it. |
| double | A primitive data type used to store real numbers (numbers with decimal points). |
| int | A primitive data type used to store integer values (whole numbers). |
| primitive data type | Basic data types in Java such as int, double, boolean, and char that are not objects. |
| reference type | A data type that holds a reference (memory address) to an object rather than storing the object's value directly. |
| variable | A named storage location in a program that holds a value of a specific data type; the value can change while the program is running. |
| Term | Definition |
|---|---|
| arithmetic expression | Mathematical expressions consisting of numeric values, variables, and operators that perform calculations. |
| casting | The process of converting a value from one primitive data type to another, such as from double to int or int to double. |
| casting operator | Operators used to convert a value from one data type to another, such as converting a double to an int. |
| data type | A classification that specifies what kind of value a variable can store and what operations can be performed on it. |
| double | A primitive data type used to store real numbers (numbers with decimal points). |
| int | A primitive data type used to store integer values (whole numbers). |
| integer expression | A mathematical or computational expression that evaluates to an integer value. |
| integer overflow | An error that occurs when an integer expression evaluates to a value outside the allowed range for the int data type, resulting in an unexpected value. |
| Integer.MAX_VALUE | A Java constant that holds the largest possible value that can be stored in an int variable. |
| Integer.MIN_VALUE | A Java constant that holds the smallest possible value that can be stored in an int variable. |
| out of range | A value that exceeds the maximum or minimum limits allowed for a particular data type. |
| precision | The degree of exactness with which a floating-point number can be represented in computer memory. |
| primitive data type | Basic data types in Java such as int, double, boolean, and char that are not objects. |
| round-off error | An error that occurs when a computed value cannot be exactly represented in the available memory and must be rounded to the nearest representable value. |
| rounding | The process of converting a decimal number to the nearest integer value. |
| truncation | The removal of digits to the right of the decimal point when casting a double value to an int value. |
| widening | The automatic conversion of a value from a smaller primitive type (like int) to a larger primitive type (like double). |
| Term | Definition |
|---|---|
| API | An application programming interface that provides a specification informing programmers how to use classes and libraries. |
| attribute | The data or properties that define the state of an object or class. |
| behavior | The methods or actions that an object or class can perform. |
| class | A formal implementation or blueprint that defines the attributes and behaviors of objects. |
| library | Collections of classes that can be utilized to create objects and are documented in API specifications. |
| method | A named block of code that only runs when it is called, allowing programmers to reuse code and organize programs into logical sections. |
| object | A specific instance of a class with defined attributes and behaviors. |
| package | Organizational groupings of classes within APIs and libraries. |
| reference type | A data type that holds a reference (memory address) to an object rather than storing the object's value directly. |
| Term | Definition |
|---|---|
| addition | The arithmetic operator (+) that combines two numeric values to produce their sum. |
| arithmetic expression | Mathematical expressions consisting of numeric values, variables, and operators that perform calculations. |
| ArithmeticException | An exception that occurs when attempting to divide an integer by zero. |
| compound expression | Expressions that use multiple operators to combine numeric values. |
| division | The arithmetic operator (/) that divides one numeric value by another. |
| double | A primitive data type used to store real numbers (numbers with decimal points). |
| escape sequence | A special sequence of characters starting with a backslash that has a special meaning in Java, such as \" for double quote, \\ for backslash, and \n for newline. |
| int | A primitive data type used to store integer values (whole numbers). |
| integer division | Division of two int values that results in only the integer portion of the quotient, discarding any fractional part. |
| literal | The code representation of a fixed value. |
| multiplication | The arithmetic operator (*) that produces the product of two numeric values. |
| numeric value | Numbers used in expressions, which can be of type int or double. |
| operator | Symbols that perform operations on numeric values in expressions. |
| operator precedence | The rules that determine the order in which operators are evaluated in an expression, with multiplication, division, and remainder evaluated before addition and subtraction. |
| parentheses | Symbols used to modify operator precedence and control the order of operations in an expression. |
| remainder operator | The operator (%) that computes the remainder when one number is divided by another. |
| string literal | A sequence of characters enclosed in double quotes used to create a String object directly in code. |
| subtraction | The arithmetic operator (-) that finds the difference between two numeric values. |
| System.out.print | A Java method that displays information on the computer display without moving the cursor to a new line after the output. |
| System.out.println | A Java method that displays information on the computer display and moves the cursor to a new line after the output. |
| variable | A named storage location in a program that holds a value of a specific data type; the value can change while the program is running. |
| Term | Definition |
|---|---|
| call by value | A method of passing arguments where the parameters are initialized with copies of the argument values rather than references to the original values. |
| constructor | A special method that is called to create and initialize an object of a class, having the same name as the class. |
| constructor argument | A value passed to a constructor when it is called that must match the type, order, and number of parameters in the constructor signature. |
| constructor signature | The combination of a constructor's name (same as the class name) and its ordered list of parameter types that uniquely identifies the constructor. |
| flow of control | The order in which statements in a program are executed, which can be interrupted by method calls and resumed after the method completes. |
| new | A Java keyword used to create a new instance of a class by allocating memory and calling the constructor. |
| null | A special value indicating that a reference variable does not currently reference any object. |
| object | A specific instance of a class with defined attributes and behaviors. |
| object reference | A value that points to the memory location where an object is stored, allowing access to that object. |
| overloaded constructor | Multiple constructors in the same class that have different signatures, allowing objects to be created with different sets of parameters. |
| parameter | A variable declared in the header of a method or constructor that receives values passed to the method when it is called. |
| parameter types | The data types of the values that are passed to a constructor or method. |
| reference type | A data type that holds a reference (memory address) to an object rather than storing the object's value directly. |
| variable | A named storage location in a program that holds a value of a specific data type; the value can change while the program is running. |
| Term | Definition |
|---|---|
| dot operator | The symbol (.) used in Java to access instance methods and properties of an object. |
| instance methods | Methods that belong to an object and are called on specific instances of a class using the dot operator. |
| null reference | A reference variable that points to no object, which will cause a NullPointerException if an instance method is called on it. |
| NullPointerException | An exception that occurs when a method is called on a null reference instead of a valid object. |
| Term | Definition |
|---|---|
| class methods | Methods that are associated with a class rather than with instances of the class, and include the static keyword in their header. |
| dot operator | The symbol (.) used in Java to access instance methods and properties of an object. |
| static | A keyword used in a method header to indicate that the method is a class method associated with the class itself, not with individual instances. |
| Term | Definition |
|---|---|
| abs() | A Math class method that returns the absolute value of a numeric parameter. |
| built-in mathematical libraries | Pre-written code libraries in Java that contain mathematical functions and methods available for use without needing to write them from scratch. |
| casting operator | Operators used to convert a value from one data type to another, such as converting a double to an int. |
| class methods | Methods that are associated with a class rather than with instances of the class, and include the static keyword in their header. |
| exclusive endpoint | An endpoint of a range where the boundary value is not included in the possible results. |
| inclusive endpoint | An endpoint of a range where the boundary value is included in the possible results. |
| java.lang package | A Java package containing fundamental classes that are automatically available without explicit import statements. |
| Math class | A Java class in the java.lang package that contains static methods for performing mathematical operations. |
| pow() | A Math class method that returns the value of the first parameter raised to the power of the second parameter. |
| random() | A Math class method that returns a random double value greater than or equal to 0.0 and less than 1.0. |
| sqrt() | A Math class method that returns the nonnegative square root of a double value. |
| Term | Definition |
|---|---|
| compareTo() method | A String method that compares two strings alphabetically and returns a negative value if the first string is less than the second, zero if they are equal, or a positive value if the first string is greater than the second. |
| concatenation | The process of combining two or more String objects or a String with a primitive value using the + or += operator to create a new String object. |
| equals method | A String method that returns true if the string contains the same sequence of characters as another string, and false otherwise. |
| immutable | A property of String objects meaning that once created, their content cannot be changed; methods called on a String return a new String rather than modifying the original. |
| implicit conversion | The automatic conversion of a primitive value to a String object when concatenated with a String. |
| index | A numeric position in a string, starting from 0 for the first character and going up to one less than the length of the string. |
| indexOf() method | A String method that returns the index of the first occurrence of a specified substring, or -1 if the substring is not found. |
| java.lang package | A Java package containing fundamental classes that are automatically available without explicit import statements. |
| length() method | A String method that returns the number of characters in a String object as an integer. |
| method overriding | When a public method in a subclass has the same method signature as a public method in the superclass but with subclass-specific behavior. |
| Object class | The superclass in Java from which all classes inherit, guaranteeing the existence of the toString method. |
| String class constructor | A method that creates a new String object by calling the String class constructor. |
| string literal | A sequence of characters enclosed in double quotes used to create a String object directly in code. |
| String object | An instance of the String class in Java that represents a sequence of characters. |
| StringIndexOutOfBoundsException | An exception thrown when attempting to access a string index that is outside the valid range of 0 to length - 1. |
| substring() method | A String method that returns a portion of a string, either from a starting index to an ending index, or from a starting index to the end of the string. |
| toString method | A method that returns a string representation of an object, automatically called when an object is concatenated with a String. |
| Term | Definition |
|---|---|
| argument | A value or variable passed to a method or constructor when it is called. |
| call by value | A method of passing arguments where the parameters are initialized with copies of the argument values rather than references to the original values. |
| constructor | A special method that is called to create and initialize an object of a class, having the same name as the class. |
| flow of control | The order in which statements in a program are executed, which can be interrupted by method calls and resumed after the method completes. |
| method | A named block of code that only runs when it is called, allowing programmers to reuse code and organize programs into logical sections. |
| method call | An invocation of a method that interrupts sequential execution and causes the program to execute the method's statements before returning control to the calling location. |
| method signature | The combination of a method's name and its ordered list of parameter types, used to identify and call a specific method. |
| non-void method | A method that returns a value of a specified type that can be stored in a variable or used as part of an expression. |
| overloaded method | Multiple methods with the same name but different method signatures, allowing the same method name to be used with different parameter types or numbers. |
| parameter | A variable declared in the header of a method or constructor that receives values passed to the method when it is called. |
| parameter list | The list of parameters in a method signature that specifies the types and order of arguments the method expects. |
| procedural abstraction | The ability to use a method by knowing what it does without needing to understand how it was implemented. |
| return statement | A statement that terminates method execution and returns control flow to the point immediately following where the method was called. |
| return value | The value produced by a non-void method that matches the return type specified in the method header. |
| void method | A method that does not return a value and cannot be used as part of an expression. |
| Term | Definition |
|---|---|
| assignment statement | A statement that stores a value in a variable using the assignment operator or a compound assignment operator. |
| compound assignment operator | Operators (+=, -=, *=, /=, %) that perform an arithmetic operation and assign the result to a variable in a single statement. |
| post-decrement operator | The -- operator used after a variable to subtract 1 from its stored value and assign the new value to the variable. |
| post-increment operator | The ++ operator used after a variable to add 1 to its stored value and assign the new value to the variable. |
| Term | Definition |
|---|---|
| API documentation | Documentation generated from Javadoc comments that describes the functionality and usage of code. |
| block comment | Comments in Java denoted by /* */ that span multiple lines or create a block of explanatory text. |
| comment | Explanatory text in code that describes functionality and is ignored by the compiler during program execution. |
| Javadoc comment | Comments in Java denoted by /** */ that are used to generate API documentation. |
| line comment | Comments in Java denoted by // that apply to a single line of code. |
| postcondition | A condition that must always be true after a method executes, describing the outcome in terms of return values or object attributes. |
| precondition | A condition that must be true immediately before a method executes in order for the method to behave as expected. |
| Term | Definition |
|---|---|
| algorithm | A step-by-step procedure or set of rules designed to solve a problem or accomplish a task. |
| code compilation | The process of translating source code written by a programmer into machine-readable instructions that a computer can execute. |
| code execution | The process of running compiled code on a computer to perform the instructions specified in the program. |
| compiler | A program that translates source code into machine code and checks for errors that must be fixed before the program can run. |
| compiler error | Errors in source code that are detected by a compiler and must be fixed before a program can be executed. |
| exception | A type of run-time error that occurs as a result of an unexpected error not detected by the compiler and interrupts the normal flow of program execution. |
| integrated development environment | A software application that provides comprehensive tools for writing, compiling, and running code in one unified interface. |
| logic error | A mistake in the algorithm or program that causes it to behave incorrectly or unexpectedly, detected through testing with specific data. |
| pattern | Recurring sequences or structures found in everyday processes that can be represented and analyzed. |
| run-time error | A mistake in the program that occurs during execution and typically causes the program to terminate abnormally. |
| sequencing | The order in which steps in a process are completed, with steps executed one at a time. |
| syntax error | A mistake in a program where the rules of the programming language are not followed, detected by the compiler. |
| text editor | A software tool used to write and edit source code in plain text format. |
| Term | Definition |
|---|---|
| attribute | The data or properties that define the state of an object or class. |
| behavior | The methods or actions that an object or class can perform. |
| class | A formal implementation or blueprint that defines the attributes and behaviors of objects. |
| inheritance | A relationship in which a subclass draws upon and reuses the attributes and behaviors of a superclass. |
| instance | A specific occurrence or realization of a class with its own set of attribute values. |
| memory address | The location in computer memory where an object is stored, which is referenced by a reference type variable. |
| object | A specific instance of a class with defined attributes and behaviors. |
| object reference | A value that points to the memory location where an object is stored, allowing access to that object. |
| reference type | A data type that holds a reference (memory address) to an object rather than storing the object's value directly. |
| subclass | A class that extends a superclass and inherits its attributes and behaviors. |
| superclass | A class that contains common attributes and behaviors shared by multiple related classes. |
| Term | Definition |
|---|---|
| assignment operator | The = symbol that allows a program to store the value of an expression on the right into a variable on the left. |
| assignment statement | A statement that stores a value in a variable using the assignment operator or a compound assignment operator. |
| data type | A classification that specifies what kind of value a variable can store and what operations can be performed on it. |
| expression | A combination of values, variables, and operators that is evaluated to produce a single value. |
| initialization | The first assignment of a value to a variable. |
| input | Data or information provided to a program, which can come from various sources such as keyboard, files, or user interactions. |
| null | A special value indicating that a reference variable does not currently reference any object. |
| reference type | A data type that holds a reference (memory address) to an object rather than storing the object's value directly. |
| Scanner class | A Java class used to obtain and parse text input from the keyboard or other input sources. |
| text input | Data entered by a user in the form of characters and strings, typically from a keyboard. |
| variable | A named storage location in a program that holds a value of a specific data type; the value can change while the program is running. |
| Term | Definition |
|---|---|
| Boolean expression | An expression that evaluates to either true or false, used to control the execution of loops and conditional statements. |
| Boolean value | Data values that can only be true or false, used in logical operations and conditional statements. |
| object reference | A value that points to the memory location where an object is stored, allowing access to that object. |
| primitive data type | Basic data types in Java such as int, double, boolean, and char that are not objects. |
| reference type | A data type that holds a reference (memory address) to an object rather than storing the object's value directly. |
| relational operator | Operators used to compare values, including ==, !=, <, >, <=, and >=. |
| Term | Definition |
|---|---|
| Boolean expression | An expression that evaluates to either true or false, used to control the execution of loops and conditional statements. |
| for loop | A type of iterative statement that repeats a block of code a specified number of times using initialization, a Boolean expression, and an update statement. |
| initialization | The first assignment of a value to a variable. |
| iteration statement | A control structure that repeats a block of code multiple times based on a condition. |
| loop body | The segment of code that is repeated within an iteration statement. |
| loop control variable | The variable initialized in a for loop that is used to control the number of iterations. |
| update | The part of a for loop header that modifies the loop control variable after each iteration of the loop body. |
| while loop | An iterative statement that repeatedly executes a block of code as long as a specified Boolean expression evaluates to true. |
| Term | Definition |
|---|---|
| iteration statement | A control structure that repeats a block of code multiple times based on a condition. |
| run-time | The period during which a program is executing or running. |
| statement execution count | The number of times a statement is executed during the running of a program. |
| tracing | The process of manually following the execution of a program step-by-step to understand how statements are executed. |
| Term | Definition |
|---|---|
| Boolean expression | An expression that evaluates to either true or false, used to control the execution of loops and conditional statements. |
| flow of control | The order in which statements in a program are executed, which can be interrupted by method calls and resumed after the method completes. |
| infinite loop | A loop that never terminates because the Boolean expression always evaluates to true. |
| iteration | A form of repetition in which code is executed zero or more times based on a condition. |
| iteration statement | A control structure that repeats a block of code multiple times based on a condition. |
| iterative process | A process that repeats a segment of code multiple times to achieve a desired result. |
| loop body | The segment of code that is repeated within an iteration statement. |
| off by one error | An error that occurs when an iteration statement loops one time too many or one time too few. |
| while loop | An iterative statement that repeatedly executes a block of code as long as a specified Boolean expression evaluates to true. |
| Term | Definition |
|---|---|
| inner loop | The iteration statement contained within the body of another iteration statement that executes completely for each iteration of the outer loop. |
| iteration statement | A control structure that repeats a block of code multiple times based on a condition. |
| nested iteration | Iteration statements that appear within the body of another iteration statement, where the inner loop completes all its iterations before the outer loop advances to its next iteration. |
| outer loop | The iteration statement that contains another iteration statement within its body. |
| Term | Definition |
|---|---|
| character reversal | The process of rearranging the characters in a string in reverse order, from last to first. |
| string algorithm | Procedures or methods designed to perform operations on strings, such as searching, modifying, or analyzing text data. |
| substring | Contiguous sequences of characters within a larger string. |
| Term | Definition |
|---|---|
| ! (not) | A logical operator that negates a Boolean expression, returning true if the expression is false and false if the expression is true. |
| && (and) | A logical operator that returns true only when both Boolean expressions are true, and false otherwise. |
| || (or) | A logical operator that returns true when at least one of the Boolean expressions is true, and false only when both are false. |
| compound Boolean expression | Boolean expressions that combine multiple Boolean values or conditions using logical operators to produce a single Boolean result. |
| logical operator | Symbols or keywords used to combine or modify Boolean expressions: ! (not), && (and), and || (or). |
| order of precedence | The sequence in which logical operators are evaluated in an expression: ! (not) first, && (and) second, then || (or). |
| short-circuit evaluation | An optimization where a logical operation using && or || stops evaluating as soon as the final result can be determined, without evaluating all expressions. |
| Term | Definition |
|---|---|
| Boolean expression | An expression that evaluates to either true or false, used to control the execution of loops and conditional statements. |
| branching logical process | Program flow that divides into different paths based on conditional statements, allowing different code to execute depending on whether conditions are true or false. |
| if-else-if | A conditional statement structure that tests multiple conditions in sequence, executing the code block for the first condition that evaluates to true. |
| multiway selection | A control structure using if-else-if statements to choose one of several code segments to execute based on different conditions. |
| nested if statement | If, if-else, or if-else-if statements placed within other if, if-else, or if-else-if statements to create multiple levels of conditional branching. |
| Term | Definition |
|---|---|
| Boolean expression | An expression that evaluates to either true or false, used to control the execution of loops and conditional statements. |
| branching logical process | Program flow that divides into different paths based on conditional statements, allowing different code to execute depending on whether conditions are true or false. |
| flow of control | The order in which statements in a program are executed, which can be interrupted by method calls and resumed after the method completes. |
| if statement | A selection statement that executes a code segment based on whether a Boolean expression is true or false. |
| if-else statement | A selection statement that provides two alternative code segments: one executed when a Boolean expression is true and another when it is false. |
| one-way selection | An if statement that executes a code segment only when a Boolean expression is true. |
| selection statement | Programming statements that control the flow of execution by choosing which code segments to run based on conditions. |
| sequential execution | The default flow of a program where statements are executed one after another in the order they appear. |
| two-way selection | An if-else statement that executes one code segment when a Boolean expression is true and a different segment when it is false. |
| Term | Definition |
|---|---|
| != | The not-equal operator used to determine if two object references are different or if a reference does not equal a value. |
| == | The equality operator used to compare object references or values; for objects, it checks if two variables reference the same object in memory. |
| Boolean expression | An expression that evaluates to either true or false, used to control the execution of loops and conditional statements. |
| De Morgan's law | A logical rule that allows conversion between equivalent Boolean expressions: !(a && b) is equivalent to !a || !b, and !(a || b) is equivalent to !a && !b. |
| equals method | A String method that returns true if the string contains the same sequence of characters as another string, and false otherwise. |
| equivalency | The state of two objects being equal based on specified criteria, typically determined by comparing their attributes. |
| equivalent | Having the same value or producing the same result; two Boolean expressions are equivalent if they evaluate to the same value in all cases. |
| null | A special value indicating that a reference variable does not currently reference any object. |
| object reference | A value that points to the memory location where an object is stored, allowing access to that object. |
| truth table | A table that shows all possible input combinations and their corresponding output values, used to prove whether Boolean expressions are equivalent. |
| Term | Definition |
|---|---|
| algorithm | A step-by-step procedure or set of rules designed to solve a problem or accomplish a task. |
| decision making | The process in an algorithm where a choice is made based on evaluating a condition to determine which path to follow. |
| looping | A programming construct that repeats a block of code multiple times as part of an algorithm's repetition. |
| repetition | A control structure in an algorithm where a process repeats itself until a desired outcome is reached. |
| selection | A control structure in an algorithm that makes a choice about how execution will proceed based on a true or false decision. |
| sequencing | The order in which steps in a process are completed, with steps executed one at a time. |
| Term | Definition |
|---|---|
| algorithm | A step-by-step procedure or set of rules designed to solve a problem or accomplish a task. |
| average | The mean value calculated by dividing the sum of all values by the number of values. |
| evenly divisible | A property of an integer that can be divided by another integer with no remainder. |
| frequency | The number of times a specific criterion or condition is met within a dataset or sequence. |
| maximum value | The largest value in a set of data or collection of numbers. |
| minimum value | The smallest value in a set of data or collection of numbers. |
| standard algorithm | A widely recognized, established procedure for solving a common computational problem. |
| sum | The result of adding multiple values together. |
| Term | Definition |
|---|---|
| accessor method | A non-void method that allows objects of other classes to obtain a copy of the value of instance variables or class variables. |
| class variable | Variables that belong to the class itself rather than individual objects and can be accessed or modified by accessor and mutator methods. |
| instance variable | A variable that belongs to an object and can be accessed throughout the class, as opposed to a local variable that is limited to a specific block of code. |
| mutator method | A method that changes the values of instance variables or class variables, often implemented as a void method. |
| non-void method | A method that returns a value of a specified type that can be stored in a variable or used as part of an expression. |
| parameters | Variables that allow procedures to be generalized and reused with a range of input values or arguments. |
| primitive values | Basic data types in Java such as int, double, and boolean that store actual values directly. |
| return by value | The process in which a non-void method evaluates a return expression compatible with the return type and returns that value. |
| return statement | A statement that terminates method execution and returns control flow to the point immediately following where the method was called. |
| return type | The data type of the value that a non-void method returns, specified in the method header. |
| void method | A method that does not return a value and cannot be used as part of an expression. |
| Term | Definition |
|---|---|
| class methods | Methods that are associated with a class rather than with instances of the class, and include the static keyword in their header. |
| class variable | Variables that belong to the class itself rather than individual objects and can be accessed or modified by accessor and mutator methods. |
| dot operator | The symbol (.) used in Java to access instance methods and properties of an object. |
| final keyword | A Java keyword that, when applied to a variable, prevents its value from being modified after initialization. |
| instance methods | Methods that belong to an object and are called on specific instances of a class using the dot operator. |
| instance variable | A variable that belongs to an object and can be accessed throughout the class, as opposed to a local variable that is limited to a specific block of code. |
| parameter | A variable declared in the header of a method or constructor that receives values passed to the method when it is called. |
| public access modifier | A keyword that allows class variables to be accessed outside of the class using the class name and dot operator. |
| static keyword | A Java keyword used to designate that a variable belongs to the class rather than to individual objects of the class. |
| Term | Definition |
|---|---|
| class method | A method that belongs to the class itself rather than to individual instances and does not have access to a this reference. |
| constructor | A special method that is called to create and initialize an object of a class, having the same name as the class. |
| current object | The specific object instance whose method or constructor is being executed. |
| instance method | A method that belongs to an object instance and can access and modify the instance's data through the this keyword. |
| method call | An invocation of a method that interrupts sequential execution and causes the program to execute the method's statements before returning control to the calling location. |
| self-referencing | Code that refers to the current object using the this keyword. |
| this keyword | A special variable that holds a reference to the current object within an instance method or constructor. |
| Term | Definition |
|---|---|
| attribute | The data or properties that define the state of an object or class. |
| constructor | A special method that is called to create and initialize an object of a class, having the same name as the class. |
| constructor parameters | Data passed to a constructor that is used to initialize instance variables with specific values. |
| default constructor | A no-parameter constructor automatically provided by Java when no constructor is explicitly written; initializes instance variables to default values. |
| default values | The initial values automatically assigned to instance variables by the default constructor based on their data type (0 for int, 0.0 for double, false for boolean, null for reference types). |
| has-a relationship | A relationship between an object and its instance variables, indicating that an object has certain attributes. |
| instance variable | A variable that belongs to an object and can be accessed throughout the class, as opposed to a local variable that is limited to a specific block of code. |
| mutable object | An object whose state can be changed after it is created; when used as a constructor parameter, a copy should be made to prevent external modification. |
| object's state | The current values of all instance variables belonging to an object at a given time. |
| Term | Definition |
|---|---|
| abstraction | The process of reducing complexity by focusing on main ideas and hiding irrelevant details while bringing together related and useful details. |
| attribute | The data or properties that define the state of an object or class. |
| class | A formal implementation or blueprint that defines the attributes and behaviors of objects. |
| class variable | Variables that belong to the class itself rather than individual objects and can be accessed or modified by accessor and mutator methods. |
| code reuse | The practice of using existing methods and procedural abstractions multiple times rather than duplicating code, which helps manage complexity. |
| data abstraction | A separation between the abstract properties of a data type and the concrete details of its representation, allowing data to be named without referencing specific implementation details. |
| instance variable | A variable that belongs to an object and can be accessed throughout the class, as opposed to a local variable that is limited to a specific block of code. |
| method | A named block of code that only runs when it is called, allowing programmers to reuse code and organize programs into logical sections. |
| method decomposition | The process of breaking down larger behaviors of a class into smaller behaviors by creating individual methods to represent each smaller behavior. |
| method signature | The combination of a method's name and its ordered list of parameter types, used to identify and call a specific method. |
| parameters | Variables that allow procedures to be generalized and reused with a range of input values or arguments. |
| procedural abstraction | The ability to use a method by knowing what it does without needing to understand how it was implemented. |
| Term | Definition |
|---|---|
| access constraints | Restrictions that control which classes and methods can access or modify a class, data, constructors, or methods. |
| attribute | The data or properties that define the state of an object or class. |
| behavior | The methods or actions that an object or class can perform. |
| constructors | Special methods used to initialize objects of a class, typically designated as public in this course. |
| data encapsulation | A technique in which the implementation details of a class are kept hidden from external classes to protect internal structure and behavior. |
| instance variable | A variable that belongs to an object and can be accessed throughout the class, as opposed to a local variable that is limited to a specific block of code. |
| method | A named block of code that only runs when it is called, allowing programmers to reuse code and organize programs into logical sections. |
| private | A keyword that restricts access to a class, data, constructor, or method to only the declaring class. |
| public | A keyword that allows access to a class, data, constructor, or method from classes outside the declaring class. |
| visibility constraints | Specifications that determine whether classes, data, constructors, and methods are visible and accessible to external classes. |
| Term | Definition |
|---|---|
| block of code | A section of code enclosed in braces that defines a region where variables can be declared and accessed. |
| instance variable | A variable that belongs to an object and can be accessed throughout the class, as opposed to a local variable that is limited to a specific block of code. |
| local variables | Variables declared in the headers or bodies of blocks of code that can only be accessed within the block in which they are declared. |
| parameters | Variables that allow procedures to be generalized and reused with a range of input values or arguments. |
| scope | The region of code in which a variable can be accessed and used. |
| Term | Definition |
|---|---|
| enclosing class | The class in which a method is defined. |
| mutable object | An object whose state can be changed after it is created; when used as a constructor parameter, a copy should be made to prevent external modification. |
| object reference | A value that points to the memory location where an object is stored, allowing access to that object. |
| parameter | A variable declared in the header of a method or constructor that receives values passed to the method when it is called. |
| private data | Class members declared with the private access modifier that can only be accessed within the same class. |
| return expression | The value or reference that a method sends back to the code that called it. |
| Term | Definition |
|---|---|
| ethical implications | The moral and ethical consequences of computing systems, including questions about right and wrong in their design and use. |
| intellectual property | Legal rights and protections for original creative works, including software code and programs. |
| open source | Software code that is publicly available and free to use, modify, and distribute without requiring permission or payment. |
| social implications | The effects and consequences of computing systems on society, including how they impact people's lives and social structures. |
| system reliability | The ability of a program to perform its intended tasks as expected under stated conditions without failure. |
| Term | Definition |
|---|---|
| algorithm | A step-by-step procedure or set of rules designed to solve a problem or accomplish a task. |
| ArrayList | A resizable array implementation in Java that can dynamically grow or shrink to store a collection of objects. |
| average | The mean value calculated by dividing the sum of all values by the number of values. |
| delete elements | The operation of removing elements from a collection. |
| duplicate elements | Multiple occurrences of the same value within a collection. |
| insert elements | The operation of adding new elements into a collection at a specified position. |
| maximum value | The largest value in a set of data or collection of numbers. |
| minimum value | The smallest value in a set of data or collection of numbers. |
| reverse | To arrange elements in an array in the opposite order from their original sequence. |
| rotate elements | To move elements in an array circularly so that elements shifted off one end reappear at the other end. |
| shift elements | To move all elements in an array left or right by one or more positions. |
| sum | The result of adding multiple values together. |
| traverse | To visit each element in a data structure (such as a string, array, or ArrayList) in a systematic way, often using recursion. |
| Term | Definition |
|---|---|
| array traversal | The process of using repetition statements to systematically access elements in an array. |
| average | The mean value calculated by dividing the sum of all values by the number of values. |
| consecutive pairs | Two adjacent elements in an array that are next to each other in sequence. |
| duplicate elements | Multiple occurrences of the same value within a collection. |
| maximum value | The largest value in a set of data or collection of numbers. |
| minimum value | The smallest value in a set of data or collection of numbers. |
| reverse | To arrange elements in an array in the opposite order from their original sequence. |
| rotate elements | To move elements in an array circularly so that elements shifted off one end reappear at the other end. |
| shift elements | To move all elements in an array left or right by one or more positions. |
| sum | The result of adding multiple values together. |
| Term | Definition |
|---|---|
| 2D array | A two-dimensional data structure consisting of rows and columns used to store and organize data in a grid format. |
| algorithm | A step-by-step procedure or set of rules designed to solve a problem or accomplish a task. |
| average | The mean value calculated by dividing the sum of all values by the number of values. |
| consecutive pairs | Two adjacent elements in an array that are next to each other in sequence. |
| duplicate elements | Multiple occurrences of the same value within a collection. |
| maximum value | The largest value in a set of data or collection of numbers. |
| minimum value | The smallest value in a set of data or collection of numbers. |
| reverse | To arrange elements in an array in the opposite order from their original sequence. |
| rotate elements | To move elements in an array circularly so that elements shifted off one end reappear at the other end. |
| shift elements | To move all elements in an array left or right by one or more positions. |
| sum | The result of adding multiple values together. |
| traverse | To visit each element in a data structure (such as a string, array, or ArrayList) in a systematic way, often using recursion. |
| Term | Definition |
|---|---|
| 2D array | A two-dimensional data structure consisting of rows and columns used to store and organize data in a grid format. |
| ArrayIndexOutOfBoundsException | An error that occurs when attempting to access an array element using an index value outside the valid range of 0 through length minus one. |
| arrays of arrays | A data structure where a 2D array is implemented as an array where each element is itself a 1D array. |
| column index | The second index in the square brackets [row][col] notation used to specify which column of a 2D array to access. |
| default values | The initial values automatically assigned to instance variables by the default constructor based on their data type (0 for int, 0.0 for double, false for boolean, null for reference types). |
| initializer list | A syntax used to create and initialize an array with specific values at the time of creation. |
| length attribute | A property of an array that indicates the number of elements it contains and cannot be changed after creation. |
| object reference data | Data types that store references to objects rather than primitive values. |
| primitive data | Basic data types in Java such as int, double, and boolean that store values directly. |
| row index | The first index in the square brackets [row][col] notation used to specify which row of a 2D array to access. |
| Term | Definition |
|---|---|
| 1D array | An array with a single row of elements, organized in a linear sequence and accessed using a single index. |
| 2D array | A two-dimensional data structure consisting of rows and columns used to store and organize data in a grid format. |
| arrays of arrays | A data structure where a 2D array is implemented as an array where each element is itself a 1D array. |
| column-major order | A traversal pattern of a 2D array where elements are accessed down each column from top to bottom before moving to the next column. |
| enhanced for loop | A Java loop construct that iterates through all elements of a collection without using an index variable. |
| nested iteration statements | Loop structures where one loop is placed inside another, used to access all elements in a 2D array. |
| row-major order | A traversal pattern of a 2D array where elements are accessed across each row from left to right before moving to the next row. |
| traverse | To visit each element in a data structure (such as a string, array, or ArrayList) in a systematic way, often using recursion. |
| Term | Definition |
|---|---|
| 1D array | An array with a single row of elements, organized in a linear sequence and accessed using a single index. |
| array | A data structure that stores a fixed-size collection of elements of the same type in contiguous memory locations, accessed by index. |
| ArrayIndexOutOfBoundsException | An error that occurs when attempting to access an array element using an index value outside the valid range of 0 through length minus one. |
| default values | The initial values automatically assigned to instance variables by the default constructor based on their data type (0 for int, 0.0 for double, false for boolean, null for reference types). |
| index | A numeric position in a string, starting from 0 for the first character and going up to one less than the length of the string. |
| initializer list | A syntax used to create and initialize an array with specific values at the time of creation. |
| length attribute | A property of an array that indicates the number of elements it contains and cannot be changed after creation. |
| object reference | A value that points to the memory location where an object is stored, allowing access to that object. |
| primitive values | Basic data types in Java such as int, double, and boolean that store actual values directly. |
| Term | Definition |
|---|---|
| array | A data structure that stores a fixed-size collection of elements of the same type in contiguous memory locations, accessed by index. |
| ArrayList | A resizable array implementation in Java that can dynamically grow or shrink to store a collection of objects. |
| ArrayList objects | Resizable collections in Java that can dynamically grow or shrink and can be traversed recursively. |
| binary search algorithm | A search algorithm that finds a target value in a sorted collection by repeatedly dividing the search space in half, eliminating half of the remaining elements with each iteration. |
| iteration | A form of repetition in which code is executed zero or more times based on a condition. |
| iteratively | A method of solving a problem by repeating a set of instructions in a loop rather than through recursive function calls. |
| linear search | A search algorithm that examines each element in a collection sequentially from the beginning until the target value is found or the end is reached. |
| merge sort | A recursive sorting algorithm that divides an array into smaller subarrays, sorts them, and then merges them back together in sorted order. |
| recursion | A programming technique where a function calls itself to solve a problem by breaking it into smaller, similar subproblems. |
| recursive algorithms | Algorithms that solve problems by having a function call itself with modified parameters until reaching a base case. |
| recursive call | An instance where a method invokes itself as part of its execution. |
| recursive sorting algorithm | A sorting algorithm that uses recursion to divide and organize elements in a collection. |
| recursively | A method of solving a problem by having a function call itself with modified parameters until a base case is reached. |
| sorted order | A requirement for binary search in which elements in a collection are arranged in a specific sequence, typically in ascending or descending order. |
| String objects | Data structures in Java that represent sequences of characters and can be traversed recursively. |
| subarray | A contiguous portion of an array. |
| traverse | To visit each element in a data structure (such as a string, array, or ArrayList) in a systematic way, often using recursion. |
| Term | Definition |
|---|---|
| add(E obj) method | An ArrayList method that appends an object to the end of the list and returns true. |
| add(int index, E obj) method | An ArrayList method that inserts an object at a specified position and shifts elements to the right. |
| ArrayList | A resizable array implementation in Java that can dynamically grow or shrink to store a collection of objects. |
| generic type | A parameterized type that specifies the data type of elements a collection will contain, such as ArrayList<E>. |
| get(int index) method | An ArrayList method that returns the element at a specified position in the list. |
| import statement | A Java statement used to make classes from a package available for use in a program. |
| index | A numeric position in a string, starting from 0 for the first character and going up to one less than the length of the string. |
| java.util package | A Java library package that contains utility classes including ArrayList. |
| mutable | Capable of being changed or modified after creation, such as an ArrayList that can grow or shrink in size. |
| object reference | A value that points to the memory location where an object is stored, allowing access to that object. |
| remove(int index) method | An ArrayList method that removes the element at a specified position and shifts elements to the left. |
| set(int index, E obj) method | An ArrayList method that replaces the element at a specified position and returns the former element. |
| size() method | An ArrayList method that returns the number of elements currently in the list. |
| type parameter | A placeholder for a specific data type in a generic class, represented by E in ArrayList<E>. |
| Term | Definition |
|---|---|
| close() | A Scanner method that closes the scanner and the associated file when the program is finished using it. |
| file | A storage location for data that persists when a program is not running and can be retrieved during program execution. |
| File class | A Java class used to create a File object that connects a program to a text file for reading data. |
| hasNext() | A Scanner method that returns true if there is another item to read in the file or input source, and false otherwise. |
| import statement | A Java statement used to make classes from a package available for use in a program. |
| InputMismatchException | An exception thrown when a Scanner method attempts to read a value that does not match the expected data type or is out of range. |
| IOException | An exception class that is thrown when a file cannot be opened or read due to an invalid file name or I/O error. |
| java.io package | A Java package containing classes like File and IOException that must be imported to use file input/output operations. |
| next() | A Scanner method that returns the next String token read from a file or input source. |
| nextBoolean() | A Scanner method that returns the next boolean value read from a file or input source. |
| nextDouble() | A Scanner method that returns the next double value read from a file or input source. |
| nextInt() | A Scanner method that returns the next integer value read from a file or input source. |
| nextLine() | A Scanner method that returns the next line of text as a String read from a file or input source. |
| Scanner class | A Java class used to obtain and parse text input from the keyboard or other input sources. |
| split() | A String method that returns a String array by dividing a String into substrings based on a given delimiter expression. |
| throws IOException | A method declaration clause that indicates the method may throw an IOException if a file cannot be opened. |
| while loop | An iterative statement that repeatedly executes a block of code as long as a specified Boolean expression evaluates to true. |
| whitespace | Blank characters such as spaces, tabs, and newlines that Scanner methods handle differently when reading from a file. |
| Term | Definition |
|---|---|
| base case | A condition in a recursive method that stops the recursion and prevents infinite calls. |
| iterative approach | A method of solving a problem using loops and repetition instead of recursion. |
| local variables | Variables declared in the headers or bodies of blocks of code that can only be accessed within the block in which they are declared. |
| parameters | Variables that allow procedures to be generalized and reused with a range of input values or arguments. |
| recursive call | An instance where a method invokes itself as part of its execution. |
| recursive method | A method that calls itself to solve a problem by breaking it down into smaller instances of the same problem. |
| Term | Definition |
|---|---|
| algorithmic bias | Systemic and repeated errors in a program that create unfair outcomes for a specific group of users. |
| bias | Systematic prejudice or error in data collection or program logic that leads to unfair or inaccurate outcomes. |
| data collection | The process of gathering information about individuals through computer systems and other means. |
| data quality | The accuracy, completeness, and reliability of data in a dataset, which affects the correctness of programs and conclusions drawn from the data. |
| data set | A collection of related data values that can be analyzed to answer questions or solve problems. |
| data set collection method | The process and technique used to gather data for a dataset, which can introduce bias or affect data quality. |
| data storage | The process of keeping collected personal information on computer systems for later access or use. |
| inaccurate data | Data that contains errors or does not correctly represent the actual values or facts, potentially causing program malfunction. |
| incomplete data | A dataset that is missing information or records, which can cause programs to work incorrectly or inefficiently. |
| personal data | Information about individuals that can be used to identify them or reveal details about their lives, activities, or characteristics. |
| privacy | The right of individuals to control access to their personal information and have it protected from unauthorized collection, use, or disclosure. |
| safeguard | Protective measures taken to prevent unauthorized access to or misuse of personal data. |
| Term | Definition |
|---|---|
| algorithm | A step-by-step procedure or set of rules designed to solve a problem or accomplish a task. |
| chart | A visual representation of data used to organize and display information in a way that aids understanding and planning. |
| data set | A collection of related data values that can be analyzed to answer questions or solve problems. |
| table | A structured visual representation of data organized in rows and columns that can be used to plan algorithms. |
| Term | Definition |
|---|---|
| array index | The numeric position used to access a specific element in an array. |
| array traversal | The process of using repetition statements to systematically access elements in an array. |
| enhanced for loop | A Java loop construct that iterates through all elements of a collection without using an index variable. |
| enhanced for loop variable | The variable in an enhanced for loop header that is assigned a copy of each array element during each iteration. |
| indexed for loop | A loop that accesses array elements by using their index positions to control iteration. |
| object reference | A value that points to the memory location where an object is stored, allowing access to that object. |
| traverse | To visit each element in a data structure (such as a string, array, or ArrayList) in a systematic way, often using recursion. |
| while loop | An iterative statement that repeatedly executes a block of code as long as a specified Boolean expression evaluates to true. |
| Term | Definition |
|---|---|
| array | A data structure that stores a fixed-size collection of elements of the same type in contiguous memory locations, accessed by index. |
| ArrayList | A resizable array implementation in Java that can dynamically grow or shrink to store a collection of objects. |
| insertion sort | An iterative sorting algorithm that inserts elements from the unsorted portion into their correct position in the sorted portion by shifting elements to make room. |
| iterative sorting algorithms | Sorting algorithms that use repetition to progressively sort elements by performing the same operation multiple times. |
| selection sort | An iterative sorting algorithm that repeatedly selects the smallest or largest element from the unsorted portion and places it in its correct final position in the sorted portion. |
| sorted portion | The part of a collection that has been arranged in the desired order during a sorting process. |
| sorting algorithms | Step-by-step procedures used to arrange elements in a collection in a specific order, such as ascending or descending. |
| swap | The operation of exchanging the positions of two elements in a collection. |
| unsorted portion | The part of a collection that has not yet been arranged in the desired order during a sorting process. |
| Term | Definition |
|---|---|
| 2D array | A two-dimensional data structure consisting of rows and columns used to store and organize data in a grid format. |
| array | A data structure that stores a fixed-size collection of elements of the same type in contiguous memory locations, accessed by index. |
| ArrayList | A resizable array implementation in Java that can dynamically grow or shrink to store a collection of objects. |
| linear search algorithms | Standard algorithms that check each element in a collection in order until the desired value is found or all elements have been checked. |
| Term | Definition |
|---|---|
| ArrayList | A resizable array implementation in Java that can dynamically grow or shrink to store a collection of objects. |
| ConcurrentModificationException | An exception that occurs when the size of an ArrayList is changed while traversing it using an enhanced for loop. |
| enhanced for loop | A Java loop construct that iterates through all elements of a collection without using an index variable. |
| IndexOutOfBoundsException | An exception that occurs when attempting to access an index value outside the valid range of an ArrayList. |
| iteration | A form of repetition in which code is executed zero or more times based on a condition. |
| recursive statements | Programming statements that call themselves to process elements in a data structure. |
| traverse | To visit each element in a data structure (such as a string, array, or ArrayList) in a systematic way, often using recursion. |
| Term | Definition |
|---|---|
| autoboxing | The automatic conversion by the Java compiler from a primitive type to its corresponding wrapper class object, such as converting an int to an Integer or a double to a Double. |
| Double class | A wrapper class in the java.lang package that represents a primitive double value as an object; Double objects are immutable. |
| immutable | A property of String objects meaning that once created, their content cannot be changed; methods called on a String return a new String rather than modifying the original. |
| Integer class | A wrapper class in the java.lang package that represents a primitive int value as an object; Integer objects are immutable. |
| parseDouble | A static method of the Double class that converts a String argument to a double value. |
| parseInt | A static method of the Integer class that converts a String argument to an int value. |
| primitive type | A basic data type in Java such as int or double that is not an object. |
| unboxing | The automatic conversion by the Java compiler from a wrapper class object to its corresponding primitive type, such as converting an Integer to an int or a Double to a double. |
| wrapper class | A class that encapsulates a primitive data type and provides object-oriented functionality, such as Integer and Double. |
#
A