< 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 |