Update VOCABULARY.md

Author: Gloomcaller

VOCABULARY.md

@@ -1,89 +1,173 @@
-**address**: The location of a value in computer memory, often represented as a hexadecimal integer.
-**algorithm**: A procedure or formula for solving a problem, with or without a computer.
-**abstract class**: A class that is declared as abstract; it cannot be instantiated, and it may (or may not) include abstract methods.
-**argument**: A value that you provide when you call a method. This value must have the type that the method expects.
-**assignment**: A statement that gives a value to a variable.
+**Address**: The location of a value in computer memory, often represented as a hexadecimal integer.
+
+**Algorithm**: A procedure or formula for solving a problem, with or without a computer.
+
+**Abstract class**: A class that is declared as abstract; it cannot be instantiated, and it may (or may not) include abstract methods.
+
+**Argument**: A value that you provide when you call a method. This value must have the type that the method expects.
+
+**Assignment**: A statement that gives a value to a variable.
+
 **AWT**: The “Abstract Window Toolkit”, a Java package for creating graphical user interfaces.
-**binary**: A system that uses only zeros and ones to represent numbers. Also known as “base 2”.
-**binary search**: An algorithm that searches a sorted array by starting in the middle, comparing an element to the target, and eliminating half of the remaining elements.
-**block**: A sequence of statements, surrounded by braces, that generally runs as the result of a condition.
-**branch**: One of the alternative blocks after a conditional statement. For example, an if-else statement has two branches.
-**bug**: An error in a program.
-**base case**: A condition that causes a recursive method not to make another recursive call.
-**class**: A template for a new type of object, containing both attributes and methods.
-**compile**: To translate a program in a high-level language into a low-level language, all at once, in preparation for later execution.
-**compile-time error**: An error in the source code that makes it impossible to compile. Also called a “syntax error”.
-**concatenate**: To join two values, often strings, end to end.
-**conditional statement**: A statement that uses a condition to determine which statements to execute.
-**constructor**: A special method that initializes the instance variables of a newly constructed object.
-**client**: A class that uses objects defined in another class.
-**class diagram**: An illustration of the attributes and methods for a class.
-**compile-time error**: An error in the source code that makes it impossible to compile. Also called a “syntax error”.
-**concatenate**: To join two values, often strings, end to end.
-**constant**: A variable, declared as final, whose value cannot be changed.
-**debugging**: The process of finding and removing errors.
-**declaration**: A statement that creates a new variable and specifies its type.
-**dot notation**: Use of the dot operator (.) to access an object’s attributes or methods.
-**decrement**: Decrease the value of a variable.
-**dynamic memory**: Memory that is allocated at runtime, such as with arrays or objects.
-**encapsulate**: To wrap data inside an object, or to wrap statements inside a method.
-**expression**: A combination of variables, operators, and values that represents a single value. Expressions also have types, as determined by their operators and operands.
-**equivalent**: Objects that are equal in value, as defined by the equals method.
-**executable**: Another name for object code that is ready to run on specific hardware.
-**flag**: A variable (usually boolean) that represents a condition or status.
-**floating-point**: A data type that represents numbers with an integer part and a fractional part. In Java, the default floating-point type is double.
-**format specifier**: A special code that begins with a percent sign and specifies the data type and format of the corresponding value.
-**function**: A part of a program that performs a specific task or computation.
-**garbage collection**: The process of finding objects that have no references and reclaiming their storage space.
-**getter**: A method that returns the value of an instance variable.
-**hacker**: A programmer who breaks into computer systems. The term hacker may also apply to someone who enjoys writing code.
-**helper method**: A method that implements part of a more complex algorithm; often it is not particularly useful on its own.
+
+**Binary**: A system that uses only zeros and ones to represent numbers. Also known as “base 2”.
+
+**Binary search**: An algorithm that searches a sorted array by starting in the middle, comparing an element to the target, and eliminating half of the remaining elements.
+
+**Block**: A sequence of statements, surrounded by braces, that generally runs as the result of a condition.
+
+**Branch**: One of the alternative blocks after a conditional statement. For example, an if-else statement has two branches.
+
+**Bug**: An error in a program.
+
+**Base case**: A condition that causes a recursive method not to make another recursive call.
+
+**Class**: A template for a new type of object, containing both attributes and methods.
+
+**Compile**: To translate a program in a high-level language into a low-level language, all at once, in preparation for later execution.
+
+**Compile-time error**: An error in the source code that makes it impossible to compile. Also called a “syntax error”.
+
+**Concatenate**: To join two values, often strings, end to end.
+
+**Conditional statement**: A statement that uses a condition to determine which statements to execute.
+
+**Constructor**: A special method that initializes the instance variables of a newly constructed object.
+
+**Client**: A class that uses objects defined in another class.
+
+**Class diagram**: An illustration of the attributes and methods for a class.
+
+**Constant**: A variable, declared as final, whose value cannot be changed.
+
+**Debugging**: The process of finding and removing errors.
+
+**Declaration**: A statement that creates a new variable and specifies its type.
+
+**Dot notation**: Use of the dot operator (.) to access an object’s attributes or methods.
+
+**Decrement**: Decrease the value of a variable.
+
+**Dynamic memory**: Memory that is allocated at runtime, such as with arrays or objects.
+
+**Encapsulate**: To wrap data inside an object, or to wrap statements inside a method.
+
+**Expression**: A combination of variables, operators, and values that represents a single value. Expressions also have types, as determined by their operators and operands.
+
+**Equivalent**: Objects that are equal in value, as defined by the equals method.
+
+**Executable**: Another name for object code that is ready to run on specific hardware.
+
+**Flag**: A variable (usually boolean) that represents a condition or status.
+
+**Floating-point**: A data type that represents numbers with an integer part and a fractional part. In Java, the default floating-point type is double.
+
+**Format specifier**: A special code that begins with a percent sign and specifies the data type and format of the corresponding value.
+
+**Function**: A part of a program that performs a specific task or computation.
+
+**Garbage collection**: The process of finding objects that have no references and reclaiming their storage space.
+
+**Getter**: A method that returns the value of an instance variable.
+
+**Hacker**: A programmer who breaks into computer systems. The term hacker may also apply to someone who enjoys writing code.
+
+**Helper method**: A method that implements part of a more complex algorithm; often it is not particularly useful on its own.
+
 **IDE**: An “integrated development environment” that includes tools for editing, compiling, and debugging programs.
