< Back to AP Computer Science A Home
Printable Flash Cards for AP CSA This has most of the vocabulary needed and is already setup as flash cards, just print and review.
Bellow is a comprehensive list of vocabulary words every AP Computer Science A student should be familiar with. This list was inspired by Quizlet AP Comp Sci Vocab.
Have a vocabulary word to add to the list or a suggested edit? Email Mr. Stout.
| Term | Definition |
|---|---|
| ! | A logical operator that reverses the state of a boolean value |
| && | A logical operator that evaluates to true only if both sides are true |
| == | An operator to compare two pieces of primitive data or two addresses |
| || | A logical operator that evaluates to true if either side is true |
| abstract | A class that is never meant to be instantiated except through a concrete subclass |
| accessor | A method that returns the value of a private instance variable (aka getter) |
| add | The method for putting a new item in a list |
| addresses | The location in memory at which an object is stored |
| Aggregation | Has - A Object relation |
| algorithm | A step by step process for solving a problem |
| AND | Only true if both inputs are true |
| arithmetic operators | +, -, *, /, % |
| array | A collection of pieces of data stored as indexed items under one name |
| ArrayIndexOutOfBoundsException | An error that happens when you refer to an element number larger than your array |
| ArrayList |
A template class for keeping track of collections of data with a changing size |
| assembler | The part of the IDE that turns your code into assembly code |
| assembly language | The instruction set used by the CPU (aka machine code) |
| assign | Set a variable to a value |
| attribute | A variable property of an object (aka field) |
| autoboxing | A feature of Java that converts primitive types to their class counterpart |
| base 2 logarithm | A mathematical operation that returns what power of 2 a number is |
| base case | A condition that triggers a recursive process to end |
| base class | A class that another class inherits from (aka superclass) |
| behavior | An ability of an object (aka method) |
| Binary Search | A search technique on ordered data that cuts the list in half on each check |
| bit | A binary digit |
| block | A piece of code that is separated from the code around it |
| body | The code inside of a method |
| boolean | A type of variable or operation that evaluates to true or false |
| braces | Symbols that define the start and end of a block of code |
| break | A statement to jump outside of a loop or conditional branch |
| bugs | Problems that prevent code from working properly |
| byte | Eight bits |
| bytecode | The Java code that is ready to be processed by an interpreter |
| capacity | The amount of space allocated for a List |
| case | Identifies a code choice of a switch statement |
| cast | Forcing an expression of one data type to fit into a variable with a different type |
| catch | A keyword used to collect and handle specific types of exceptions |
| change | Setting a part of the condition to a different value so the code doesn't loop infinitely |
| char | A data type for holding a single letter, digit or symbol |
| class | Code that defines the attributes and behaviors of an object |
| class definition | All of the method headers and instance variables that make up a class |
| class declaration | The header line of a class |
| class variable | A variable that is shared among all instances of a class (aka static field) |
| client | A class that uses another class |
| column | A vertical organization of items in a 2D array, the second set of brackets |
| comments | A written description of what code does for human readers |
| Comparable |
An interface requiring compareTo that allows built-in sort and searches to be used on a class |
| comparator | A class implementing compare that creates a tool for sorting and searching |
| compare | A tool that is used to check the order between two objects passed as parameters |
| compareTo | A method that is used to check the order between an object and a single parameter |
| comparisons | When an expression or constant is checked for a relationship with another |
| compatible | Data types that contain similar enough values that they can be cast to each other |
| compiler | The part of an IDE used to change turn code into software |
| compound | A complex line of code with made of multiple expressions |
| compound assign | +=, -=, *=, /=, %= |
| concatenation | An operation that creates a new string out of other strings by sticking them together |
| concrete | A class that can be instantiated, a non abstract class |
| condition | A statement that can be evaluated to determine if a piece of code will be run |
| conditional | A statement that is dependent on an expression that evaluates to true or false |
| console application | A piece of software that runs without a GUI |
| conspicuous | Variable names that clearly describe the value they represent |
| constant | A variable that cannot change once its initial value is assigned |
| constructor | A piece of code that is run when an object is instantiated/created |
| contents | What is inside of a data set or element |
| convention | An agreed upon way of coding that is not required by the computer |
| convert | Changing values of one type into another |
| copy constructor | A special constructor that takes a parameter of the same type as the class being created |
| CPU | The "brain" of your computer. |
| data type | The kind of information that can be held in a variable |
| debugger | The part of an IDE that helps you find errors in your code |
| declaration | The line where a class, method or variable is first created |
| decrement | Decreasing a value by 1 |
| default constructor | A constructor provided by the compiler when no constructor is coded |
| DeMorgan's Laws | Rules that describe how logical operations relate and transform into each other |
| derived class | A class that inherits from another class (aka subclass) |
| digital | Using whole numbers |
| direct manipulation interface | An interface that allows the user to interact with program constructs manually |
| do-while | A type of loop with the condition at the end that always executes at least once |
| document | To create help files and comments to make notes for future users and editors |
| dot notation | A way of referencing a method or variable that is part of a class |
| double | The most common data type for decimal numbers |
| editor | The part of an IDE used to type code |
| element | A individual item in an array or list |
| empty string | A string variable that has memory allocated but no text ("") |
| encapsulation | The practice of using setters and getters to control access to private variables |
| equals | A method that compares objects to see if they are the same |
| equation | A mathematical statement that two expressions have the same value |
| evaluate | Determine the current value of an expression |
| exception | An problem that occurs while a program is running that causes it to crash |
| exception handling | Code intended to catch runtime errors and handle them to prevent a crash |
| executable | A file ready to be run as a program by an operating system |
| expression | A piece of code that will be evaluated when it is run |
| extends | A keyword that is used to cause a class to inherit from another class |
| false | The opposite of true |
| field | A variable created and stored at the object level (aka instance variable) |
| final | A keyword used for creating a constant |
| finally | A keyword that attempts to run code after an exception has happened |
| flowchart | A graphic showing the paths that execution of a program may follow |
| for | A type of loop with the initialization, condtion and chage built into the header. A fixed number of times loop. |
| for-each loop | A special code block for traversing an array or list |
| formatting | Making numbers appear in as text in a particular way |
| gate | A component that does simple binary calculations |
| generic type | A superclass type shared by multiple subclass types |
| getter | A method that returns the value of a private instance variable (aka accessor) |
| GUI | The graphical user interface for interacting with a user |
| hardware | Physical component of a device |
| HAS-A | A relationship between classes where one class is used by another |
| hierarchy | A system for organizing in which each item is a superclass and/or subclass of another item |
| high level language | A language like Java that is converted to machine code before it is executated |
| IDE | An integrated development environment that contains the tools you need to write a program |
| if-else | The keywords used for conditional branching |
| immutable | A value that cannot be changed once created |
| implementation | The final code used to solve a programming problem |
| implements | A keyword that indicates a class will perform the job of an interface |
| implicit | Something that is assumed to be the case if not stated otherwise |
| import | A keyword that allows you to use code from another package in your code |
| increment | To increase a value by a set amount |
| indentation | Shifting code to the right to indicated that it is inside a block |
| index | The number that represents each letter or element in a String, array or a List |
| IndexOutOfBoundsException | An error that happens when code accesses an element in an array that doesn't exist |
| infinite loop | A piece of code that repeats itself forever |
| information hiding | The practice of making instance variables private to protect the internals operations of the code |
| inheritance | When a subclass gets code and variables originally created in the parent class |
| initialize | Allocate the memory for an array and set up beginning values |
| Insertion Sort | A sort with O(n^2) speed that finds the correct position of each element swapping as needed |
| instance | An object based on a class that exists when a program is running |
| instance variable | A variable stored at the class level (aka field) |
| instantiate | Creating and setting up and actual instance of a class to link to its variable, uses "new" keyword |
| int | The most common data type for non decimal numbers |
| integer division | The answer for why 7/2 is 3 and not 3.5 |
| interface | A programming construct that provides headers of required methods, but no code or variables |
| interpret | Preparing a Java application to be run for a specific operating system |
| invoke | A word meaning to call a method and run its code |
| IS-A | A subclass/superclass relationship between classes |
| iteration | One of many times executing the same piece of code |
| iterative statements | Sections of code that repeat in a predictable order |
| JavaDoc | A tool that creates documentation for code using comments with special syntax and keywords |
| JDK | The Java Development Kit needed for writing Java code |
| key | A piece of data in an object used to sort on |
| length | The number of items in an array |
| length() method | Used to find the number of characters in a string |
| literal strings | Text that is written in code between quotation marks |
| local variable | A variable created inside a method or other block of code |
| logic error | A coding mistake that causes code to act differently than planned |
| logical operators | Operators that combine or compare boolean expressions (eg. &&, ||, !) |
| loop invariant | A relationship between variables that is checked to determine whether to loop again |
| loops | Any piece of code that repeats when it reaches the end |
| machine code | A CPU specific binary language (aka assembly code) |
| Mergesort | A sort with O(n log n) speed that breaks the data set in half calling itself recursively |
| method | Code that defines an ability or behavior of an object |
| minimized | Code that takes the least space possible |
| modifier | A method used to change the value of a private variable (aka setter, mutator) |
| modulus | %, An operator for finding the remainder from integer division |
| motherboard | Computer component all other parts connect to |
| mutator | A method used to change the value of a private variable (aka setter, modifer) |
| nested | Code that is inside another block of code |
| nested loop | A piece of repeating code inside another piece of repeating code |
| new operator | A keyword used when calling the constructor for an object being instantiated |
| newline | A character that tells the console to move the cursor to the next line |
| no-args constructor | An empy constructor, one that takes no parameters |
| NOT | Reverses value of the input |
| null | A keyword meaning "has no value" |
| O notation | A way of showing the relative theoretical speed of a search or sort algorithm |
| object | An instance of a class that exists when a program is running |
| object model | A planning tool used to design a class before coding it |
| object oriented programming | A programming philosophy in which code is written to represent real world things or ideas |
| OR | True if any input is true |
| order of operators | The rules that determine how the computer chooses which operations are evaluated first |
| overloaded | When a method is written in different ways with two or more possible parameter sets |
| package | A collection of java classes |
| parameter | A variable whose value or reference is passed into a method |
| parse | Move through a string one letter or word at a time |
| partitioning | The process of breaking a set into two or more pieces |
| pass by reference | When a parameter is sent as a memory location |
| pass by value | When a parameter is sent as data |
| pattern recognition | The ability to recognize a form of organization in a data set |
| peripheral | Computer part not inside the chassis |
| pivot | A value in a set used to split the set into two parts on which the data will be sorted |
| polymorphism | The concept that a single named behavior can be performed differently by various subclasses |
| primitive type | One of the built-in non-object data types that is stored by value |
| printf | A special method for Strings that includes formatting characters in the string literal |
| private | A keyword that makes a variable or method accessible from only inside the class |
| procedural language | A language where programs are expected to operate in a predictable order |
| pseudocode | A way of designing a program using written descriptions of what the code will be |
| public | A keyword that makes a variable or method accessible from outside the class |
| Quicksort | A sort with O(n log n) speed that splits the data using a randomly chosen pivot |
| RAM | Computer component that stores currently in-use data |
| readability | A measure of how easily something is understood by others |
| recursive | A piece of code that uses itself to solve the problem |
| redundancy | Allows a something to be understood even if some of it is missing or wrong |
| reference | An address that holds the memory location of the variable's data |
| regular expression | A predefined set of codes for limiting parse and search type String operations |
| relational operators | Operators that compare two expressions (eg. <>, !=, ==) |
| remove | A method for taking an item out of a list and filling any gap |
| reserved word | Special words used by the Java language that cannot be used for naming |
| return | A statement that causes a method to end and may send back a value to the calling code |
| return type | The kind of data that will be sent back by a method |
| row | A horizontal section of a 2D array, the first set of square brackets |
| scope | The part of code in which a variable exists or is accessible |
| search | Finding a particular item in a list, array or other collection |
| Selection Sort | A sort with O(n^2) speed that checks each element against every other element |
| Sequential Search | A search that checks each element from beginning to end |
| set | A method for changing the value of an item in a list |
| setter | A method that is used to change the value of a private variable (aka modifier) |
| short-circuit evaluation | A chain of relational or conditional expressions that stops evaluating as soon as the result is known |
| signature | The header line of a method that defines its return type, name and parameter list |
| size | The number of items in an ArrayList |
| software engineering | Planning, designing, building and testing computer programs |
| sorting | Putting a collection of data in order |
| source code | The original code created by the programmer |
| square brackets | Used to create arrays and refer to a specific element |
| stack | The part of the computer that keeps track currently running layers of code |
| statement | A complete and syntactically correct line of code |
| static field | A variable that is shared among all instances of a class (aka class variable) |
| static method | A method that uses no (non-static) instance variables and can be called without an instance of the class |
| String | A built-in class for holding words, sentences, parahraphes, etc. |
| style | The conventions agreed upon by programmers for how to write code to be understood by others |
| subclass | A class that inherits from another class |
| subinterface | An interface that inherits from another interface |
| subscript | A way of writing an index to an array in pseudocode |
| substring | A part of a text value |
| super | A keyword that is used to access methods and fields from a base class |
| superclass | A class that another class inherits from (aka base class) |
| superinterface | An interface that another interface inherits from |
| switch | A keyword that chooses what code to run based on a single value |
| symbolic | A name that represents another value |
| syntax | The rules for how code must be entered to compile and work |
| syntax error | A coding mistake that prevents code from compiling |
| testing | Checking the condition on a piece of code |
| this | A keyword that refers to the current instance of the class |
| transistor | A tiny on-off switch |
| transmission | Moving something from one place to another |
| traversal | The process of interacting with each element in an array or list in order |
| true | The opposite of false |
| try | A keyword that begins a block code that could cause an exception |
| Two-Dimensional Array | An array of arrays |
| uninitialized string | A string variable that is named but has nowhere to store its data |
| value | Data represented by a variable or expression |
| variable | A named value in a program that can contain a specific type of data |
| visual prototyping and design tools | Tools that allow an engineer to plan their software through drawings and flow models |
| while | A type of loop that runs as long as its condition is true |
| whitespace | Any space, tab or new line charcter in the code |
| wrapper class | A class designed to add behaviors to a primitive type |
| XOR | True if and only if one input is true |