Create VOCABULARY

Author: Gloomcaller

VOCABULARY

@@ -0,0 +1,89 @@
+**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.
+**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.
+**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.
+**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.
+**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.