Variables, Data Types, and Operators
In Java, every data value has a clearly defined type. Java is a statically typed language, meaning that every variableβs type must be explicitly declared and cannot change during execution.
1. Variable and Constant Declaration
A variable is a reserved memory space for storing information.
// Declaration and initialization
int age = 25;
double price = 99.99;
boolean isStudent = true;
char initial = 'F';
// Constant (value cannot be changed after assignment)
final double PI = 3.14159;
2. Scope, visibility, and lifetime
Scope is the region of code where a name can be used. Visibility answers from which lines that name is accessible; lifetime states how long its value exists during execution. These concepts are related but not identical.
Java uses lexical scopes defined by classes, methods, and { } blocks. There are no free global variables in Java: every value declared outside a method belongs to a class or to an instance of that class.
| Category | Declaration | Visibility | Lifetime | Initialization |
|---|---|---|---|---|
| Local variable | Inside a method | From its declaration to the end of its block | During that invocation and block | Has no default value; definite assignment is required. |
| Block-scope variable | Inside an if, for, while, or explicit block | Only inside that block | Until the block ends | Same rule as any local variable. |
| Parameter | In a method or constructor signature | Throughout that method body | During the invocation | Receives the argument value. |
| Instance field | In the class, without static | According to its access modifier | While the object remains reachable | Receives a default value if not assigned. |
| Class field | In the class, with static | According to its access modifier | From class loading onward | Receives a default value if not assigned. |
Numeric fields receive 0, booleans receive false, and references receive null. This does not mean those values are valid for the domain: a constructor should explicitly establish required state.
Complete example and shadowing
public final class Account {
private static int accountCount = 0; // Class field
private int balance; // Instance field
public Account(int balance) { // Parameter
if (balance < 0) {
System.out.println("Invalid balance, used 0 by default.");
balance = 0;
}
this.balance = balance; // this.balance selects the field
accountCount++;
}
public void credit(int amount) {
if (amount <= 0) {
System.out.println("Invalid amount, nothing was credited.");
return;
}
int previousBalance = balance; // Local variable
balance += amount;
if (balance < previousBalance) {
System.out.println("Overflow detected, the operation was discarded.");
balance = previousBalance;
}
}
}
The balance parameter shadows the field with the same name. this.balance explicitly selects the instance field. Shadowing is legal, but overusing it makes it harder to see which value changes.
A block also limits names:
if (age >= 18) {
String message = "Access granted";
System.out.println(message);
}
// System.out.println(message); // Does not compile: message is not visible here.
Initialization rules and clear failures
Java applies definite assignment to locals: the compiler must prove that they received a value before they are read.
int result;
// System.out.println(result); // Does not compile: it may be uninitialized.
int safeResult = 0; // Correct only when 0 is a valid domain value.
Do not add an arbitrary default merely to silence the compiler without saying so. If required data is missing, validate it explicitly: print a notice and use a documented default value, as the Account constructor does. For optional data, choose and document a genuinely neutral value.
3. Primitive Types vs. Reference Types
Java categorizes data types into two main groups:
Primitive Types (Store direct values)
| Type | Size | Range / Example |
|---|---|---|
byte | 8 bits | -128 to 127 |
short | 16 bits | -32,768 to 32,767 |
int | 32 bits | -2,147,483,648 to 2,147,483,647 |
long | 64 bits | Large integers (e.g., 10000000000L) |
float | 32 bits | Single-precision floating point (e.g., 3.14f) |
double | 64 bits | Double-precision floating point (e.g., 3.14159265) |
boolean | 1 bit | true or false |
char | 16 bits | Single Unicode character (e.g., 'A') |
Reference Types (Store memory addresses to objects)
Examples: String, Arrays, and any custom class.
String name = "Facundo"; // Reference to a String object
4. Type Casting
- Implicit Casting (Widening): Smaller type to larger type (automatic).
int intValue = 10; double doubleValue = intValue; // 10.0 - Explicit Casting (Narrowing): Larger type to smaller type (requires
(type)syntax).double exactPrice = 45.89; int roundedPrice = (int) exactPrice; // 45 (loses fractional part)
5. Java Operators
Arithmetic Operators
+, -, *, /, % (modulus / remainder).
int a = 10;
int b = 3;
int quotient = a / b; // 3
int remainder = a % b; // 1
Relational and Logical Operators
- Relational:
==,!=,>,<,>=,<= - Logical:
&&(AND),||(OR),!(NOT)
boolean isAdult = age >= 18;
boolean canAccess = isAdult && isStudent;
6. Hands-on Exercise
Write a program that declares the grades for three exams of a student, calculates their average using floating-point numbers (double), and prints whether the student passed (average >= 6.0) using a boolean expression.
Go deeper with real code
You can reinforce this lesson by browsing complete, runnable programs in the course repository: l02_variables_tipos_datos_y_operadores.
There you will find eight short programs on primitive data types, wrapper classes, autoboxing and unboxing, text and unit conversion, and arithmetic, relational and logical operators.
Clone the repository, open the folder and run each program while you read the lesson to see every concept in action.