Glossary / Key Terms

The full toolkit for Java developers. Includes the compiler (javac), the JRE, and development tools. You need this installed to write and compile Java programs.

The subset of the JDK needed to run Java programs. Contains the JVM and standard libraries, but not the compiler. End users only need this.

The engine that actually runs your Java bytecode. Each operating system has its own JVM, which is how Java achieves "Write Once, Run Anywhere."

The intermediate code produced by the Java compiler. It is not human-readable and not machine code — the JVM translates it to machine instructions at runtime.

The program that converts your .java source code into .class bytecode files. It also checks for syntax errors before creating the bytecode.

The human-readable Java code you write in .java files. This is what gets compiled into bytecode.

A text file containing your Java source code. The filename must match the public class name inside it.

The compiled bytecode file produced by javac. This is what the JVM reads and executes. You never edit these directly.

The entry point of every Java program. The JVM looks for this exact signature to start execution.

A container for your code in Java. Every Java file must have at least one class, and the filename must match the public class name.

A folder-like grouping that organizes your Java classes. Written in lowercase with dots as separators (e.g., com.pluralsight.app).

A statement that lets you use classes from other packages without typing their full name every time.

A named container that holds a value in memory. You must declare its type before using it.

Tells Java what kind of value a variable can hold (number, text, true/false, etc.) and how much memory to reserve for it.

One of Java's 8 built-in basic types that store simple values directly in memory: byte, short, int, long, float, double, boolean, char.

The 8 primitive types. int (whole numbers) and double (decimal numbers) are the most commonly used. boolean holds true/false. char holds a single character.

A sequence of characters (text). Unlike primitives, String is a reference type — the variable holds a reference to the text in memory, not the text itself. Always use .equals() to compare Strings, not ==.

The final keyword makes a variable's value unchangeable after it is assigned. By convention, constant names use ALL_CAPS.

A fixed value written directly in your code. Examples: 42 is an int literal, 3.14 is a double literal, "hello" is a String literal.

Automatic conversion from a smaller type to a larger type. No data is lost, so Java does it for you without any special syntax.

Converting from a larger type to a smaller type. Data might be lost (e.g., decimals get truncated), so you must use a cast to tell Java you accept the risk.

Explicitly converting a value from one type to another using parentheses with the target type. Required for narrowing conversions.

Math operators for addition, subtraction, multiplication, division, and modulo (remainder). When both operands are int, division truncates the decimal.

Returns the remainder after division. Useful for checking even/odd, cycling through values, or wrapping around ranges.

Stores the value on the right side into the variable on the left. This is not the same as "equals" in math — it means "assign."

Shorthand that combines an arithmetic operation with assignment. x += 3 means the same as x = x + 3.

Adds 1 or subtracts 1 from a variable. Can be prefix (++x) or postfix (x++).

++x increments first, then returns the new value. x++ returns the current value first, then increments. The difference matters when used inside an expression.

Using + to join Strings together, or to join a String with another value. Java automatically converts the non-String side to text.

Compare two values and return true or false. Used in if statements and loops. For Strings, use .equals() instead of ==.

&& (AND) requires both sides true. || (OR) requires at least one side true. ! (NOT) flips true to false and vice versa.

A compact one-line if/else. Syntax: condition ? valueIfTrue : valueIfFalse.

A class from java.util that reads user input from the keyboard (System.in). Create one in main and pass it to other methods that need input.

Prints text to the console followed by a new line. This is the standard way to display output and prompts in this course.

The standard input stream — represents keyboard input. You pass it to Scanner to read what the user types.

Scanner methods that read different types of input. nextLine() reads a full line of text. nextInt() and nextDouble() read numbers but leave the newline character in the buffer.

Formatted output using placeholders: %d for integers, %f for decimals, %s for strings, %.2f for 2 decimal places.

The invisible newline characters at the end of each line of input. On Windows, this is both a Carriage Return and Line Feed (\\r\\n). Understanding this explains the Scanner buffer problem.

Scanner stores incoming input in a buffer. When nextInt() reads a number, it leaves the newline in the buffer. A following nextLine() picks up that leftover newline and appears to "skip." Fix: add an extra scanner.nextLine() after nextInt().

Runs a block of code only when a condition is true. The most basic way to make decisions in your program.

Adds an alternative block that runs when the condition is false. Exactly one of the two blocks will always execute.

Chains multiple conditions together. Java checks each one in order and runs the first block whose condition is true.

An alternative to long if/else chains when comparing one variable against specific values. Cleaner for menus and category-based logic.

case defines a value to match. break exits the switch (without it, execution "falls through" to the next case). default runs if no case matches.

When a case block is missing break, execution continues into the next case. This is usually a bug, but sometimes used intentionally to group cases.

A modern switch syntax using -> instead of : and break. No fall-through risk — each case runs only its own code.

A named block of code that performs a specific task. Methods let you organize code into reusable pieces instead of repeating yourself.

The combination of the method's name and its parameter list. Java uses this to identify which method you are calling.

A parameter is the variable in the method definition. An argument is the actual value you pass when calling the method.

Declared before the method name, it tells Java what type of value the method sends back. If the method returns nothing, use void.

A return type meaning the method does not return a value. Used for methods that just perform an action (like printing).

Sends a value back to the caller and exits the method immediately. The returned value must match the method's declared return type.

A method that belongs to the class, not to an object. You can call it without creating an instance. In Week 1, all your methods are static because you haven't learned objects yet.

Running a method by writing its name followed by parentheses with any required arguments. Execution jumps to that method and returns when it finishes.

A "stack" of method frames that tracks which methods are currently running. When you call a method, a new frame is pushed on. When it returns, the frame is popped off. The bottom is always main().

A principle: if you write the same code in multiple places, extract it into a method. This makes code easier to maintain and less error-prone.

A distributed version control system that tracks changes to your files over time. You interact with Git through the IntelliJ GUI — the Commit panel, push, pull, and file color indicators.

A project folder tracked by Git. It contains your files plus a hidden .git folder that stores the full history of every change.

A snapshot of your project at a specific point in time. Each commit has a message describing what changed. You can always go back to any previous commit.

Push uploads your local commits to the remote server (GitHub). Pull downloads new commits from the remote to your local machine.

A copy of your repository hosted on a server (like GitHub). The default remote is named "origin." Push sends your commits there; pull brings commits down.

An independent line of development. The default branch is main. Branches let multiple people work on different features without interfering with each other.

A system where every developer has a complete copy of the project history on their own machine. If the server goes down, no work is lost.

A website that hosts Git repositories online. You use "Share Project on GitHub" from IntelliJ to upload your project, and push/pull to keep it synced.

A build tool that manages your Java project structure, dependencies, and compilation. IntelliJ uses Maven to organize the standard folder layout.

The Maven configuration file at the root of your project. It defines the project name, version, and any external libraries (dependencies) your project uses.

The standard folder where your Java source code lives in a Maven project. All your .java files go here, organized by package.

The standard folder for test code in a Maven project. Test files verify that your main code works correctly. You will learn testing in a later module.

Group ID identifies your organization (e.g., com.pluralsight). Artifact ID is the name of your specific project. Together they uniquely identify your project in Maven.