-**inheritance**: The ability to define a new class that has the same instance variables and methods of an existing class.
-**instance**: A member of a class. Every object is an instance of a class.
-**instance method**: A non-static method that has access to this and the instance variables.
-**instance variable**: An attribute of an object; a non-static variable defined at the class level.
-**immutable**: An object that, once created, cannot be modified. Strings are immutable by design.
-**import statement**: A statement that allows programs to use classes defined in other packages.
+
+**Inheritance**: The ability to define a new class that has the same instance variables and methods of an existing class.
+
+**Instance**: A member of a class. Every object is an instance of a class.
+
+**Instance method**: A non-static method that has access to this and the instance variables.
+
+**Instance variable**: An attribute of an object; a non-static variable defined at the class level.
+
+**Immutable**: An object that, once created, cannot be modified. Strings are immutable by design.
+
+**Import statement**: A statement that allows programs to use classes defined in other packages.
+
 **JAR**: A “Java Archive”, which is essentially a ZIP file containing classes and other resources.
+
 **JDK**: The “Java Development Kit”, which contains the compiler, Javadoc, and other tools.
+
 **JVM**: The “Java Virtual Machine”, which interprets the compiled byte code.
-**keyword**: A reserved word used by the compiler to analyze programs. You cannot use keywords (like public, class, and void) as variable names.
-**literal**: A value that appears in source code. For example, "Hello" is a string literal, and 74 is an integer literal.
-**loop**: A statement that executes a sequence of statements repeatedly.
-**local variable**: A variable declared inside a method. Local variables cannot be accessed from outside their method.
-**loop body**: The statements inside the loop.
-**logic error**: An error in a program that makes it do something other than what the programmer intended.
-**method**: A named sequence of statements.
-**memory diagram**: A graphical representation of the state of a program at a point in time.
-**method signature**: The first line of a method that defines its name, return type, and parameters.
-**merge sort**: A recursive sorting algorithm that divides an array into two parts, sorts each part (using merge sort), and merges the results.
+
+**Keyword**: A reserved word used by the compiler to analyze programs. You cannot use keywords (like public, class, and void) as variable names.
+
+**Literal**: A value that appears in source code. For example, "Hello" is a string literal, and 74 is an integer literal.
+
+**Loop**: A statement that executes a sequence of statements repeatedly.
+
+**Local variable**: A variable declared inside a method. Local variables cannot be accessed from outside their method.
+
+**Loop body**: The statements inside the loop.
+
+**Logic error**: An error in a program that makes it do something other than what the programmer intended.
+
+**Method**: A named sequence of statements.
+
+**Memory diagram**: A graphical representation of the state of a program at a point in time.
+
+**Method signature**: The first line of a method that defines its name, return type, and parameters.
+
+**Merge sort**: A recursive sorting algorithm that divides an array into two parts, sorts each part (using merge sort), and merges the results.
+
 **NaN**: A special floating-point value that stands for “not a number”.
