CSP 26 midterm personal studyguide

*Program*

Software containing a group of instructions to instruct the computer to perform tasks.

*Compiler*

A program that translates high-level source code into an executable form, such as byte code.

*Java Virtual Machine (JVM)*

A program that simulates an underlying operating system to execute byte code (.class files), providing portability across different platforms.

*Hardware Components*

The physical pieces of a computer, including the *CPU, main memory, secondary storage, and input/output devices*.

*Central Processing Unit (CPU)*

The component that performs the *fetch, decode, execute cycle* to process instructions.

*Main Memory (RAM)*

Volatile storage divided into *bytes*, used to hold currently running programs and their data.

*Binary Digit (Bit)*

The smallest unit of computer memory that can be either on or off.

*Byte*

A section of memory consisting of *eight bits*.

*Algorithm*

A collective set of instructions that enables a computer to solve a problem or perform a task.

*Syntax Errors*

Mistakes made by a programmer that violate the strict rules of a programming language, discovered during compilation.

*Identifier*

A programmer-defined name for items like *classes, variables, or methods*.

*Identifier Rules*

Must be a sequence of letters, digits, underscores, or dollar signs; cannot start with a digit or be a *reserved word*.

*Variable*

A named storage location in the computer's memory used to hold a value.

*Literal*

Specific data that is hardcoded directly into the program's code.

*Primitive Data Types*

Data types built into the Java language (such as *int, double, boolean, and char*) that hold values directly rather than objects.

*Reference Data Types*

Variables that store the *memory address of an object, such as String, Scanner, or File*.

*Assignment Operator (=)*

An operator that assigns the value on its right side to the variable on its left side.

*Initialization*

The process of giving an initial value to a variable in the same statement as its declaration.

*Arithmetic Operators*

Symbols used for calculations: *+ (addition), - (subtraction), * (multiplication), / (division), and % (modulo)*.

*Modulo Operator (%)*

Evaluates the *remainder* of the division of two integer operands.

*Integer Division*

Division where both operands are integers, resulting in the fractional part being discarded.

*Implicit Conversion*

Automatic type conversion by the compiler, such as promoting an *int to a double* during an operation.

*Explicit Conversion (Casting)*

Manually converting a value to a different type using the format *(type)expression*.

*Overflow*

An error that occurs when a value assigned to a variable is greater than the maximum value its data type can store.

*String Class*

A reference type used to hold a *sequence of characters*.

*Immutable*

The characteristic of *String objects* meaning their content cannot be changed once they are created.

*Escape Sequences*

Two-character sequences starting with *\ that represent special characters, like \n (newline) or \t (tab)*.

*Scanner Class*

A class in the *java.util* package used to read input from the keyboard or files.

*System.out.printf*

A method used to perform *formatted console output* using format specifiers.

*Format Specifiers*

Placeholders in a format string, such as *%d (integer), %f (floating-point), or %s (string)*.

*Final Keyword*

Used to declare a *constant variable* whose value cannot be changed once initialized.

*Boolean Expression*

Any variable or calculation that results in a value of *true or false*.

*Relational Operators*

Operators used to compare values: *== (equal), != (not equal), < (less than), > (greater than), <=, and >=*.

*Logical Operators*

Operators used to combine boolean expressions: *&& (AND), || (OR), and ! (NOT)*.

*Short-Circuit Evaluation*

A process where a logical operator skips evaluating the second operand if the result is already determined by the first.

*If-Else Statement*

A structure that executes one group of statements if an expression is true and another group if it is false.

*Switch Statement*

A multiple-branch decision structure that compares a variable to constant values to determine which code to execute.

*While Loop*

A *pretest loop* that repeatedly executes a block of statements as long as a condition remains true.

*Do-While Loop*

A *posttest loop* that executes its body at least once before testing the loop condition.

*For Loop*

A loop that contains *initialization, test, and update* expressions, typically used when the number of iterations is known.

*Infinite Loop*

A loop that never stops iterating because its expression always evaluates to true.

*Sentinel Value*

A special value used to notify a program to stop acquiring input.

*Break Statement*

A statement used to immediately exit a loop or a switch structure.

*Continue Statement*

A statement that causes an immediate jump to the next iteration or condition check of a loop.

*Method*

A named list of statements that can be invoked to perform a specific task.

*Method Header*

Includes the *access modifiers, return type, method name, and parameter list*.

*Parameter*

A method input specified in the method definition.

*Argument*

The actual value provided to a method's parameter during a method call.

*Void Method*

A method that does not return a value to its caller.

*Method Overloading*

Defining multiple methods with the *same name but different parameter types*.

*Variable Scope*

The region of code where a declared name is valid and visible.

*Field (Class Member Variable)*

A variable declared within a class but outside any method, visible to all methods in that class.

*Javadoc*

A tool that parses specially formatted comments (*/ ... /**) to generate program documentation in HTML format.

*Unit Test*

An automated test used to evaluate individual small parts of a program, like specific methods.

*FileInputStream*

A class used to establish an input stream to read bytes from a file.

*PrintWriter*

A class used to write formatted text to an output stream, such as a file.

*throws IOException*

A clause added to a method header indicating it may throw an input/output exception that must be handled or passed up.

*Enumeration (Enum)*

A user-defined data type that consists of a small set of named values.

*Math Class Methods*

Standard methods like *Math.sqrt(), Math.pow(), and Math.abs()* used for complex calculations.

*Random Class*

A class used to generate *pseudo-random* numbers.

*ASCII/Unicode*

Standards for encoding characters as numbers; Java uses *Unicode*.

*Short-hand (Compound) Operators*

Operators like *+=, -=, *=, and /=* that update a variable's value based on its current value.

*Incremental Development*

The process of writing, compiling, and testing small amounts of code step-by-step to manage complexity.

*Method Stub*

A method definition with its statements not yet fully written, often used during incremental development.