Variables, Data Types & Operators

What you'll learn

Every program is really just data being stored, changed, and combined. In this module you'll learn how Java holds data in variables, the exact types that data can take, and the operators you use to calculate and compare.

By the end you'll be able to:

• Declare, initialize, and reassign variables — and lock values with final
• Choose the right primitive type for any value
• Use literals, underscores in numbers, and var type inference
• Convert between types safely with widening and narrowing casts
• Apply arithmetic, comparison, logical, and bitwise operators correctly
• Predict results using operator precedence, and use the Math class

Variables & constants

A variable is a named box in memory that holds a value. In Java every variable has a fixed type that never changes — this is what makes Java a statically typed language. You declare a variable by writing its type and name, and initialize it by giving it a value.

int age = 25;          // declare + initialize
double price = 19.99;
char grade = 'A';
boolean isJavaFun = true;

age = 26;              // reassign later
final int MAX = 100;   // constant — cannot change

System.out.println(age);
System.out.println(grade + " costs " + price);

A variable's value can change over time (that's why it's "variable"). When you want a value that must never change, mark it final — that makes it a constant. Constants are written in UPPER_SNAKE_CASE by convention.

Primitive data types

Java has 8 primitive types — the built-in building blocks for raw values. They fall into four natural groups:

Each type reserves a fixed amount of memory, which decides the range of values it can hold:

byte  small = 100;
short medium = 20_000;
int   count = 2_000_000;
long  huge = 9_000_000_000L;   // note the L

float  ratio = 3.14f;          // note the f
double precise = 3.141592653589793;

char   letter = 'J';
boolean active = false;

System.out.println(count + " / " + huge);
System.out.println(ratio + " / " + precise);

Literals, underscores & var

A literal is a fixed value written directly in code — 42, 3.14, 'A', true, "hello". To make large numbers readable you can add underscores as digit separators (the compiler ignores them): 1_000_000.

Since Java 10, you can use var for local variables and let the compiler infer the type from the value on the right. The variable is still strongly typed — you just didn't have to write the type twice.

var message = "Hello";   // inferred as String
var count = 42;          // inferred as int
var pi = 3.14;           // inferred as double

System.out.println(message.getClass().getSimpleName());
System.out.println(count + pi);

Type conversion & casting

Sometimes you need to move a value from one type to another. There are two directions, and Java treats them very differently.

Widening (small type → bigger type) happens automatically because no information can be lost. Narrowing (big type → smaller type) must be requested with an explicit cast (type) — and it can lose data or overflow, so use it deliberately.

int i = 300;
byte b = (byte) i;        // narrowing: 300 doesn't fit in a byte
System.out.println(b);    // -> 44 (overflow wraps around)

double d = 9.99;
int truncated = (int) d;  // decimals are dropped, not rounded
System.out.println(truncated);  // -> 9

System.out.println(Integer.MAX_VALUE + 1);  // overflow

Operators

Operators are the symbols that combine values. Arithmetic operators do the maths — but watch out for one classic trap:

int a = 17, b = 5;

System.out.println(a + b);          // 22
System.out.println(a - b);          // 12
System.out.println(a * b);          // 85
System.out.println(a / b);          // 3  <- integer division!
System.out.println(a % b);          // 2  <- remainder
System.out.println((double) a / b); // 3.4

Comparison operators ask a yes/no question and produce a boolean, while logical operators combine those booleans:

int age = 20;

boolean canVote = age >= 18;
boolean isTeen  = age >= 13 && age <= 19;

System.out.println(canVote);   // true
System.out.println(isTeen);    // false
System.out.println(!canVote);  // false

Java also has bitwise and shift operators that work on the individual bits of integers — useful for flags, low-level code, and performance tricks:

Operator precedence & associativity

When several operators appear together, precedence decides who goes first (just like maths: * before +). Here's the order from highest to lowest, simplified:

The Math class

For anything beyond the basic operators, Java's built-in Math class has you covered — powers, roots, rounding, trigonometry, and more. Its methods are static, so you call them straight on Math:

System.out.println(Math.max(10, 20));  // 20
System.out.println(Math.min(10, 20));  // 10
System.out.println(Math.abs(-7));      // 7
System.out.println(Math.pow(2, 10));   // 1024.0
System.out.println(Math.sqrt(144));    // 12.0
System.out.println(Math.round(3.6));   // 4

Recap & quick check

Great work — you can now store and manipulate data with confidence. Next up: Module 3 — Input, Output & Strings, where your programs start talking to the user and working with text.