-**newline**: A special character signifying the end of a line of text. Also known as “line ending”, “end of line” (EOL), or “line break”.
-**nesting**: Putting a conditional statement inside one or both branches of another conditional statement.
-**object**: A collection of related data that comes with a set of methods that operate on the data.
-**operator**: A symbol that represents a computation like addition, multiplication, or string concatenation.
-**object-oriented**: A way of organizing code and data into objects, rather than independent methods.
-**parameter**: A piece of information that a method requires before it can run.
-**parse**: To analyze the structure of a program; what the compiler does first.
-**primitive**: A data type that stores a single value and provides no methods.
-**polymorphism**: A language feature that allows objects to be assigned to variables of related types.
-**query**: A request for data from a database or other data source.
-**return type**: The type of value a method returns.
-**recursion**: A method or algorithm that invokes itself one or more times with different arguments.
-**refactor**: To restructure or reorganize existing source code without changing its behavior.
-**recursive**: A method or algorithm that invokes itself one or more times with different arguments.
-**row-major order**: Storing data in a 2D array, first by rows and then by columns.
-**scope**: The area of a program where a variable can be used.
-**stack diagram**: A graphical representation of the variables belonging to each method. The method calls are “stacked” from top to bottom, in the flow of execution.
-**static context**: The parts of a class that run without reference to a specific instance of the class.
-**temporary variable**: A short-lived variable, often used for debugging.
-**top-down design**: Breaking down a problem into subproblems, and solving each subproblem one at a time.
-**token**: The smallest unit of source code, such as an individual word, literal value, or symbol.
+
+**Newline**: A special character signifying the end of a line of text. Also known as “line ending”, “end of line” (EOL), or “line break”.
+
+**Nesting**: Putting a conditional statement inside one or both branches of another conditional statement.
+
+**Object**: A collection of related data that comes with a set of methods that operate on the data.
+
+**Operator**: A symbol that represents a computation like addition, multiplication, or string concatenation.
+
+**Object-oriented**: A way of organizing code and data into objects, rather than independent methods.
+
+**Parameter**: A piece of information that a method requires before it can run.
+
+**Parse**: To analyze the structure of a program; what the compiler does first.
+
+**Primitive**: A data type that stores a single value and provides no methods.
+
+**Polymorphism**: A language feature that allows objects to be assigned to variables of related types.
+
+**Query**: A request for data from a database or other data source.
+
+**Return type**: The type of value a method returns.
+
+**Recursion**: A method or algorithm that invokes itself one or more times with different arguments.
+
+**Refactor**: To restructure or reorganize existing source code without changing its behavior.
+
+**Recursive**: A method or algorithm that invokes itself one or more times with different arguments.
+
+**Row-major order**: Storing data in a 2D array, first by rows and then by columns.
+
+**Scope**: The area of a program where a variable can be used.
+
+**Stack diagram**: A graphical representation of the variables belonging to each method. The method calls are “stacked” from top to bottom, in the flow of execution.
+
+**Static context**: The parts of a class that run without reference to a specific instance of the class.
+
+**Temporary variable**: A short-lived variable, often used for debugging.
+
+**Top-down design**: Breaking down a problem into subproblems, and solving each subproblem one at a time.
+
+**Token**: The smallest unit of source code, such as an individual word, literal value, or symbol.
+
 **UML**: Unified Modeling Language, a standard way to draw diagrams for software engineering.
-**unit test**: Code that exercises a single method of a program, testing for correctness and/or efficiency.
-**value**: A number, string, or other data that can be stored in a variable. Every value belongs to a type (e.g., int or String).
-**validate**: To confirm that an input value is of the correct type and within the expected range.
-**virtual machine**: An emulation of a real machine. The JVM enables a computer to run Java programs.
-**wildcard**: A command-line feature that allows you to specify a pattern of filenames by using the * character.
-**zero-based index**: Indexing convention in which the first element of an array is accessed using the index 0.
+
+**Unit test**: Code that exercises a single method of a program, testing for correctness and/or efficiency.
+
+**Value**: A number, string, or other data that can be stored in a variable. Every value belongs to a type (e.g., int or String).
+
+**Validate**: To confirm that an input value is of the correct type and within the expected range.
+
+**Virtual machine**: An emulation of a real machine. The JVM enables a computer to run Java programs.
+
+**Wildcard**: A command-line feature that allows you to specify a pattern of filenames by using the * character.
+
+**Zero-based index**: Indexing convention in which the first element of an array is accessed using the index 0.